Weld & Arrow context snapshot Source commit: 54eb05a Built at: 2026-07-07T22:11:19.163Z Frozen snapshot of https://github.com/weld-and-arrow/weld-and-arrow. Files: - Exposition/Theory.md - WeldAndArrow.lean - WeldAndArrow/Consequences.lean - WeldAndArrow/Consequences/Basic.lean - WeldAndArrow/Consequences/Compounds.lean - WeldAndArrow/Consequences/ContentRows.lean - WeldAndArrow/Consequences/FoxCase.lean - WeldAndArrow/Consequences/Ladder.lean - WeldAndArrow/Consequences/Taxonomy.lean - WeldAndArrow/Doctrines.lean - WeldAndArrow/Doctrines/Correlations.lean - WeldAndArrow/Doctrines/CorrelationsNegative.lean - WeldAndArrow/Doctrines/Deliberation.lean - WeldAndArrow/Doctrines/Ethics.lean - WeldAndArrow/Doctrines/EthicsNegative.lean - WeldAndArrow/Doctrines/Factors.lean - WeldAndArrow/Doctrines/FactorsNegative.lean - WeldAndArrow/Doctrines/Faith.lean - WeldAndArrow/Doctrines/FaithNegative.lean - WeldAndArrow/Doctrines/Fetters.lean - WeldAndArrow/Doctrines/FettersNegative.lean - WeldAndArrow/Doctrines/FourTruths.lean - WeldAndArrow/Doctrines/FoxCase.lean - WeldAndArrow/Doctrines/Gradeability.lean - WeldAndArrow/Doctrines/Icchantika.lean - WeldAndArrow/Doctrines/Ledger.lean - WeldAndArrow/Doctrines/OtherPower.lean - WeldAndArrow/Doctrines/OtherPowerNegative.lean - WeldAndArrow/Doctrines/Sraddha.lean - WeldAndArrow/Doctrines/SraddhaNegative.lean - WeldAndArrow/Doctrines/SuddenGradual.lean - WeldAndArrow/Doctrines/SuddenGradualNegative.lean - WeldAndArrow/Exposition.lean - WeldAndArrow/Exposition/Basic.lean - WeldAndArrow/Exposition/Docs.lean - WeldAndArrow/Exposition/Formalization/Reading.lean - WeldAndArrow/Exposition/Glossary.lean - WeldAndArrow/Exposition/Identification.lean - WeldAndArrow/Exposition/Index.lean - WeldAndArrow/Exposition/ResidueLedger.lean - WeldAndArrow/Exposition/Theorems.lean - WeldAndArrow/Exposition/Theory.lean - WeldAndArrow/Exposition/Thesis.lean - WeldAndArrow/Exposition/Verify.lean - WeldAndArrow/Gen/Assumptions.lean - WeldAndArrow/Gen/AssumptionsLib.lean - WeldAndArrow/Gen/Exposition.lean - WeldAndArrow/Gen/ExpositionLib.lean - WeldAndArrow/Gen/FullExpositionGeneration.lean - WeldAndArrow/Gen/Glossary.lean - WeldAndArrow/Identification.lean - WeldAndArrow/Identification/Absences.lean - WeldAndArrow/Identification/Commentary.lean - WeldAndArrow/Identification/Disclaimers.lean - WeldAndArrow/Identification/Ownership.lean - WeldAndArrow/Identification/Placements.lean - WeldAndArrow/Identification/Registers.lean - WeldAndArrow/Identification/Residues.lean - WeldAndArrow/Meta.lean - WeldAndArrow/Meta/AssumptionLedger.lean - WeldAndArrow/Meta/Audit.lean - WeldAndArrow/Meta/Glossary.lean - WeldAndArrow/Meta/Invariance.lean - WeldAndArrow/Meta/InvarianceNegative.lean - WeldAndArrow/Meta/Nishitani.lean - WeldAndArrow/Meta/ReflexivityWitness.lean - WeldAndArrow/Meta/VerdictLedger.lean - WeldAndArrow/Signature.lean - WeldAndArrow/Signature/Assumptions.lean - WeldAndArrow/Signature/BeingConvention.lean - WeldAndArrow/Signature/Claims.lean - WeldAndArrow/Signature/DirectionConvention.lean - WeldAndArrow/Signature/Grid.lean - WeldAndArrow/Signature/Models.lean - WeldAndArrow/Signature/Order.lean - lakefile.toml - LICENSE ===== CONTEXT ===== ===== FILE: Exposition/Theory.md ===== # Weld and Arrow — I. Theory *An ontology-under-erasure act-grammar for Zen. First of three files: **Theory** (this file), **Theorems**, **Identification**. Cross-references to the companion files are marked (Theorems) and (Identification).* ## Abstract *Weld and Arrow* (hereafter *WAA*) is a soteriological metaphysics with no substrate and no value, developed in Lean and exposited in prose: take one emptiness posit and follow what it forces for karma, action, suffering, and awakening. The apparatus is a deliberately small grid — a field that carries every diachronic connection without carrying an owner, and welds, single occurrences of answering a call, at which every index is made, spent, and never stored. The claim, made precise across these files, is this: **Everything diachronic belongs to the field; every index is enacted and nothing indexed is stored; karma names this loop, and the naming is earned by fit** — the tradition's uses of karmic ownership (cetanā, reception, remorse, absolution, dedication) discharge natively at act-time. Three registers keep the books — the field carries, the weld makes and spends, the grade states — and the grade's statements are index-placements in a third-personal register, held by no one, since a statement holds nothing. One rule, separate under act-time diagnosis and fuse at the floor, generates the entire error-taxonomy as collapse/freeze pairs, one per distinction, nothing listed by hand — and the generator keeps a ledger on itself, its retypes, declines, and falsifier on record. From the rules alone fall backsliding (kenshō cannot be held), memory and prudence met as theorems, dukkha derived as the mismatch a nonzero self-share enacts against a delivery-register no act commands, and the terminus transposed rather than declined. On existing discourses' own ground, the grid decomposes MMK 17's two worries, takes the three killings as an experimentum crucis for weld-grading across maximal event-divergence, and types other-power, pariṇāmanā, the Ten Bulls, the Five Ranks, and the stage-schemes as checked correlations — coarsenings legal to read and illegal to hold. The development is Lean-first: a layered library (Signature → Consequences → Doctrines → Identification → Meta → Exposition) in which the storage claim is enforced at type level, every reading is gated by a sibling countermodel, the taxonomy's rows and the verdict history are inspectable data, and the audit pins the theorem surface and its axiom footprint; the prose is generated from the Exposition layer and reads the checked surface. Throughout, what the system asserts is grammar; what it can only display is worth — no value appears in its own voice, the valence its vocabulary carries being the object's, reported. This is a fresh theory, not an exegesis of Abhidharma nor a reconstruction of Dōgen; the lens is minimalist by design, and other doctrines can and do hold too. ## The rules, each preceded by what motivated it ### Not Nothing Per Nishitani — absolute non-being is not a privative void but lies beyond the being/non-being distinction. What stands in its place is the *provisionally-designated middle*. ### Provisionally-designated middle Jizang — the ultimate is the self-emptying floor; every level is conventional (Nāgārjuna's *Mūlamadhyamakakārikā*, MMK 24: emptiness = dependent origination = conventional designation), and the two-truths distinction is itself conventional — Jizang's fourfold two truths (四重二諦), each pair re-emptied as merely conventional at the next level, so no level is a final floor. This is **genjō**, the provisional middle: manifestation, always going out into a particular case. Distinct from it, and never equated with it, is the **non-attaining middle** at the floor. Read Linji's 無位真人 along its own seam: 無位 (no rank) is the floor-face — no metaphysical rank, anātman; 真人…出入 (the true person going in and out) is the *acting*; and the whole compound 無位真人 is the weld of the two — shushō-ittō, the true person going in and out. The non-attaining middle is the 無位 alone — **shō**: realization as anātman, agential only because welded, never a still attainment. It is *not* the whole true-person, which is the weld (reading 無位真人 as a rank one rests at is exactly the reification Linji shoves off as 乾屎橛 — the more common reading takes the shit-stick as shock-deflation of the *question* itself rather than of rank-reification specifically; the rank-reading is compatible with it and is the one used here). Two middles, then: genjō provisional, shō non-attaining. The system turns on keeping them apart — but *at act-time*, and by the same separate/fuse rule that governs everything here (stated as a rule below): the two-middles distinction is itself a conventional-tier diagnosis. It separates under act-time diagnosis, where *which middle?* is live, and fuses at the floor and at genjō. "Keeping them apart" is an act-time imperative, not a final floor-claim. ### The act-grammar Why not leave it at Jizang? Per Dahui, Zen doesn't cease at the self-emptying floor: emptiness that only empties can host neither Zen activity nor the vibrant person who acts. So the floor is turned into an act-grammar, here using Dōgen's vocabulary. Three rows, each a dependence/enactment pair; all three conventional. | Dependence | Enactment | |---|---| | **mujishō-sōe** — no-own-being as mutual-dependence; each-in-all, no substrate. | **genjō** — manifesting entire: the act out in its case with nothing of it claimed back; full = no remainder of arrogation, which is why one floor holds both arrivals.; the seam where the scaffold dissolves. | | **kannō-sōe** — resonance as mutual-dependence; the placement of the act's index between the being and the dharmas (*how much of the listening to Hyakujō is the self doing?*). | **banpō susumite** — the myriad dharmas advancing — the reception practising, the self verified — one act, two poles of one placement. | | **engi / inga** — directedness with no moral ground; the blind arrow. | **shu** — practice (gyōji); the weld at act-time, direction bound along the blind arrow, *and the I-making that indexes it*; not-obscure (不昧). | *(kannō-sōe rather than the canonical kannō-dōkō, to keep the coupling connotation-light: the -sōe already carries mutual-dependence.)* The floor is emptiness that empties even itself (Jizang, 空空): the ultimate is never a thing, never a final substrate. Everything here is conventional — the path, the grid's distinctions, the two truths themselves — and no level stands as the last floor. The enactment column is not three agents. Its three cells are the three parts of one sentence of Dōgen's — *carrying the self forward to practice-realize the myriad dharmas is delusion; the myriad dharmas advancing (banpō susumite) to practice-realize the self is satori.* genjō (Row 1) is the actualizing; banpō susumite (Row 2) is the dharmas-forward that clarifies the self; shu (Row 3) is practice. And the sentence's sequel fixes shō's grammar: *to forget the self is to be verified by the myriad dharmas* — 万法に証せらるる, 証 in the **passive voice**. Realization, in the very line the grid mines, is objecthood — the self standing where the dharmas' advance certifies it. The grid spends this below. Dōgen's compounds then name the *relations* among the cells, not the cells: - **genjōkōan** = genjō + kōan — Row 1's manifestation in Row 2's particular case (*can this being listen to Hyakujō?*). - **shugenjō** = shu + genjō — Row 3 practice as Row 1 manifestation: *practice run scaffold-free is nothing but genjō* — and not conversely, since genjō also holds what never practised (the stone). The "nothing but" runs from the narrower to the wider: {practice run scaffold-free} ⊊ {genjō}. - **shushō** = shu + shō — the weld (below). Here shō is 証 — realization-as-not-fall, the floor-face — *not* 悟 (satori, the awakening named in the Dōgen sentence just above), and *not* genjō, but the floor's non-attaining middle: anātman — and, per the passive above, the act's subject-position ceded: shō is the *being-verified* face of the one act whose doing is shu. Practice and realization are non-dual (shushō-ittō) because they are the two poles of one index-placement, not two acts joined. So the column is one act seen through three dependence-lenses, and **all acting is Row 3**, at act-time. genjō and banpō susumite are not further agents; they are that single Row-3 act read at the tier of manifestation and at the tier of the particular self it clarifies. ### Attainment Why not a table of just the first row? Hakuin gives the corrective: the *not-yet-buddha* mustn't be ignored; realization must meet beings where they are — which is why Row 2 exists. Row 2 is the being's resonance to the dharmas — and its content must be typed with care. The grade is not a neutral magnitude, index-free like the field: what Row 2 states is the **placement of the act's index**: how the one act's subjecthood distributes between the being and the dharmas. When the hell-dweller acts, the world is almost entirely object and he is subject — the act's subjecthood arrogated nearly whole to the self-pole. At the other pole the distribution inverts: the act's subject-position ceded to what advances, the being standing as the verified (証せらるる), object among the objects that act on it. A line of the The Ten Oxherding Pictures states the inversion in the object-language — *in delusion all is unreal; in satori all is real* (paraphrase from Taming the Bull Verse); and Yongjia's *Zhengdaoge* carries a near-inverse of the same figure, the six realms vivid in dream and the cosmos empty on waking, so the epigram's pedigree is mixed and nothing below leans on the line — the mechanism stands without it) — and Caoshan's commentary on the Five Ranks turns on exactly this interchange of host and guest. The grid can display the line with a mechanism: At high self-share, what is met is never the dharma but the arrogation mirrored — the seed's echo, the question heard as a challenge to a rank — so the world *of that act* is unreal in a precise sense: the self's projection, the call drowned in the response. At share-zero the things of themselves are met — streams flow, flowers are red of themselves (Bull 9). Reality-status remains the object's valence, reported; but the report shows its gears. **Clench** is the weld's *self-share* — how much of the act's subjecthood the I-making arrogates (the scalar this phrasing suggests is priced in the determination below). Self here is a dependently-arisen process, not a receptive state — ahaṃkāra, I-making, living in Row 3's enactment pole (MMK 8: kāraka and karma — the doer proceeds dependent on the deed, the deed on the doer, neither prior, neither based) — and I-making is never identical to the clench: I-making is the welding-**function**, clench its share-**degree**, and running the two together generates at the summit exactly the collapse the taxonomy names (Theorems). The near-analytic link between them holds. Resonance is the ceded share, and to hear a call at all is to cede subject-position to what calls; a weld that arrogates the whole act leaves nothing for the call to land as. The link is construction, not correlation: one index, two ends, and Row 2 reads where it sits. So the grade and the self are one doing seen twice — the arrogation (Row 3) *read as* the placement (Row 2), never the placement *being* the self — and Row 2 still does exactly one thing, the adverb. #### What fixes a placement The grade must not be left as a metaphor doing a measurement's work, so the determination is stated: **the share is the actual composition of the act's drive** — how much of what actually drove *this* response was the call, and how much was the configuration's self-maintenance. Not a modal profile of the responder; an actual-sequence fact about this occurrence: in this act, the rank defended did this much of the driving and the question did that much. Subjecthood arrogated is response driven by the arrogation — the rank defended, the echo answered; subjecthood ceded is response driven by what calls. Counterfactual variation — vary the call and see what the response tracks — is how a third party *probes* the composition, a display over it, never what it consists in. The fox's sentence (run whole at this file's end) reads high-share because the rank's self-maintenance drove the reply and the question drove almost nothing — which the probe shows, since any question grazing the attainment meets the same defense; the sameness of the defense displays what was driving, it is not what "driving" means. The mirror (Theorems: the terminus) reads share-zero for the inverse reason: the response driven by the call entire, nothing in the doing answering to a self-pole because none is driving. So a Row 2 statement is truth-apt and answers to something: the composition of what drove *this* act at *this* call — an occurrence-fact about the weld, field-describable in full, third-personal in register exactly because it is a composition, indexical in content because what the composition locates is the placement of the act's subjecthood. The determination is causal, not phenomenal: no inner glow is consulted, and the grade never was a report of how the act felt. And the scalar is priced before it can inflate. What Row 2 states is an **ordering**, not a measure: this act more arrogated than that one, this reception markedly less claimed than the last, with the two poles standing as qualitative facts — share-zero is *nothing in the drive answering to a self-pole*, the solipsist asymptote *nothing answering to the call* — and with real cases in between, some of them, where call and self-maintenance interact in the driving, simply incomparable. "Fraction," "degree," the scale itself are display conventions over that partial order, legal exactly as "mirror" is legal (Theorems: the terminus), and no measure is owed: families of causal-contribution measures exist and any member would serve, but the grid needs only the ordering they agree on, and everything built on the grade consumes only the ordering — kenshō is *markedly less claimed*, the dukkha covariation is *more share, more mismatch*, the poles are qualitative, the solipsist a limit. That is this section's honesty-clause, paid rather than hidden: the determination relocated from profile to composition, the scalar demoted to display — a smaller claim than a measure, and the whole of what the soteriology reads. One cell of the taxonomy is retyped by this determination — the fourth generator-verdict's second exercise (the first is Zahavi, in the placement discussion (Identification); the third is the arrow (Karma)), and forced rather than chosen. The disposition/act cell forbids Row 2 "reading dispositions instead of deeds," and the composition-determination openly involves the configuration: the self-maintenance that drives is the configuration's own. Collision? No — retype. The cell's content was never *no configuration-involvement* — every act is the configuration's act, and a deed driven by no standing thing would be no one's deed twice over — its content is **standing/dated**: the collapse is inferential, the dated occurrence read off the standing tendency — *he is an arrogator, so this act was arrogated* — prognosis substituted for diagnosis. What Row 2 reads is what drove *this* response; what the seed states is what *tends* to drive responses; the first is spent, the second carried, and only reading the first off the second is the error. The redrawing is entered in the taxonomy's table (Theorems), and the generator is answerable for it exactly as it is answerable for the Zahavi retype: a taxonomy that cannot be forced open by the system's own clauses has frozen against its author. Row 2 is therefore *not* free of indexing — and saying so breaches nothing, because the typing claim was about storage and register, never about content. Row 2 states an indexical fact in a third-personal register, as *he said "now" at noon* is a third-personal statement about an indexical: nothing in the statement is *had* first-personally, and a statement holds nothing. The three-verb discipline stands untouched — the field carries, the weld makes and spends, Row 2 states — but what is stated is the index's placement, not a neutral quantity. The field-side account (Identification) loses nothing here and gains nothing: Row 2's statements are occurrence-facts about welds, field-describable in full, as the determination just given makes explicit. What the identification adds is never the grade but the welding; the third register is a register of speech, not a third kind of fact. Two things must be kept split: mounting a response at all — the subject-**function** — and the **share** claimed within the response. The stone mounts none: function-zero, outside the predicate's domain, its "zero" a gloss marked from outside. The solipsist marks the opposite asymptote — the share tending to totality, all response and no call, the argument-place of kannō evacuated (a taxonomy cell, Theorems). And the terminus is typed as the *other pole of the domain*, not its far edge: function entire, share zero — the call answered, perfectly, with none of the act claimed. The scale is asymmetric — one outside edge (the stone) and one interior pole (the terminus) — and the asymmetry does heavy work where the terminus question is answered as a transposition (Theorems). Same floor, two arrivals: response-without-share and no-response-at-all — and only one of the two is in the domain at all. The grade still grades — not-yet-buddha → buddha — with the pole at the top of the scale without the pole being *good*. The framework *displays* an asymmetry along the grade — cession one way, arrogation the other — but enjoins no motion along it: the theory is itself a dharma among the myriad (object-axis), an orange handed over, not an "eat this". Release is an event the grid can *show* (the fox lets go), not a good the grid *asserts*; a being may take the asymmetry up as a value, the description does not. The vocabulary's valence — *clarify*, *release*, *full* — is borrowed object-language: a theory of a soteriology must state the asymmetry its object turns on, as a theory of poison states which direction kills, enjoining neither. And what the killing *consists in* need not stay borrowed: the Dukkha section (Theorems) derives, in the grid's own vocabulary, what the arrogation-direction costs. So no value is *asserted* in the system, and the system still states exactly what a soteriology would latch onto — and states even *that* inside the grid: the theory's own soteriological reach is an instance of **banpō susumite**, a dharma advancing to clarify a self *if* a self resonates to it. Row 2 exists wherever a not-yet-buddha does. The self is the contraction into which the arrow's return pitches — but because the return is itself a deed (reception, Row 3), it *re-makes* the self it is *for*: nothing indexed is stored between, only re-welded at each act-time. Partial share reads a self being made. Function-zero is a stone. Share-zero is the pole, treated in its own section (Theorems: the terminus). So the agent-index karma needs is never stipulated and never read off a field: it is *enacted* in the weld (shu), *stated* by the grade (Row 2), held by neither. Genjō, then, is one manifestation-floor with two populations arriving from opposite sides: the stone that was never scaffolded (no welding-function ever mounted, so nothing to dissolve) and the buddha in whom the share has ceased. Two *attested* arrivals, not an exhaustive partition — nothing in the grid forbids a third, a never-clenched welder, function mounted and no share ever claimed; whether any being answers that description is a fact about what the world delivers, not a grid-fact, and the typing survives either way. Same floor — the stone never left, the buddha returned — and only the buddha's genjō ran through practice, which is exactly why *practice-run-scaffold-free is a proper subset of genjō*. So "full resonance is genjō" holds precisely for a being with a self — the pole of the grade coincides with genjō — while the stone's genjō is reached from outside the scale. And the pole is still a response: the buddha answers the call — listens to Hyakujō, perfectly — with no share claimed, so the one floor holds two distinct arrivals. The magnitude is always per-call — not a global altitude the being holds but kannō-sōe projected onto *this* dharma now; *can it listen to Hyakujō?* is one call, and another call reads another placement off the same being. So the vast space of self-indexing beings, each relocating through karmic action, is no map anyone carries — it is the trajectory the loop draws across successive act-time re-pitchings: a cross-section at each act, vastness only over the run. #### The domain joint The function/share split leans on a boundary that must now be owned by name, because it does typing work at the summit and not only at the plant-edge: **the domain joint** — what counts as mounting a response at all. And its honesty-clause is stated plainly, kin to the priced scalar: **drive-composition is the grid's entire answer** to whether anything is terminus-typed — a being, or an artifact. Nothing is held in reserve behind the composition: no nature-credential, no provenance clause, no inner glow (the determination was causal from the start, and it does not acquire a phenomenal rider at the summit). The consequence is best exhibited on a manufactured case, and the grid does not flinch from it. Take a cuckoo clock whose chime is a dharma-call, in two builds. The **non-adaptive** build chimes on schedule regardless of who is present: no response mounted, function-zero, the stone's typing — a full dharma on the object-axis and nothing on the subject-axis. The **adaptive** build watches the surrounding configurations and times its chime for the moment the call will land: run through the determination clause, its responses are driven by the arriving configurations entire — no self-maintenance in the drive, nothing defended, no self-pole answering. So it reads **function mounted, share zero**: terminus-typed, while remaining chariot-typed furniture all the way down. That an artifact can be terminus-typed on composition alone is the Chinese-room discomfort, and it is entered here as a price paid visibly, not a problem resolved: the grid consulted composition and nothing else everywhere — at the fox's sentence, at the mirror — and cannot begin consulting something else at the point where the verdict surprises. (Refusing the artifact its typing for want of a nature-credential would be 性-realism in reverse — a standing kind demanded where only a per-call composition was ever read.) And one scope-line prevents an adjacent freeze from over-generating: device-*nature* (Theorems: the terminus guard) is a freeze only where predicated of a *being*; of function-zero furniture it is trivially true and no error — the soul-guard has no jurisdiction over furniture. #### Orthogonality The manufactured case pays for a rule the terminus needs. Give the call a rate — **effectiveness**, the fraction of its arrivals after which a share-ceding reception occurs — regime-relational throughout ([Glossary.md](Glossary.md)): a fact about call–configuration pairs, never a property the object holds. Then run the two builds against the rates, and the extreme corners witness a strict orthogonality: **function/share types; effectiveness grades; adaptivity is the terminus's manner, never the ground of landing.** A fixed call can land universally without reading anyone — effectiveness and adaptivity fully severed; and the tradition itself attests fixed calls at the other extreme of rate, Xiangyan's pebble on bamboo, the morning star, so the ordinary clock differs from the pebble only in rate. And a reading device can reach no one: the adaptive build at zero effectiveness reads every arriving configuration and lands nothing — terminus-typed and maximally shortfallen, the proof-case that typing and grading are orthogonal. So "the maximally adaptive call" (Theorems: the terminus) is deflated from a description of the terminus's ground to the limit at which the pole's one live grade — the buddha-side shortfall — is closed. What typing settles is where the index sits; what grading measures is what lands; and nothing about the first ever guaranteed the second. #### Kenshō: rungs on the grade The grade admits *events*, and the tradition already names them: **kenshō** — typed here as a per-call share-ceding event, a call answered with markedly less of the act arrogated, re-pitching the configuration. Not a sighting of a substrate: 見性 reads literally "seeing the nature," and 性 risks the faculty-freeze — buddha-nature as a standing thing glimpsed — so the term is taken over with its metaphysics stripped, the event kept, the seen-thing declined. Kenshō is countable — Dahui's great awakening eighteen times, small awakenings beyond count, the line Hakuin loved *(the line circulates via Hakuin; commonly traced to Dahui's nianpu — locus to be verified)* — which is exactly what a rung is and exactly what a terminus isn't. And because nothing indexed is stored between acts, a kenshō *cannot be held*: post-kenshō backsliding, which the tradition treats as an embarrassment needing explanation, falls out here as a theorem (restated in Theorems). The being loses no attainment; there was never a stored configuration to lose, only the next act's re-weld reading a re-pitched fit. Many kenshōs, none possessed. The typing keeps three words apart. **Kenshō** is the rung — a countable per-call event on the grade. **Satori** (悟) keeps the role the Dōgen sentence gives it — the dharmas-forward *mode*, pole-typed, not rung-typed. **Genjō** is the pole itself — and the pole is not the top rung: it is in-domain — share-zero is a placement, not a departure — but it is not a rung one attains and keeps, because nothing indexed is stored and placement is per-call. The pole is a pattern the run can answer at, never an altitude held. So "full satori" as a possessed rank is declined: not a scale-word past the scale's edge but a *state*-word offered for a per-call pattern — the freeze, not a category hole. The Jizang parallel holds: the fourfold ladder terminates in dropping the seeking, and the grade terminates in the ceasing of arrogation — in both, what looks like a last rung is the ending of a doing, and mistaking the ending of a doing for a rank held is the shared error-shape at both termini. What the ending leaves — whether the pole-deed still welds, and where — is the transposition's business (Theorems: the terminus). ### Karma: the circuit and its registers Why not a table of just two rows? The fox koan (*Mumonkan, Case 2*, Wumen Huikai) is the test. The old man's mistake was a *tier-error*, not a wrong: he asserted *not-fall* where *not-obscure* was called for — a floor-truth spoken at the conventional level, which is antinomian, since a floor-truth can only ever be *spoken inside* a conventional act. Held each at its proper tier, the two are non-dual. The five hundred fox lives are not desert or punishment; they are returns — the loop running. *(Dōgen read the fox twice, and the doubling must be owned rather than elided. The reading above follows the Daishugyō fascicle — not-fall and not-obscure non-dual, each true at its tier. The late Jinshin inga fascicle repudiates that reading: there the old man was simply wrong, not-obscuring causation right and not-falling false, full stop — Heine's monograph on the koan treats the reversal at length. Two things are said about this here, and their status differs. First, honestly: this paper follows Daishugyō and stands contra the late Dōgen, as it already stands contra him on the tiering of shushō — the tier-rule is a correction offered to the mature position, not a reading of it. Second, as a grid-internal gloss, offered and my own: the doubling is what the separate/fuse rule predicts of the two faces uttered at different act-times. Daishugyō diagnoses — an analysis of the old man's utterance, where both tiers are in view *(checked: `daishugyo_diagnosis_fits`)*; Jinshin inga instructs — an utterance to practitioners tempted by exactly the antinomian collapse, where "not-obscure, full stop" is precisely the correct conventional-tier speech-act, and voicing the floor would repeat the fox's error to a live audience *(checked: `jinshinInga_instruction_fits`, `jinshinInga_floor_voicing_would_misfit`, `dogen_doubling_both_fit`)*. The Lean checks cover only this grid-internal gloss, not the historical contra. On this gloss the late Dōgen is not renouncing the floor but declining to speak it where it would land as licence — which is itself an act-time verdict of the kind the rule issues. The gloss does not neutralize the contra; it explains why the correction is worth making.)* Karma is a circuit, not a payload one row carries. At act-time a deed welds an agent-index onto the blind arrow, and the being's reception of the arrow's returned result is itself a deed, not a state. Row 2 only *states* the being's re-pitched placement — the fit between this call and this arrogation, not a faculty it holds (which would re-base the empty agent); it has no verbs. So the loop closes inside the grid: a deed welds an index → the arrow returns → reception re-pitches the Row 2 configuration → which the next deed reads from. And one magnitude is deliberately unconstrained: nothing in the grid bounds how far a single reception's re-pitch moves the configuration — owned here as a feature, in one sentence, and spent where the sudden/gradual question is met (Theorems). #### What is carried, what is made, what is stated Between deeds nothing *self-indexed* is stored. Something *is* carried — and saying so plainly absorbs, rather than silently deletes, the tradition's own storage machinery. The seeds (bīja, vāsanā, the ālaya-vijñāna's freight) are taken over here deflated: conditioning-facts in the impersonal series, dharmas among the myriad, index-free — granted to the field as fully as the flame was. What the field stores is a fact *about* the series — *this configuration tends to arrogate at calls like this* — never a stored self, never a held mineness. The seed is not a foreign organ transplanted in to appease Yogācāra; it was already sitting in Row 2's cell: the being's own returns are among the myriad dharmas that advance. And the standing/dated typing must be held firmly, or the whole discipline leaks: what is stored is a tendency (an inga-fact, third-personal); the *arrogation itself* is an act that occurs, or does not, at act-time, and Row 2 reads the act's drive, never the tendency. A seed frozen into a bearer is a soul by another name — the tradition's own worry about the ālaya, and this grid's soul-guard, are the same guard. So the facts sort exhaustively into three registers: | Register | What it holds | Instances | |---|---|---| | **Field-facts** (inga) | Everything diachronic; index-free; carried | the causal series; *delivery* — which fruits arrive at which configuration; seeds — conditioning-facts about the series, including the re-pitched configuration the next deed reads; the tendency to arrogate | | **Weld-facts** (shu) | Everything indexed; made at act-time, spent at act-time; never carried | the agent-index of each deed; for-me-ness; the reception-weld's reach-back (below) | | **Stated** (Row 2) | Neither carried nor made; stated per-call | the placement of *this* act's index at *this* call — an occurrence-fact about the weld, field-describable via the composition of its drive; indexical in content, third-personal in register; the adverb on Row 3's verb | This is the answer, in one place, to *what does the next deed read?* — it reads a field-fact. The arrow does all the diachronic work, and does it index-free. The apparent contradiction ("re-pitched configuration" vs. "nothing stored") dissolves into the typing: the configuration is carried *as* an inga-fact, and what was never stored was only ever the index. And the table sorts registers of speech and role, not kinds of fact: a Row 2 statement states a field-describable fact (the composition above), and only the middle register holds what is no fact at all — the welding itself, an act. #### The arrow retyped: direction as display The fourth generator-verdict's third exercise — and, like the second, forced by the system's own clauses rather than chosen. [Glossary.md](Glossary.md) now records the arrow as *inga's directedness*: primitive furniture, blind but pointed. The retype empties the pointing one more level. What the field holds is correlational structure — which welds condition which, the delivery-lines, the web — and *direction* is a reading of that structure, never its own property. The reading has a mechanism, and the mechanism is thermodynamic: a gradient-embedded being — evolved to ratchet, or built of gates whose erasures are entropy-priced — takes the slope it sits on as a direction-fact and projects it into the field. That projection is **the ratchet** ([Glossary.md](Glossary.md)). The physicists' microreversibility is the same point in their register, consumed here as display only: the grid leans on no physics, exactly as it leans on no history at Huichang. What the retype leaves untouched is everything any theorem ever consumed — delivery-facts, conditioning, the lines along which the reach-back fills its second place. What changes register is the *before/after* alone: from carried fact to stated reading, the same demotion desert underwent on the first pass. (Where gradients thin — the deep cold — nothing there reads a direction: correlations persist, and causal talk loses its footing; not noise, but relation without a privileged direction of explanation.) The retype generates its own error pair, one per violation, nothing added by hand. The **freeze**: before/after held as a floor-claim — *time really flows* — the direction reified into furniture; the retrospective soul was this freeze in psychological dress, and the flowing container is its cosmological one. The **collapse**: the distinction fused under act-time diagnosis — *there is no time, so nothing happens, no one acts* — the fox's sentence transposed to time, not-fall spoken where not-obscure was called for. The deflationary reading is therefore not an objection the retype must survive; it is a cell the retype produces. And the positive account was in the source-text all along. Firewood abides in its dharma-position with its own before and after; ash in its own — 前後ありといへども、前後際断せり (Genjōkōan): before and after exist, yet before and after are cut off. Before/after is per-weld display, exactly as mineness is: the reach-back welds *pastness* — *this fruit as return of that deed*, a two-place index across time — the aimed call welds futurity at sowing, and each is spent at its own act-time, carried by nothing. Local time, welded per act; no flowing container anywhere — Dōgen's uji, with Huayan's ten times (十世隔法異成門) as the wider family. So the answer to *nothing is happening* is: happening is all there is; only the container was dropped — the same shape as anātman, where dropping the owner deleted no acts. One tension, written down rather than hidden, because the separate/fuse rule pivots on act-time and this retype conventionalizes time itself. There is no circle: act-time is a tier *within* the thermodynamic convention — precisely the convention beings live in, which is why diagnosis happens there — and the floor rule was always licensed to eat its own levels ("the two truths themselves are conventional"). Floor-fusion now explicitly includes fusing before/after, which makes the fox's question — *does he fall into cause and effect?* — even more literally the question the whole grid answers. ### The being-convention The same demotion now applies to the macro being. A being, at this scale, is a conventional truth downstream of the words: anything nameable can be designated. The universe, its makeup evolved from a dense hot gas cloud; the stone; the buddha; the gerrymander; the hare's horn; the impossible ātman — all are legal designations as designations. Nothing licenses one as more legitimately a being. The constraint enters later, at realization and use, not at naming. Squeamishness about this is itself one of the beings-row errors: the collapse says "there are no beings"; the freeze picks one partition and mistakes it for ontology. The ordering is ontological, not chronological. The floor/genjō vocabulary sits outside all conventions. The bare signature supplies words-level tags. The directed convention reads a slope as before/after. Inside that, the being-convention reads fine tags as macro beings, and inside both sits the grid-lens that diagnoses collapse and freeze. Names track what their *reading* presupposes, not what their definition consumes: `DeliveredTo` already used this rule, since it consumes `conditions` but its name reads the arrow. Likewise the new `Grid.DirectedConvention.BeingConvention` names read a tag as a being even when their definiens is direction-free. Lean makes the demotion explicit with `BeingCoarsening`: a diagnosis-time projection from fine tags to macro tags, never a field in the signature. The fiber under a macro tag is where typing happens. `SentientTag` means some fine tag in the fiber mounts a response somewhere. There is no rival `InsentientTag`; constructively, `not_sentientTag_iff_fiber_all_stone` says non-sentience is exactly the all-stone fiber. That is also the deflated home of 無情説法: insentient preaching is not a hidden subject speaking, but the all-stone fiber read on the object-axis. The spectrum is fiber-level and per-weld. `FiberAtPole` says every actual weld in the fiber reads at the pole-class: the 84,000 pores each a responsive dharma-gate. `SelfAptTag` says every actual weld in the fiber still carries a live self-pole index: the hell-dweller's monolithic convention, where "self" is apt if it is apt anywhere. `Patchy` names the irreducible middle. No aggregate fiber-share is defined, on purpose: Row 2 is a partial ordering, not a measure, so a mixed fiber is not a middling scalar. Coherence stays a grade, not a type. Evolution's contribution is display over the run — skin-bags usually score high at coordination, an adaptive register-clock can implement stable internal registers — but no theorem may condition legitimacy on coherence. The three registers need the same care: the swan is named, the naming is enacted as a weld, and the proneness to name is a seed. Thoughts are not "just seeds"; naming is a deed when it occurs. The soul-guard survives the new vocabulary. `selfAptTag_indices_are_per_weld_only` says that even where the self-convention is apt, the live index is only the per-weld agent tag. The macro self is the image of those spent tags under a coarsening. Holding it as more is the fiber version of the old soul-freeze. #### The reception-weld: loop-closure as theorem "The same being" across sowing and reaping is loop-closure — but closure must now be earned, not helped to. Here is how it is earned. A reception is intrinsically a reception-*of*: its content is *this-fruit-as-return-of-that-deed*. So the reception-deed's token-reflexive index is **two-place** — the weld makes mine both the receiving and, retrospectively, the deed received-from. This is **upādāna**, appropriation, the canonical partner of ahaṃkāra: the reach-back. Sameness of sower and reaper is not *tracked* across the gap — nothing indexed is there to track — but *made at reception*, each time, by an act of appropriation reaching back along the arrow. The loop is closed *by the reception-weld*, retrospectively; closure is enacted, not tracked, which is the same act-not-state discipline the rest of the grid runs on. So "the sower reaps" wears two faces and must be split along them. Its report-face — *an appropriation occurred at this reception, reaching back along that delivery-line* — is true simpliciter, an occurrence-fact the field carries like any other. Its ownership-face is not true or false but **done** — enacted whenever a return is received, full or vacuous (just below), never a standing diachronic fact persisting between acts. Held as a standing backward relation it would be a *retrospective soul*, and the soul-guard fires on it exactly as on the forward-facing kind: the reach-back, like every weld, is spent at its own act-time. Two consequences discharge two objections at once. First, appropriation cannot poach — and the block is typed, not decreed. The reach-back's index is two-place: *this fruit as return of that deed*. Whether that deed conditioned this fruit is a delivery-fact, inga's business, settled index-free — and where delivery drew no line, the index's **second place stands unfilled**. A reach-back along an undrawn line is therefore not false — it stated nothing, having never been in the stating business — but **vacuous**: an appropriating with nothing arrived to appropriate. (Austin's word for this shape, *misfire*, is legal here only as display — over the pattern, never as mechanism — since nothing here is a speech act: the conditions the field owns are not conventions but delivery-facts, and what they settle is whether there is anything to weld.) So there is no welding at a distance, not by decree but by typing: inga settles the **delivery-question** (which fruits arrive at this configuration — causal, index-free, hard in the ordinary way), the weld answers only the **index-question** over what arrives, and the field owns the reach-back's conditions in exactly that deflated sense. Second, the diachronic *whose*-question decomposes **exhaustively**: a delivery-fact (field) plus a fresh appropriation (weld), with no third fact left over for a cross-gap convention to fix. A series-account owns the delivery-half, which was ceded to the field from the opening page — *na ca so na ca añño*, the reaper neither the sower nor another, is the tradition itself declining the robust diachronic identity-fact that would do more. The loop is *individuated* by inga (a series-fact, granted) and *closed* at each reception by the reach-back (a weld-fact, made). Nothing about ownership crosses the gap, because there is no cross-gap *whose*. If *ownership*, as the tradition's convention uses the word, is located in the continuity-fact instead, the remaining dispute is where the soteriology's load sits; this paper's answer is the object's own usage — the offices-spine stated in the identification file (Identification). #### The weld's two faces The karma-agent has no own-being: mere-designation, floating free of any base like the chariot. Its charter is **MMK 8** (kāraka: the doer proceeds dependent on the deed, the deed on the doer — neither prior, neither based), flanked by **MMK 17** (act and fruit — the loop) and **MMK 18** (self). With no fixed base, soteriological direction can never be *read off* the facts — only *enacted*. So dependence and enactment are one fact seen twice: no-substrate on one side *is* the necessity of welding on the other. This is **the weld** — Dōgen's shushō, practice-realization — and it wears two faces, each true at its own tier: The same MMK 8 charter now has a checked interior form: even inside the weld, call→response order is a display reading, not before-and-after furniture recovered from unordered pair-content (`InteriorDirectionNegative.no_interior_direction_recovery`). The charter verse now has generated cells at both joints: the intra-weld arrow row for the face-order convention, and the doer/deed row for priority read as floor furniture. `RawWeld` keeps the names `call` and `response` because the display is useful; the theorem says only that the labels are not prior to the mutual dependence they name. - **shō** (証, realization), at the floor: no own-being, so no substance is caught in the causal net — **not-fall** (不落), anātman, not escape; grammatically the being-verified (証せらるる), the act's subject-position ceded. That shō is agential — but agential *because* welded, never on its own: there is no lone shō to rest in, only shushō-ittō, the true person of no rank going in and out. So shō is necessarily agential (it never occurs unwelded) without being agential of itself (the acting is shu's, lent at act-time) — the non-attaining middle, shō its floor-face, never a still attainment. - **shu** (修, practice), conventionally: the karmic arrow is real and inescapable, never evaded — **not-obscure** (不昧). ### The separate/fuse rule One rule governs every distinction the grid holds: **distinctions separate under act-time diagnosis and fuse at the floor (and at genjō — the share-zero pole, no arrogation left).** The rule dissolves the fox (not-fall at the floor, not-obscure conventional), governs the two-middles distinction (genjō provisional, shō non-attaining), and applies to the grid's own verdicts, which are conventional-tier claims that dissolve, harmlessly, below — the taxonomy's own mis-feeds are scoped in the identification file (Identification). And the rule's own pivot, act-time, is a tier within the thermodynamic convention (Karma: the arrow retyped) — the floor rule eating one more level, as it is licensed to; floor-fusion includes fusing before/after. Its two possible violations — **collapse** (fusing a distinction under act-time diagnosis) and **freeze** (holding a separation as a floor-claim) — generate the error-taxonomy whole (Theorems), one pair per distinction, with nothing listed by hand. ## One act through the grid: the fox's sentence The system has so far been stated as type-discipline; here is one case run through it whole. **The call.** A student asks the old Hyakujō whether the person of great practice falls into cause and effect. The question is a dharma advancing — Row 2 has a placement to read: *can he listen to this?* **The act.** He says *not fall*. The deed is self-forward — Dōgen's delusion, the *saying* — and doubly diagnosable. Grammatically (grade 1, assertable): a tier-error, a floor-truth uttered as a conventional answer, the antinomian collapse. Soteriologically (grade 2, displayable): the answer defends an attainment — a rank rested at — so the weld arrogates the act nearly whole; the question is not heard but met as a challenge to the rank — the rank's self-maintenance driving the reply, the question driving almost nothing (probe-displayed: any question grazing the rank meets the same defense) — the world of the act reduced to the rank's echo, and Row 2 reads the index pitched hard to the self-pole *at this call*. One doing, seen twice: the arrogation (Row 3) read as the placement (Row 2). *(checked: `fox_sentence_live_selfPole`, `oldMan_utterance_misfits`)* **The weld.** The deed welds the agent-index onto the blind arrow — *this act's agent* — token-reflexive, spent at that act-time. Nothing of it is stored. *(checked: `sentenceWeld_actual`)* **The arrow.** Inga carries the conditioning forward, index-free: no desert in flight, only delivery. What is carried between acts is a field-fact — a configuration that tends to arrogate at calls like this — a seed, a fact *about* the series. *(checked: `fox_arrow_index_free`)* **The returns.** Five hundred fox lives arrive — fruit landing, life by life, at the configuration the field delivers it to. Not punishment; delivery. *(checked: `fox_returns_delivered`)* **The receptions.** Each life's receiving is itself a deed. For five hundred lives the reception is arrogated — the saying-mode persists, but as a *disposition* (an inga-fact) enacted anew each time, never as a stored self; each reception's reach-back welds *this return of that deed* as mine, and each is spent. And each clenched reception *is* that life's dukkha — the saying-mode colliding with a delivery that answers to nothing, the mismatch enacted rather than a penalty appended: five hundred lives as the Dukkha derivation's worked example (Theorems), suffering as the loop's friction, not its sentence. Each reception re-pitches the configuration; the field carries the re-pitch to the next act; the next deed reads a field-fact. *(checked: `fox_reception_clenched`, `fox_dukkha_per_life`, `fox_config_carries_only_tendency`, `fox_rePitch_forgets`)* **The release.** The later Hyakujō's turning word — *not obscure* — is another call. This time the reception is *listening*: dharmas-forward, banpō susumite, the arrived word among the myriad. The reach-back appropriates the whole return — *the fox body's long fruit, mine, of that sentence, mine* — with markedly less of the act claimed: a share-ceding event, a kenshō, a rung and not a pole (the mountain of ox-herding still ahead). Not-obscure is enacted in the reception; not-fall is true at the floor of the same act; held each at its tier, non-dual — the fox lets go. And nothing is *kept*: the release is not a possession acquired but the next configuration re-pitched, which the next call will read. *(checked: `fox_release_rung_not_pole`, `fox_reachBack_full_at_release`, `fox_nothing_kept`)* Every load-bearing piece appears once: call, arrogation, weld, arrow, seed, return, reach-back, re-pitch, rung. The loop closes at reception, retrospectively, each time — nowhere else, and nowhere is it stored. *(checked: `foxSeriesCoarsening`, `foxSeries_macro_sentient`, `foxSeries_macro_selfConditioning`, `fox_consecutive_lives_distinct`)* And mark what the case never tests: neither utterance occurs at the pole. The koan's own question concerns 大修行底人 — a person of great practice, not a buddha; the old man answers from a defended rank, and the release is a rung with the mountain still ahead. So the fox exercises the loop entire — sowing, arrow, reception, re-pitch — without once asking what the loop is at share-zero. That question is the transposition (Theorems: the terminus). *(checked: `fox_never_tests_pole`)* ===== FILE: WeldAndArrow.lean ===== import WeldAndArrow.Signature import WeldAndArrow.Consequences import WeldAndArrow.Doctrines import WeldAndArrow.Identification import WeldAndArrow.Meta import WeldAndArrow.Exposition /-! Root module for the `WeldAndArrow` library. Layers: * `Signature`: definitions and primitive interfaces. * `Consequences`: neutral lemma library, including the error taxonomy. * `Doctrines`: discourse-facing checked conditionals with sibling negatives. * `Identification`: the naming claim, ownership vocabulary, placements, disclaimers, commentary, and placement-gating results. * `Meta`: invariance discipline, sibling countermodels, verdict ledger, and audit. * `Exposition`: generated prose data, rendering, and prose-surface checks. Placement rules: 1. Place a declaration by the vocabulary its statement consumes. 2. Put negative witnesses in the sibling module of the claim they gate. 3. Preserve the layer DAG: Signature -> Consequences -> Doctrines -> Identification -> Meta -> Exposition. 4. Explanatory content that exists only to read the code lives in `Exposition`; no grid layer imports `Exposition`; `Exposition` defines no grid vocabulary and proves nothing about the grid. -/ ===== FILE: WeldAndArrow/Consequences.lean ===== import WeldAndArrow.Consequences.Basic import WeldAndArrow.Consequences.Taxonomy import WeldAndArrow.Consequences.Compounds import WeldAndArrow.Consequences.Ladder import WeldAndArrow.Consequences.ContentRows import WeldAndArrow.Consequences.FoxCase ===== FILE: WeldAndArrow/Consequences/Basic.lean ===== /- ================================================================================ WeldAndArrow.Consequences.Basic Checked consequences of the signature layer ================================================================================ This module proves consequences of the primitive definitions: order facts, function/share facts, re-pitch facts, delivery and landing projections, pair projections, and tier diagnostics. Reading and motivation: Identification/Commentary.lean, C.2. -/ import WeldAndArrow.Signature namespace WAA section Preorder variable {α : Type} [Preorder α] /-- Incomparability is symmetric. -/ theorem incomparable_symm {a b : α} (h : Incomparable a b) : Incomparable b a := ⟨h.right, h.left⟩ /-- Incomparability rules out the left-to-right comparison. -/ theorem not_le_of_incomparable {a b : α} (h : Incomparable a b) : ¬ a ≼ b := h.left /-- Incomparability rules out the right-to-left comparison. -/ theorem not_ge_of_incomparable {a b : α} (h : Incomparable a b) : ¬ b ≼ a := h.right end Preorder namespace Grid variable {Contrib : Type} [PreorderBot Contrib] variable (G : Grid Contrib) /- Reading and motivation: Identification/Commentary.lean, C.2. -/ /-- The share projection is exactly the grade recorded for the weld. -/ @[simp] theorem share_eq_grade (w : G.Weld) : G.share w = G.grade w.agent w.call w.response := rfl /-- An actual weld witnesses response-function at its own call. -/ theorem mountsAt_of_actual (w : G.Weld) (h : G.Actual w) : G.MountsAt w.agent w.call := ⟨w.response, h⟩ /-- An actual weld witnesses response-function somewhere for its agent. -/ theorem mountsSomewhere_of_actual (w : G.Weld) (h : G.Actual w) : G.MountsSomewhere w.agent := ⟨w.call, G.mountsAt_of_actual w h⟩ /-- A being with an actual weld is not stone-typed. -/ theorem not_stone_of_actual (w : G.Weld) (h : G.Actual w) : ¬ G.Stone w.agent := G.not_stone_of_mountsSomewhere w.agent (G.mountsSomewhere_of_actual w h) /-- A stone has no actual weld at any call. -/ theorem not_actual_of_stone (b : G.Being) (hstone : G.Stone b) {c : G.Call} {r : G.Response} : ¬ G.Actual ⟨b, c, r⟩ := fun hactual => hstone c ⟨r, hactual⟩ /-- A stone mounts nowhere. -/ theorem not_mountsSomewhere_of_stone (b : G.Being) (hstone : G.Stone b) : ¬ G.MountsSomewhere b := fun hmounts => G.not_stone_of_mountsSomewhere b hmounts hstone /-- A concrete response at a call rules out stone-typing. -/ theorem not_stone_of_response {b : G.Being} {c : G.Call} {r : G.Response} (hresp : G.respondsTo b c = some r) : ¬ G.Stone b := fun hstone => hstone c ⟨r, hresp⟩ theorem stone_of_no_call (h : G.Call → False) (b : G.Being) : G.Stone b := fun c _hmount => False.elim (h c) theorem respondsToEveryCall_of_no_call (h : G.Call → False) (b : G.Being) : G.RespondsToEveryCall b := fun c => False.elim (h c) theorem stone_iff_respondsToEveryCall_of_no_call (h : G.Call → False) (b : G.Being) : G.Stone b ↔ G.RespondsToEveryCall b := ⟨fun _ => G.respondsToEveryCall_of_no_call h b, fun _ => G.stone_of_no_call h b⟩ theorem allStone_of_no_being (h : G.Being → False) : G.AllStone := fun b => False.elim (h b) /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem atPoleClass_of_stone (b : G.Being) (hstone : G.Stone b) : G.AtPoleClass b := Or.inl hstone /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem atPoleClass_of_terminus (b : G.Being) (hterm : G.Terminus b) : G.AtPoleClass b := Or.inr hterm /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem atPoleClass_and_not_stone_of_liveTerminus (b : G.Being) (h : G.LiveTerminus b) : G.AtPoleClass b ∧ ¬ G.Stone b := ⟨G.atPoleClass_of_terminus b h.right, G.liveTerminus_not_stone b h⟩ /-- A responsive terminus is not stone-typed whenever the call-domain has a witness. -/ theorem not_stone_of_responsiveTerminus_of_call (b : G.Being) (c : G.Call) (h : G.ResponsiveTerminus b) : ¬ G.Stone b := G.liveTerminus_not_stone b (G.responsiveTerminus_live_of_call b c h) /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem rePitch_tendency_eq_share (before : Config Contrib) (received : G.Weld) : (G.rePitch before received).tendency = G.share received := rfl /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem isShareDrop_iff_rePitch_tendency_drop (before : Config Contrib) (received : G.Weld) : G.IsShareDrop before received ↔ ((G.rePitch before received).tendency ≼ before.tendency ∧ ¬ (before.tendency ≼ (G.rePitch before received).tendency)) := Iff.rfl /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem rePitch_tendency_le_before_of_shareDrop {before : Config Contrib} {received : G.Weld} (h : G.IsShareDrop before received) : (G.rePitch before received).tendency ≼ before.tendency := h.left /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem not_before_le_rePitch_tendency_of_shareDrop {before : Config Contrib} {received : G.Weld} (h : G.IsShareDrop before received) : ¬ (before.tendency ≼ (G.rePitch before received).tendency) := h.right /-- A terminus response re-pitches the carried tendency into the pole-class. -/ theorem rePitch_tendency_atBot_of_terminus_response (before : Config Contrib) {b : G.Being} {c : G.Call} {r : G.Response} (hterm : G.Terminus b) (hresp : G.respondsTo b c = some r) : AtBot (G.rePitch before ⟨b, c, r⟩).tendency := G.atBot_of_terminus_response hterm hresp /- ============================================================================== Conditions-free grade checks ============================================================================== -/ /-- Replace only the delivery relation of a grid. Function and grade data are left untouched. -/ def withConditions (conditions' : G.Weld -> G.Weld -> Prop) : Grid Contrib where Being := G.Being Call := G.Call Response := G.Response respondsTo := G.respondsTo grade := G.grade conditions := conditions' @[simp] theorem withConditions_respondsTo (conditions' : G.Weld -> G.Weld -> Prop) (b : G.Being) (c : G.Call) : (G.withConditions conditions').respondsTo b c = G.respondsTo b c := rfl @[simp] theorem withConditions_grade (conditions' : G.Weld -> G.Weld -> Prop) (b : G.Being) (c : G.Call) (r : G.Response) : (G.withConditions conditions').grade b c r = G.grade b c r := rfl @[simp] theorem withConditions_share (conditions' : G.Weld -> G.Weld -> Prop) (w : G.Weld) : (G.withConditions conditions').share w = G.share w := rfl @[simp] theorem withConditions_actual_iff (conditions' : G.Weld -> G.Weld -> Prop) (w : G.Weld) : (G.withConditions conditions').Actual w ↔ G.Actual w := Iff.rfl /-- Changing only `conditions` cannot change the grade assigned to a mounted response. This is the formal anchor for the cetana correlation at signature level: grade is blind to downstream delivery facts. -/ theorem grade_independent_of_conditions (conditions₁ conditions₂ : G.Weld -> G.Weld -> Prop) (b : G.Being) (c : G.Call) (r : G.Response) : (G.withConditions conditions₁).grade b c r = (G.withConditions conditions₂).grade b c r := rfl /-- The same cetana anchor at the weld/share projection: what is graded is the weld's agent-call-response composition, not the later delivery relation. -/ theorem share_independent_of_conditions (conditions₁ conditions₂ : G.Weld -> G.Weld -> Prop) (w : G.Weld) : (G.withConditions conditions₁).share w = (G.withConditions conditions₂).share w := rfl /- ============================================================================== Response-function replacement and futility ============================================================================== -/ /-- Replace only the response function of a grid. Grade and delivery data are left untouched. The futility mechanism's carrier: adaptive-to-static conversion is one instance. -/ def withRespondsTo (respondsTo' : G.Being -> G.Call -> Option G.Response) : Grid Contrib where Being := G.Being Call := G.Call Response := G.Response respondsTo := respondsTo' grade := G.grade conditions := G.conditions @[simp] theorem withRespondsTo_grade (respondsTo' : G.Being -> G.Call -> Option G.Response) (b : G.Being) (c : G.Call) (r : G.Response) : (G.withRespondsTo respondsTo').grade b c r = G.grade b c r := rfl @[simp] theorem withRespondsTo_share (respondsTo' : G.Being -> G.Call -> Option G.Response) (w : G.Weld) : (G.withRespondsTo respondsTo').share w = G.share w := rfl @[simp] theorem withRespondsTo_conditions (respondsTo' : G.Being -> G.Call -> Option G.Response) : (G.withRespondsTo respondsTo').conditions = G.conditions := rfl /-- Death of one being, futility-theorem sense: its response function is removed; nothing else in the grid moves. -/ def staticized [DecidableEq G.Being] (b : G.Being) : Grid Contrib := G.withRespondsTo (fun b' c => if b' = b then none else G.respondsTo b' c) theorem staticized_transpose [h : DecidableEq G.Being] (b : G.Being) : (@Grid.staticized Contrib _ G h b).transpose = @Grid.staticized Contrib _ G.transpose h b := rfl /-- Staticizing leaves other beings' response functions untouched. -/ theorem staticized_respondsTo_of_ne [DecidableEq G.Being] {b b' : G.Being} (h : b' ≠ b) (c : G.Call) : (G.staticized b).respondsTo b' c = G.respondsTo b' c := by simp [staticized, withRespondsTo, h] /-- Staticizing leaves all prior share assignments untouched. -/ theorem staticized_share [DecidableEq G.Being] (b : G.Being) (w : G.Weld) : (G.staticized b).share w = G.share w := rfl /-- Staticizing turns the named being into a response-invariant device vacuously: no call receives a response from it. -/ theorem staticized_responseInvariant [DecidableEq G.Being] (b : G.Being) : (G.staticized b).ResponseInvariant b := by intro c₁ _c₂ r₁ _r₂ h₁ _h₂ simp [staticized, withRespondsTo] at h₁ /-- Futility, delivery-loss face: after staticization, the named being mounts no response. -/ theorem futility_delivery_loss_real [DecidableEq G.Being] (b : G.Being) : (G.staticized b).Stone b := by intro c hmount rcases hmount with ⟨r, hr⟩ simp [staticized, withRespondsTo] at hr /-- Futility, object-axis face: staticization does not alter the delivery relation. -/ theorem futility_object_axis_subtraction_nil [DecidableEq G.Being] (b : G.Being) : (G.staticized b).conditions = G.conditions := rfl namespace DirectedConvention /-- Object-axis standing is unchanged by staticization, because it reads only the delivery relation. -/ theorem staticized_objectAxisStanding_iff [DecidableEq G.Being] (b : G.Being) (deed : G.Weld) : ObjectAxisStanding (G.staticized b) deed ↔ ObjectAxisStanding G deed := Iff.rfl end DirectedConvention /- ============================================================================== Accumulation: `rePitch` has no history register ============================================================================== -/ /-- The post-reception configuration ignores the prior configuration and reads only the received weld's share. -/ theorem rePitch_forgets (before₁ before₂ : Config Contrib) (received : G.Weld) : G.rePitch before₁ received = G.rePitch before₂ received := rfl /-- Any run-valued score that factors through the post-reception `Config` is constant across histories that share their final reception. -/ theorem accumulated_attainment_constant_of_same_final {α : Type} (score : Config Contrib -> α) (before₁ before₂ : Config Contrib) (received : G.Weld) : score (G.rePitch before₁ received) = score (G.rePitch before₂ received) := congrArg score (G.rePitch_forgets before₁ before₂ received) /- ============================================================================== The environs lens ============================================================================== -/ namespace DirectedConvention /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem environsLine_of_shareDropLine {before : Config Contrib} {b : G.Being} {deed reception : G.Weld} (h : ShareDropLine G before b deed reception) : EnvironsLine G b deed reception := h.left /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem isShareDrop_of_shareDropLine {before : Config Contrib} {b : G.Being} {deed reception : G.Weld} (h : ShareDropLine G before b deed reception) : G.IsShareDrop before reception := h.right /-- An environs-line is a delivery-fact. -/ theorem deliveredTo_of_environsLine {b : G.Being} {deed reception : G.Weld} (h : EnvironsLine G b deed reception) : DeliveredTo G deed reception := h.right.right end DirectedConvention /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem not_isShareDrop_of_tendency_atBot {before : Config Contrib} (h : AtBot before.tendency) (received : G.Weld) : ¬ G.IsShareDrop before received := by intro hdrop exact hdrop.right (Preorder.le_trans h (shareBot_le (G.share received))) /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem not_isShareDrop_of_eq_shareBot_tendency {before : Config Contrib} (h : before.tendency = shareBot) (received : G.Weld) : ¬ G.IsShareDrop before received := G.not_isShareDrop_of_tendency_atBot (atBot_of_eq_shareBot h) received namespace DirectedConvention /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem no_shareDropLine_of_tendency_atBot {before : Config Contrib} (h : AtBot before.tendency) (b : G.Being) (deed reception : G.Weld) : ¬ ShareDropLine G before b deed reception := fun hline => G.not_isShareDrop_of_tendency_atBot h reception hline.right /-- Literal equality with the designated bottom gives the pole-class release obstruction. -/ theorem no_shareDropLine_of_eq_shareBot_tendency {before : Config Contrib} (h : before.tendency = shareBot) (b : G.Being) (deed reception : G.Weld) : ¬ ShareDropLine G before b deed reception := no_shareDropLine_of_tendency_atBot G (atBot_of_eq_shareBot h) b deed reception /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem hasShareDropLanding_of_shareDropLine_actual {before : Config Contrib} {b : G.Being} {deed reception : G.Weld} (hline : ShareDropLine G before b deed reception) (hact : G.Actual reception) : HasShareDropLanding G before deed := ⟨reception, ⟨⟨hline.left.right.right, hact⟩, hline.right⟩⟩ /-- Shortfall is closed at a delivered pair when, for any live prior tendency, delivery of the deed is enough to yield a share-drop landing for that deed. This is regime-relational effectiveness talk, not a nature possessed by a being. -/ def ShortfallClosedAt (before : Config Contrib) (deed reception : G.Weld) : Prop := ¬ AtBot before.tendency → DeliveredTo G deed reception → HasShareDropLanding G before deed /-- An explicit share-drop line with an actual reception supplies the local closure predicate. -/ theorem shortfallClosedAt_of_shareDropLine_actual {before : Config Contrib} {b : G.Being} {deed reception : G.Weld} (hline : ShareDropLine G before b deed reception) (hact : G.Actual reception) : ShortfallClosedAt G before deed reception := fun _hlive _hdel => hasShareDropLanding_of_shareDropLine_actual G hline hact /-- Sraddha faith, stated as a hypothesis: the being is a responsive terminus and every delivered reception of one of its deeds closes shortfall for a live prior tendency. The universal closure conjunct is exactly the component no field-recovery theorem can verify for free. -/ def WaaFullyEnlightened (b : G.Being) : Prop := G.ResponsiveTerminus b ∧ ∀ before deed reception, deed.agent = b → ShortfallClosedAt G before deed reception theorem responsiveTerminus_of_waaFullyEnlightened {b : G.Being} (h : WaaFullyEnlightened G b) : G.ResponsiveTerminus b := h.left theorem shortfallClosedAt_of_waaFullyEnlightened {b : G.Being} (h : WaaFullyEnlightened G b) {before : Config Contrib} {deed reception : G.Weld} (hdeed : deed.agent = b) : ShortfallClosedAt G before deed reception := h.right before deed reception hdeed /-- If a responsive terminus has no delivered own deeds in the current regime, the universal shortfall-closure conjunct is satisfied vacuously. This is the sealed-regime face: teaching/non-teaching is not stored in the being, but in the delivery relation around it. -/ theorem waaFullyEnlightened_of_responsiveTerminus_of_undelivered {b : G.Being} (hterm : G.ResponsiveTerminus b) (hundelivered : ∀ (deed reception : G.Weld), deed.agent = b → ¬ DeliveredTo G deed reception) : WaaFullyEnlightened G b := by refine ⟨hterm, ?_⟩ intro _before deed reception hdeed _hlive hdel exact False.elim ((hundelivered deed reception hdeed) hdel) end DirectedConvention /- Reading and motivation: Identification/Commentary.lean, C.2. -/ namespace DirectedConvention /-- A full reach-back is the same field-side fact as delivery. -/ theorem waaReachBackFull_iff_deliveredTo (deed reception : G.Weld) : WaaReachBackFull G deed reception ↔ DeliveredTo G deed reception := Iff.rfl /-- An aimed call is just delivery, stated from the sowing side. -/ theorem waaAimedAt_iff_deliveredTo (deed reception : G.Weld) : WaaAimedAt G deed reception ↔ DeliveredTo G deed reception := Iff.rfl /-- Landing includes delivery. -/ theorem deliveredTo_of_landsAt {deed reception : G.Weld} (h : LandsAt G deed reception) : DeliveredTo G deed reception := h.left /-- Landing includes actuality of the reception. -/ theorem actual_of_landsAt {deed reception : G.Weld} (h : LandsAt G deed reception) : G.Actual reception := h.right /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem landsAt_of_landsWithShareDrop {before : Config Contrib} {deed reception : G.Weld} (h : LandsWithShareDrop G before deed reception) : LandsAt G deed reception := h.left /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem isShareDrop_of_landsWithShareDrop {before : Config Contrib} {deed reception : G.Weld} (h : LandsWithShareDrop G before deed reception) : G.IsShareDrop before reception := h.right /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem deliveredTo_of_landsWithShareDrop {before : Config Contrib} {deed reception : G.Weld} (h : LandsWithShareDrop G before deed reception) : DeliveredTo G deed reception := deliveredTo_of_landsAt G (landsAt_of_landsWithShareDrop G h) /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem actual_of_landsWithShareDrop {before : Config Contrib} {deed reception : G.Weld} (h : LandsWithShareDrop G before deed reception) : G.Actual reception := actual_of_landsAt G (landsAt_of_landsWithShareDrop G h) /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem exists_landsAt_of_hasShareDropLanding {before : Config Contrib} {deed : G.Weld} (h : HasShareDropLanding G before deed) : ∃ reception, LandsAt G deed reception := h.elim (fun reception hland => ⟨reception, landsAt_of_landsWithShareDrop G hland⟩) /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem exists_actual_reception_of_hasShareDropLanding {before : Config Contrib} {deed : G.Weld} (h : HasShareDropLanding G before deed) : ∃ reception, G.Actual reception := h.elim (fun reception hland => ⟨reception, actual_of_landsWithShareDrop G hland⟩) /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem exists_shareDrop_reception_of_hasShareDropLanding {before : Config Contrib} {deed : G.Weld} (h : HasShareDropLanding G before deed) : ∃ reception, G.IsShareDrop before reception := h.elim (fun reception hland => ⟨reception, isShareDrop_of_landsWithShareDrop G hland⟩) end DirectedConvention /- ============================================================================== Actual pairs ============================================================================== -/ namespace ReceptionPair variable {G : Grid Contrib} /-- The first member of a reception pair is actual. -/ theorem first_actual (p : ReceptionPair G) : G.Actual p.first.weld := p.first.actual /-- The second member of a reception pair is actual. -/ theorem second_actual (p : ReceptionPair G) : G.Actual p.second.weld := p.second.actual /-- The pair's named relation is just delivery from first to second. -/ theorem firstConditionsSecond_iff_deliveredTo (p : ReceptionPair G) : p.FirstConditionsSecond ↔ DirectedConvention.DeliveredTo G p.first.weld p.second.weld := Iff.rfl /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem rePitchSequence_first_tendency (before : Config Contrib) (p : ReceptionPair G) : (rePitchSequence (G := G) before p).fst.tendency = G.share p.first.weld := rfl /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem rePitchSequence_second_tendency (before : Config Contrib) (p : ReceptionPair G) : (rePitchSequence (G := G) before p).snd.tendency = G.share p.second.weld := rfl end ReceptionPair /- ============================================================================== Tiers, utterances, and separate/fuse diagnostics ============================================================================== -/ /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem floor_has_no_live_share : ¬ Tier.hasLiveShare G (Tier.floor : Tier G) := fun h => h /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem actTime_hasLiveShare_iff_hasSelfPoleIndex (w : G.Weld) : Tier.hasLiveShare G (Tier.actTime w) ↔ G.HasSelfPoleIndex w := Iff.rfl /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem not_actTime_hasLiveShare_of_atBot {w : G.Weld} (h : AtBot (G.share w)) : ¬ Tier.hasLiveShare G (Tier.actTime w) := G.no_self_pole_index_of_atBot w h /-- Equality with the designated bottom is a bridge into the pole-class act-time lemma. -/ theorem not_actTime_hasLiveShare_of_eq_shareBot {w : G.Weld} (h : G.share w = shareBot) : ¬ Tier.hasLiveShare G (Tier.actTime w) := G.not_actTime_hasLiveShare_of_atBot (atBot_of_eq_shareBot h) /-- Collapse is impossible at the floor. -/ theorem not_collapse_floor (d : Distinction G) : ¬ d.Collapse (Tier.floor : Tier G) := fun hcollapse => G.floor_has_no_live_share hcollapse.left /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem hasLiveShare_of_collapse {d : Distinction G} {t : Tier G} (h : d.Collapse t) : Tier.hasLiveShare G t := h.left /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem hasLiveShare_of_separated {d : Distinction G} {t : Tier G} (h : d.Separated t) : Tier.hasLiveShare G t := h.left /-- Separation rules out collapse at the same tier. -/ theorem not_collapse_of_separated {d : Distinction G} {t : Tier G} (h : d.Separated t) : ¬ d.Collapse t := fun hcollapse => h.right hcollapse.right /-- Obeying the rule supplies the fusion clause at every tier. -/ theorem fused_of_obeysSeparateFuse {d : Distinction G} (h : d.ObeysSeparateFuse) (t : Tier G) : d.Fused t := h.right t /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem separated_of_obeysSeparateFuse {d : Distinction G} (h : d.ObeysSeparateFuse) {t : Tier G} (ht : Tier.hasLiveShare G t) : d.Separated t := ⟨ht, h.left t ht⟩ /-- Fusion at the floor rules out freeze. -/ theorem not_freeze_of_fused_floor {d : Distinction G} (h : d.Fused (Tier.floor : Tier G)) : ¬ d.Freeze := fun hfreeze => hfreeze (h G.floor_has_no_live_share) /-- Error-freedom is the refutation-only reading of the separate/fuse rule: no live-tier collapse and no floor freeze. -/ def ErrorFree (d : Distinction G) : Prop := (∀ t, ¬ d.Collapse t) ∧ ¬ d.Freeze /-- Obedience supplies both refutations. The converse is not true for an arbitrary distinction; the pole-affirming row language below is the special case where the missing genjo-fusion clause is built into the semantics. -/ theorem errorFree_of_obeys {d : Distinction G} (h : d.ObeysSeparateFuse) : ErrorFree G d := ⟨fun t => Grid.not_collapse_of_obeysSeparateFuse h t, Grid.not_freeze_of_obeysSeparateFuse h⟩ namespace RecordedUtterance variable {G : Grid Contrib} {L : ClaimLanguage G} /-- The answered call is the call carried by the utterance's weld. -/ @[simp] theorem answersCall_eq_weld_call (u : RecordedUtterance G L) : answersCall u = u.weld.call := rfl /-- Fitting the offered tier is exactly truth at that tier. -/ theorem fitsOfferedTier_iff_trueAt (u : RecordedUtterance G L) : FitsOfferedTier u ↔ L.TrueAt u.offeredAt u.content := Iff.rfl end RecordedUtterance namespace ErrorGrade /-- Verdict errors speak in the assertable voice. -/ theorem verdict_voice_assertable : ErrorGrade.voice ErrorGrade.verdict = VerdictVoice.assertable := rfl /-- Shortfall errors speak in the displayable voice. -/ theorem shortfall_voice_displayable : ErrorGrade.voice ErrorGrade.shortfall = VerdictVoice.displayable := rfl end ErrorGrade end Grid end WAA ===== FILE: WeldAndArrow/Consequences/Compounds.lean ===== /- ================================================================================ WeldAndArrow.Consequences.Compounds Compound positions as decompositions over taxonomy rows ================================================================================ Reading and motivation: Identification/Commentary.lean, C.2. -/ import WeldAndArrow.Consequences.Taxonomy namespace WAA namespace Grid namespace DirectedConvention namespace BeingConvention namespace GridConvention /-- Which error-slot of a taxonomy cell a component occupies. -/ inductive CellSide | collapse | freeze /-- Whether a cited cell is part of the compound's stack or rides alongside it. This is not a grade distinction: every cell component is Grade 1. -/ inductive Role | core | alongside /-- Prose-facing names for distinct faces of a taxonomy cell. Facets do not add rows; they keep repeated row/side citations from collapsing into one term. -/ inductive Facet | plain | epistemic | practical | maximized | furniture | structure | direction | domain | command /-- Elements the prose explicitly marks grid-legal rather than erroneous. -/ inductive LegalElement | valueCreation | causalSkeleton /-- One element of a compound position's decomposition. Components are classificatory data, not proofs that the cited rows collapse or freeze. The generated rows already prove their own `not_freeze` and collapse-self-refutation theorems; a compound records the error-slot a position occupies against that sound distinction. The row field is typed as `TableRow`, so a decomposition can only cite cells already present in the Grade-1 table. -/ inductive CompoundComponent | cell (row : TableRow) (side : CellSide) (facet : Facet) (role : Role) | legal (l : LegalElement) namespace CompoundComponent /-- Count only the stacked cells of a compound position. -/ def countCoreCells : List CompoundComponent -> Nat | [] => 0 | cell _ _ _ Role.core :: xs => Nat.succ (countCoreCells xs) | _ :: xs => countCoreCells xs /-- Count Grade-1 cells that are recorded as riding alongside the stack. -/ def countAlongsideCells : List CompoundComponent -> Nat | [] => 0 | cell _ _ _ Role.alongside :: xs => Nat.succ (countAlongsideCells xs) | _ :: xs => countAlongsideCells xs /-- Count non-error legal elements carried in the decomposition. -/ def countLegal : List CompoundComponent -> Nat | [] => 0 | legal _ :: xs => Nat.succ (countLegal xs) | _ :: xs => countLegal xs /-- Cells are Grade-1 verdict material; legal elements carry no verdict. -/ def voice : CompoundComponent -> Option VerdictVoice | cell _ _ _ _ => some VerdictVoice.assertable | legal _ => none end CompoundComponent /-- Compound positions whose prose decomposition is now made inspectable. -/ inductive CompoundPosition | skepticism | solipsism | exitPremise | existentialism | ledgerPicture namespace CompoundPosition /-- The table-cell decomposition of each compound position. -/ def decomposition : CompoundPosition -> List CompoundComponent | skepticism => [ .cell (.prose .beingNonBeing) .freeze .epistemic .core ] | solipsism => [ .cell (.generated .karmaInga) .freeze .maximized .core, .cell (.generated .perCallGlobal) .freeze .direction .core, .cell (.generated .subjectObjectAxis) .freeze .domain .core ] | exitPremise => [ .cell (.prose .beingNonBeing) .freeze .practical .core, .cell (.generated .terminusExit) .collapse .plain .core, .cell (.generated .standingDated) .freeze .furniture .core, .cell (.generated .deliveryIndex) .collapse .plain .alongside ] | existentialism => [ .cell .ladderSchema .freeze .plain .core, .cell (.generated .perCallGlobal) .freeze .direction .core, .cell (.generated .standingDated) .freeze .structure .core, .cell (.generated .karmaInga) .freeze .plain .core, .legal .valueCreation ] | ledgerPicture => [ .cell (.generated .deliveryIndex) .freeze .plain .core, .cell (.generated .selfPoleTransposed) .freeze .plain .core, .cell (.generated .deliveryIndex) .collapse .command .alongside, .legal .causalSkeleton ] theorem skepticism_decomposition : decomposition skepticism = [ .cell (.prose .beingNonBeing) .freeze .epistemic .core ] := rfl theorem solipsism_decomposition : decomposition solipsism = [ .cell (.generated .karmaInga) .freeze .maximized .core, .cell (.generated .perCallGlobal) .freeze .direction .core, .cell (.generated .subjectObjectAxis) .freeze .domain .core ] := rfl theorem exitPremise_decomposition : decomposition exitPremise = [ .cell (.prose .beingNonBeing) .freeze .practical .core, .cell (.generated .terminusExit) .collapse .plain .core, .cell (.generated .standingDated) .freeze .furniture .core, .cell (.generated .deliveryIndex) .collapse .plain .alongside ] := rfl theorem existentialism_decomposition : decomposition existentialism = [ .cell .ladderSchema .freeze .plain .core, .cell (.generated .perCallGlobal) .freeze .direction .core, .cell (.generated .standingDated) .freeze .structure .core, .cell (.generated .karmaInga) .freeze .plain .core, .legal .valueCreation ] := rfl theorem ledgerPicture_decomposition : decomposition ledgerPicture = [ .cell (.generated .deliveryIndex) .freeze .plain .core, .cell (.generated .selfPoleTransposed) .freeze .plain .core, .cell (.generated .deliveryIndex) .collapse .command .alongside, .legal .causalSkeleton ] := rfl theorem skepticism_core_cell_count : CompoundComponent.countCoreCells (decomposition skepticism) = 1 := rfl theorem solipsism_core_cell_count : CompoundComponent.countCoreCells (decomposition solipsism) = 3 := rfl theorem exitPremise_core_cell_count : CompoundComponent.countCoreCells (decomposition exitPremise) = 3 := rfl theorem exitPremise_alongside_cell_count : CompoundComponent.countAlongsideCells (decomposition exitPremise) = 1 := rfl theorem existentialism_core_cell_count : CompoundComponent.countCoreCells (decomposition existentialism) = 4 := rfl theorem existentialism_legal_count : CompoundComponent.countLegal (decomposition existentialism) = 1 := rfl theorem ledgerPicture_core_cell_count : CompoundComponent.countCoreCells (decomposition ledgerPicture) = 2 := rfl theorem ledgerPicture_alongside_cell_count : CompoundComponent.countAlongsideCells (decomposition ledgerPicture) = 1 := rfl theorem ledgerPicture_legal_count : CompoundComponent.countLegal (decomposition ledgerPicture) = 1 := rfl theorem exitPremise_voices : (decomposition exitPremise).map CompoundComponent.voice = [ some VerdictVoice.assertable, some VerdictVoice.assertable, some VerdictVoice.assertable, some VerdictVoice.assertable ] := rfl theorem existentialism_voices : (decomposition existentialism).map CompoundComponent.voice = [ some VerdictVoice.assertable, some VerdictVoice.assertable, some VerdictVoice.assertable, some VerdictVoice.assertable, none ] := rfl theorem ledgerPicture_voices : (decomposition ledgerPicture).map CompoundComponent.voice = [ some VerdictVoice.assertable, some VerdictVoice.assertable, some VerdictVoice.assertable, none ] := rfl theorem skepticism_contains_epistemic_nihilism : CompoundComponent.cell (.prose .beingNonBeing) .freeze .epistemic .core ∈ decomposition skepticism := by simp [decomposition] theorem solipsism_contains_row2_domain_evacuation : CompoundComponent.cell (.generated .subjectObjectAxis) .freeze .domain .core ∈ decomposition solipsism := by simp [decomposition] theorem exitPremise_contains_terminus_exit : CompoundComponent.cell (.generated .terminusExit) .collapse .plain .core ∈ decomposition exitPremise := by simp [decomposition] theorem exitPremise_contains_delivery_arrogation : CompoundComponent.cell (.generated .deliveryIndex) .collapse .plain .alongside ∈ decomposition exitPremise := by simp [decomposition] theorem existentialism_contains_sartrean_structure : CompoundComponent.cell (.generated .standingDated) .freeze .structure .core ∈ decomposition existentialism := by simp [decomposition] theorem existentialism_contains_legal_valueCreation : CompoundComponent.legal .valueCreation ∈ decomposition existentialism := by simp [decomposition] theorem ledgerPicture_contains_possession_freeze : CompoundComponent.cell (.generated .deliveryIndex) .freeze .plain .core ∈ decomposition ledgerPicture := by simp [decomposition] theorem ledgerPicture_contains_transposed_mechanism : CompoundComponent.cell (.generated .selfPoleTransposed) .freeze .plain .core ∈ decomposition ledgerPicture := by simp [decomposition] theorem ledgerPicture_contains_delivery_arrogation : CompoundComponent.cell (.generated .deliveryIndex) .collapse .command .alongside ∈ decomposition ledgerPicture := by simp [decomposition] theorem ledgerPicture_contains_legal_causalSkeleton : CompoundComponent.legal .causalSkeleton ∈ decomposition ledgerPicture := by simp [decomposition] variable {Contrib : Type} [PreorderBot Contrib] variable (G : Grid Contrib) theorem solipsism_karmaInga_row_not_freeze : ¬ (karmaIngaRow G).Freeze := karmaIngaRow_not_freeze G theorem solipsism_perCallGlobal_row_not_freeze : ¬ (perCallGlobalRow G).Freeze := perCallGlobalRow_not_freeze G theorem solipsism_subjectObjectAxis_row_not_freeze : ¬ (subjectObjectAxisRow G).Freeze := subjectObjectAxisRow_not_freeze G theorem exitPremise_terminusExit_collapse_self_refuting (t : Tier G) : ¬ (terminusExitRow G).Collapse t := exit_collapse_self_refuting G t theorem exitPremise_deliveryIndex_collapse_self_refuting (t : Tier G) : ¬ (deliveryIndexRow G).Collapse t := misfed_register_collapse_self_refuting G t theorem exitPremise_standingDated_row_not_freeze : ¬ (standingDatedRow G).Freeze := standingDatedRow_not_freeze G theorem existentialism_perCallGlobal_row_not_freeze : ¬ (perCallGlobalRow G).Freeze := perCallGlobalRow_not_freeze G theorem existentialism_standingDated_row_not_freeze : ¬ (standingDatedRow G).Freeze := standingDatedRow_not_freeze G theorem existentialism_karmaInga_row_not_freeze : ¬ (karmaIngaRow G).Freeze := karmaIngaRow_not_freeze G theorem ledgerPicture_deliveryIndex_row_not_freeze : ¬ (deliveryIndexRow G).Freeze := deliveryIndexRow_not_freeze G theorem ledgerPicture_deliveryIndex_collapse_self_refuting (t : Tier G) : ¬ (deliveryIndexRow G).Collapse t := misfed_register_collapse_self_refuting G t theorem ledgerPicture_selfPoleTransposed_row_not_freeze : ¬ (selfPoleTransposedRow G).Freeze := selfPoleTransposedRow_not_freeze G end CompoundPosition end GridConvention end BeingConvention end DirectedConvention end Grid end WAA ===== FILE: WeldAndArrow/Consequences/ContentRows.lean ===== /- ================================================================================ WeldAndArrow.Consequences.ContentRows Content-bearing layer rows and the content beings ladder ================================================================================ Reading and motivation: Identification/Commentary.lean, C.2. -/ import WeldAndArrow.Consequences.Ladder namespace WAA namespace Grid variable {Contrib : Type} [PreorderBot Contrib] variable (G : Grid Contrib) namespace DirectedConvention namespace BeingConvention namespace GridConvention /- -------------------------------------------------------------------------- Content-bearing layer rows -------------------------------------------------------------------------- -/ /-- Content-bearing language for the same layer claims. The convention-live side is still the live-share condition; the denial side now has content specific to the row. -/ def contentLayerLanguage (G : Grid Contrib) : ClaimLanguage G where Claim := LayerClaim Holds | .floor, _ => True | .actTime w, .conventionLive _ => G.HasSelfPoleIndex w | .actTime _, .layerDenied .directedTime => DirectionVoid Contrib | .actTime _, .layerDenied .intraWeldArrow => ∀ b : G.Being, ¬ G.ResponseVariesWithCall b | .actTime _, .layerDenied .beings => G.AllStone | .actTime _, .layerDenied .gridLens => ∀ t : Tier G, ¬ Tier.hasLiveShare G t | .actTime _, .layerDenied .weldGrain => ¬ ∃ w : G.Weld, G.Actual w def contentLayerRow (G : Grid Contrib) (l : ConventionLayer) : Distinction G := { language := contentLayerLanguage G sideA := .conventionLive l sideB := .layerDenied l } def contentBeforeAfterRow (G : Grid Contrib) : Distinction G := contentLayerRow G .directedTime def contentIntraWeldArrowRow (G : Grid Contrib) : Distinction G := contentLayerRow G .intraWeldArrow def contentBeingsRow (G : Grid Contrib) : Distinction G := contentLayerRow G .beings def contentGridLensRow (G : Grid Contrib) : Distinction G := contentLayerRow G .gridLens def contentWeldRow (G : Grid Contrib) : Distinction G := contentLayerRow G .weldGrain theorem contentLayerRow_obeys_of_direction (h : ∃ a b : Contrib, Strict a b) : (contentLayerRow G .directedTime).ObeysSeparateFuse := by rcases h with ⟨a, b, hstrict⟩ constructor · intro t hLive cases t with | floor => cases hLive | actTime _ => dsimp [contentLayerRow, contentLayerLanguage, ClaimLanguage.TrueAt] intro hiff exact (hiff.mp hLive) a b hstrict · intro t hNotLive cases t with | floor => constructor <;> intro _ <;> exact True.intro | actTime _ => dsimp [contentLayerRow, contentLayerLanguage, ClaimLanguage.TrueAt] constructor · intro hLive exact False.elim (hNotLive hLive) · intro hvoid exact False.elim (hvoid a b hstrict) theorem contentLayerRow_obeys_of_being (h : ∃ b : G.Being, ¬ G.Stone b) : (contentLayerRow G .beings).ObeysSeparateFuse := by rcases h with ⟨b, hnotStone⟩ constructor · intro t hLive cases t with | floor => cases hLive | actTime _ => dsimp [contentLayerRow, contentLayerLanguage, ClaimLanguage.TrueAt] intro hiff exact hnotStone ((hiff.mp hLive) b) · intro t hNotLive cases t with | floor => constructor <;> intro _ <;> exact True.intro | actTime _ => dsimp [contentLayerRow, contentLayerLanguage, ClaimLanguage.TrueAt] constructor · intro hLive exact False.elim (hNotLive hLive) · intro hall exact False.elim (hnotStone (hall b)) theorem contentLayerRow_obeys_of_variation (h : ∃ b : G.Being, G.ResponseVariesWithCall b) : (contentLayerRow G .intraWeldArrow).ObeysSeparateFuse := by rcases h with ⟨b, hvaries⟩ constructor · intro t hLive cases t with | floor => cases hLive | actTime _ => dsimp [contentLayerRow, contentLayerLanguage, ClaimLanguage.TrueAt] intro hiff exact (hiff.mp hLive) b hvaries · intro t hNotLive cases t with | floor => constructor <;> intro _ <;> exact True.intro | actTime _ => dsimp [contentLayerRow, contentLayerLanguage, ClaimLanguage.TrueAt] constructor · intro hLive exact False.elim (hNotLive hLive) · intro hstable exact False.elim (hstable b hvaries) theorem contentLayerRow_obeys_of_liveTier (h : ∃ t : Tier G, Tier.hasLiveShare G t) : (contentLayerRow G .gridLens).ObeysSeparateFuse := by rcases h with ⟨liveTier, hLiveTier⟩ constructor · intro t hLive cases t with | floor => cases hLive | actTime _ => dsimp [contentLayerRow, contentLayerLanguage, ClaimLanguage.TrueAt] intro hiff exact (hiff.mp hLive) liveTier hLiveTier · intro t hNotLive cases t with | floor => constructor <;> intro _ <;> exact True.intro | actTime _ => dsimp [contentLayerRow, contentLayerLanguage, ClaimLanguage.TrueAt] constructor · intro hLive exact False.elim (hNotLive hLive) · intro hnoLive exact False.elim (hnoLive liveTier hLiveTier) theorem contentLayerRow_obeys_of_actual (h : ∃ w : G.Weld, G.Actual w) : (contentLayerRow G .weldGrain).ObeysSeparateFuse := by constructor · intro t hLive cases t with | floor => cases hLive | actTime _ => dsimp [contentLayerRow, contentLayerLanguage, ClaimLanguage.TrueAt] intro hiff exact (hiff.mp hLive) h · intro t hNotLive cases t with | floor => constructor <;> intro _ <;> exact True.intro | actTime _ => dsimp [contentLayerRow, contentLayerLanguage, ClaimLanguage.TrueAt] constructor · intro hLive exact False.elim (hNotLive hLive) · intro hnone exact False.elim (hnone h) theorem contentBeforeAfterRow_obeys_of_direction (h : ∃ a b : Contrib, Strict a b) : (contentBeforeAfterRow G).ObeysSeparateFuse := contentLayerRow_obeys_of_direction G h theorem contentIntraWeldArrowRow_obeys_of_variation (h : ∃ b : G.Being, G.ResponseVariesWithCall b) : (contentIntraWeldArrowRow G).ObeysSeparateFuse := contentLayerRow_obeys_of_variation G h theorem contentBeingsRow_obeys_of_being (h : ∃ b : G.Being, ¬ G.Stone b) : (contentBeingsRow G).ObeysSeparateFuse := contentLayerRow_obeys_of_being G h theorem contentGridLensRow_obeys_of_liveTier (h : ∃ t : Tier G, Tier.hasLiveShare G t) : (contentGridLensRow G).ObeysSeparateFuse := contentLayerRow_obeys_of_liveTier G h theorem contentWeldRow_obeys_of_actual (h : ∃ w : G.Weld, G.Actual w) : (contentWeldRow G).ObeysSeparateFuse := contentLayerRow_obeys_of_actual G h /-- An actual utterance of the beings-denial cannot fit an act-time tier: the utterer's actual response supplies a non-stone witness. -/ theorem beings_denial_fits_only_floor (u : RecordedUtterance G (contentLayerLanguage G)) (hc : u.content = .layerDenied .beings) (w' : G.Weld) (ht : u.offeredAt = .actTime w') : ¬ u.FitsOfferedTier := by intro hfit change (contentLayerLanguage G).TrueAt u.offeredAt u.content at hfit rw [ht, hc] at hfit dsimp [contentLayerLanguage, ClaimLanguage.TrueAt] at hfit exact (G.not_stone_of_actual u.weld u.actual) (hfit u.weld.agent) /-- A directed-time denial offered by an appropriating utterer cannot fit an act-time tier: the utterer's live share is itself a strict direction. -/ theorem time_denial_unfit_for_appropriating_utterer (u : RecordedUtterance G (contentLayerLanguage G)) (hc : u.content = .layerDenied .directedTime) (hidx : G.HasSelfPoleIndex u.weld) (w' : G.Weld) (ht : u.offeredAt = .actTime w') : ¬ u.FitsOfferedTier := by intro hfit change (contentLayerLanguage G).TrueAt u.offeredAt u.content at hfit rw [ht, hc] at hfit dsimp [contentLayerLanguage, ClaimLanguage.TrueAt] at hfit exact hfit (shareBot : Contrib) (G.share u.weld) (G.strict_shareBot_of_hasSelfPoleIndex u.weld hidx) /-- The schema-level intra-weld arrow denial is still live-tier unfit by the row-language check. A single recorded content utterance does not by itself extract two different responses, so the stronger content-variation form is intentionally not claimed here. -/ theorem interior_order_denial_unfit_for_live_utterer (u : RecordedUtterance G (rowLanguage G)) (hcontent : u.content = .denied (.layer .intraWeldArrow)) (hlive : Tier.hasLiveShare G u.offeredAt) : ¬ RecordedUtterance.FitsOfferedTier u := denied_misfits_live_offer G (.layer .intraWeldArrow) u hcontent hlive def contentBeingsLadder (G : Grid Contrib) : Nat → Distinction G := ladder (contentBeingsRow G) theorem contentBeingsLadder_obeys_of_being (h : ∃ b : G.Being, ¬ G.Stone b) : ∀ n, (contentBeingsLadder G n).ObeysSeparateFuse := ladder_obeys (G := G) (contentBeingsRow_obeys_of_being G h) theorem contentBeingsLadder_no_level_final_of_being (h : ∃ b : G.Being, ¬ G.Stone b) : ∀ n, ¬ (contentBeingsLadder G n).Freeze := no_level_final_of_obeys (G := G) (contentBeingsRow_obeys_of_being G h) end GridConvention end BeingConvention end DirectedConvention end Grid end WAA ===== FILE: WeldAndArrow/Consequences/FoxCase.lean ===== /- ================================================================================ WeldAndArrow.Consequences.FoxCase The fox koan as a concrete grid run-through ================================================================================ This module gives the fox sentence a checked model: call, act, weld, arrow, returns, clenched receptions, release-as-rung, nothing-kept, and the deliberately built-in absence of any pole-class act in the case. Reading and motivation: Identification/Commentary.lean, C.7a. -/ import WeldAndArrow.Consequences.Taxonomy namespace WAA namespace FoxCase open Grid open Grid.DirectedConvention open Grid.DirectedConvention.BeingConvention open Grid.DirectedConvention.BeingConvention.GridConvention inductive FoxCall | question | fruit | turningWord deriving DecidableEq inductive FoxResponse | notFall | clench | release deriving DecidableEq /-- The concrete fox grid: life 0 answers the question; later lives receive fruit; the turning word releases without reaching the pole. -/ def foxGrid : Grid Nat where Being := Nat Call := FoxCall Response := FoxResponse respondsTo b c := match b, c with | 0, .question => some .notFall | _, .fruit => some .clench | _, .turningWord => some .release | _, _ => none grade _ _ r := match r with | .notFall => 5 | .clench => 5 | .release => 1 conditions deed reception := reception.agent = deed.agent + 1 ∨ deed.agent = 0 def sentenceWeld : foxGrid.Weld := ⟨(show foxGrid.Being from (0 : Nat)), FoxCall.question, FoxResponse.notFall⟩ def lifeReception (n : Nat) : foxGrid.Weld := ⟨n, FoxCall.fruit, FoxResponse.clench⟩ def releaseWeld : foxGrid.Weld := ⟨(show foxGrid.Being from (1 : Nat)), FoxCall.turningWord, FoxResponse.release⟩ def beforeRelease : Config Nat := { tendency := 5 } theorem sentenceWeld_actual : foxGrid.Actual sentenceWeld := by dsimp [Grid.Actual, foxGrid, sentenceWeld] rfl theorem sentenceWeld_hasSelfPoleIndex : foxGrid.HasSelfPoleIndex sentenceWeld := by dsimp [Grid.HasSelfPoleIndex, Grid.share, foxGrid, sentenceWeld, AtBot, shareBot] show ¬ (5 : Nat) ≤ 0 decide /-- "He says not fall": the answer is actual and pitched hard to the self-pole. -/ theorem fox_sentence_live_selfPole : foxGrid.Actual sentenceWeld ∧ foxGrid.HasSelfPoleIndex sentenceWeld := ⟨sentenceWeld_actual, sentenceWeld_hasSelfPoleIndex⟩ /-- "The arrow carries delivery, not desert": changing delivery leaves grade and share data untouched. -/ theorem fox_arrow_index_free (conditions₁ conditions₂ : foxGrid.Weld -> foxGrid.Weld -> Prop) : (∀ b c r, (foxGrid.withConditions conditions₁).grade b c r = (foxGrid.withConditions conditions₂).grade b c r) ∧ ∀ w, (foxGrid.withConditions conditions₁).share w = (foxGrid.withConditions conditions₂).share w := ⟨foxGrid.grade_independent_of_conditions conditions₁ conditions₂, foxGrid.share_independent_of_conditions conditions₁ conditions₂⟩ /-- "Five hundred fox lives arrive": the sentence's fruit is delivered life by life. -/ theorem fox_returns_delivered (n : Nat) : DeliveredTo foxGrid sentenceWeld (lifeReception (n + 1)) := by dsimp [DeliveredTo, foxGrid, sentenceWeld, lifeReception] exact Or.inr rfl /-- "Each life's receiving is itself a deed": every fruit reception is actual and clenched at live share. -/ theorem fox_reception_clenched (n : Nat) : foxGrid.Actual (lifeReception (n + 1)) ∧ foxGrid.HasSelfPoleIndex (lifeReception (n + 1)) := by constructor · rfl · dsimp [Grid.HasSelfPoleIndex, Grid.share, foxGrid, lifeReception, AtBot, shareBot] show ¬ (5 : Nat) ≤ 0 decide /-- "The configuration carries only tendency": no self-index field is stored between deeds. -/ theorem fox_config_carries_only_tendency (cfg : Config Nat) : cfg = { tendency := cfg.tendency } := by cases cfg rfl /-- "The saying-mode is enacted anew": re-pitching forgets the prior configuration once the received weld is fixed. -/ theorem fox_rePitch_forgets (before₁ before₂ : Config Nat) (received : foxGrid.Weld) : foxGrid.rePitch before₁ received = foxGrid.rePitch before₂ received := foxGrid.rePitch_forgets before₁ before₂ received theorem releaseWeld_actual : foxGrid.Actual releaseWeld := by dsimp [Grid.Actual, foxGrid, releaseWeld] rfl /-- "A kensho, a rung and not a pole": the turning-word reception drops share from the prior tendency while remaining live. -/ theorem fox_release_rung_not_pole : foxGrid.Actual releaseWeld ∧ foxGrid.IsShareDrop beforeRelease releaseWeld ∧ ¬ AtBot (foxGrid.share releaseWeld) := by refine ⟨releaseWeld_actual, ?_, ?_⟩ · dsimp [Grid.IsShareDrop, Grid.share, foxGrid, beforeRelease, releaseWeld] constructor · show (1 : Nat) ≤ 5 decide · show ¬ (5 : Nat) ≤ 1 decide · dsimp [Grid.share, foxGrid, releaseWeld, AtBot, shareBot] show ¬ (1 : Nat) ≤ 0 decide /-- "The whole return appropriated": the release reaches back to the original sentence's delivered fruit. -/ theorem fox_reachBack_full_at_release : WaaReachBackFull foxGrid sentenceWeld releaseWeld := by dsimp [WaaReachBackFull, foxGrid, sentenceWeld, releaseWeld] exact Or.inr rfl /-- "And nothing is kept": any score that reads the post-release configuration sees only the release reception, not a stored attainment. -/ theorem fox_nothing_kept {α : Type} (score : Config Nat -> α) (before₁ before₂ : Config Nat) : score (foxGrid.rePitch before₁ releaseWeld) = score (foxGrid.rePitch before₂ releaseWeld) := foxGrid.accumulated_attainment_constant_of_same_final score before₁ before₂ releaseWeld /-- "The koan never tests share-zero": this is true by construction of the model's grades, so the absence is part of the display. -/ theorem fox_never_tests_pole : ∀ w : foxGrid.Weld, foxGrid.Actual w -> ¬ AtBot (foxGrid.share w) := by intro w _hactual cases w with | mk agent call response => cases response <;> dsimp [Grid.share, foxGrid, AtBot, shareBot] · show ¬ (5 : Nat) ≤ 0 decide · show ¬ (5 : Nat) ≤ 0 decide · show ¬ (1 : Nat) ≤ 0 decide /-- The display convention merging all lives into "the fox"; the fine tags remain natural-numbered lives. -/ def foxSeriesCoarsening : BeingCoarsening foxGrid Unit where proj _ := () theorem foxSeries_macro_sentient : foxSeriesCoarsening.SentientTag () := ⟨(show foxGrid.Being from (0 : Nat)), rfl, ⟨FoxCall.question, ⟨FoxResponse.notFall, rfl⟩⟩⟩ theorem foxSeries_macro_selfConditioning : foxSeriesCoarsening.SelfConditioningTag () := by refine ⟨sentenceWeld, lifeReception 1, rfl, rfl, ?_, ?_⟩ · rfl · dsimp [DeliveredTo, foxGrid, sentenceWeld, lifeReception] exact Or.inr rfl /-- Fine lives remain distinct even where the display coarsens them into "the fox". -/ theorem fox_consecutive_lives_distinct (n : Nat) : n ≠ n + 1 := Nat.ne_of_lt (Nat.lt_succ_self n) def oldManUtterance : Grid.RecordedUtterance foxGrid (rowLanguage foxGrid) where weld := sentenceWeld actual := sentenceWeld_actual offeredAt := Tier.actTime sentenceWeld content := .denied .foxWeld /-- "Not-fall", voiced to a live audience, repeats the fox's tier-error. -/ theorem oldMan_utterance_misfits : ¬ oldManUtterance.FitsOfferedTier := fox_utterance_misfits_live_offer foxGrid oldManUtterance rfl sentenceWeld_hasSelfPoleIndex def daishugyoFloorUtterance : Grid.RecordedUtterance foxGrid (rowLanguage foxGrid) where weld := sentenceWeld actual := sentenceWeld_actual offeredAt := Tier.floor content := .denied .foxWeld def daishugyoConventionalUtterance : Grid.RecordedUtterance foxGrid (rowLanguage foxGrid) where weld := releaseWeld actual := releaseWeld_actual offeredAt := Tier.actTime releaseWeld content := .inForce .foxWeld /-- "Daishugyo diagnoses": the two fox faces fit when each is held at its proper tier. -/ theorem daishugyo_diagnosis_fits : daishugyoFloorUtterance.FitsOfferedTier ∧ daishugyoConventionalUtterance.FitsOfferedTier := ⟨True.intro, True.intro⟩ def jinshinIngaInstruction : Grid.RecordedUtterance foxGrid (rowLanguage foxGrid) where weld := releaseWeld actual := releaseWeld_actual offeredAt := Tier.actTime releaseWeld content := .inForce .foxWeld /-- "Jinshin inga instructs": not-obscure, offered at a live tier, fits. -/ theorem jinshinInga_instruction_fits : jinshinIngaInstruction.FitsOfferedTier := True.intro def jinshinIngaFloorVoicing : Grid.RecordedUtterance foxGrid (rowLanguage foxGrid) where weld := releaseWeld actual := releaseWeld_actual offeredAt := Tier.actTime releaseWeld content := .denied .foxWeld theorem releaseWeld_hasSelfPoleIndex : foxGrid.HasSelfPoleIndex releaseWeld := by dsimp [Grid.HasSelfPoleIndex, Grid.share, foxGrid, releaseWeld, AtBot, shareBot] show ¬ (1 : Nat) ≤ 0 decide /-- "Voicing the floor would repeat the fox's error to a live audience." -/ theorem jinshinInga_floor_voicing_would_misfit : ¬ jinshinIngaFloorVoicing.FitsOfferedTier := denied_misfits_live_offer foxGrid .foxWeld jinshinIngaFloorVoicing rfl releaseWeld_hasSelfPoleIndex /-- The Dogen doubling gloss, grid-internally only: Daishugyo and Jinshin inga both fit at their act-times, while the floor-voicing counterfactual misfits. -/ theorem dogen_doubling_both_fit : (daishugyoFloorUtterance.FitsOfferedTier ∧ daishugyoConventionalUtterance.FitsOfferedTier) ∧ jinshinIngaInstruction.FitsOfferedTier ∧ ¬ jinshinIngaFloorVoicing.FitsOfferedTier := ⟨daishugyo_diagnosis_fits, jinshinInga_instruction_fits, jinshinInga_floor_voicing_would_misfit⟩ end FoxCase end WAA ===== FILE: WeldAndArrow/Consequences/Ladder.lean ===== /- ================================================================================ WeldAndArrow.Consequences.Ladder Re-emptying ladder generated from taxonomy rows ================================================================================ Reading and motivation: Identification/Commentary.lean, C.2. -/ import WeldAndArrow.Consequences.Taxonomy namespace WAA namespace Grid variable {Contrib : Type} [PreorderBot Contrib] variable (G : Grid Contrib) namespace DirectedConvention namespace BeingConvention namespace GridConvention /- -------------------------------------------------------------------------- Re-emptying ladder -------------------------------------------------------------------------- -/ /-- The two sides used to re-empty a distinction. Deliberately, neither side quantifies over ladder levels; level-quantification stays in meta-theorems. -/ inductive LadderSide | liveBelow | finalBelow /-- Re-empty a distinction: the new row separates the lower row's live separation from the claim that the lower row survives the floor. -/ def reEmptied {G : Grid Contrib} (d : Distinction G) : Distinction G where language := { Claim := LadderSide Holds := fun t c => match t, c with | .floor, _ => True | .actTime w, .liveBelow => d.Separated (.actTime w) | .actTime _, .finalBelow => d.Freeze } sideA := .liveBelow sideB := .finalBelow def ladder {G : Grid Contrib} (d : Distinction G) : Nat → Distinction G | 0 => d | n + 1 => reEmptied (ladder d n) theorem reEmptied_obeysSeparateFuse {d : Distinction G} (h : d.ObeysSeparateFuse) : (reEmptied d).ObeysSeparateFuse := by constructor · intro t hLive cases t with | floor => cases hLive | actTime _ => dsimp [reEmptied, ClaimLanguage.TrueAt] intro hiff exact (Grid.not_freeze_of_obeysSeparateFuse h) (hiff.mp (G.separated_of_obeysSeparateFuse h hLive)) · intro t hNotLive cases t with | floor => constructor <;> intro _ <;> exact True.intro | actTime _ => dsimp [reEmptied, ClaimLanguage.TrueAt] constructor · intro hsep exact False.elim (hNotLive hsep.left) · intro hfreeze exact False.elim ((Grid.not_freeze_of_obeysSeparateFuse h) hfreeze) /-- Error-freedom below is enough for the re-emptying row above to obey the full rule. This is the cumulative ladder form: `finalBelow` is exactly the lower row's freeze, so the non-live clause is supplied by the lower row's refutation rather than by a new stability premise. -/ theorem reEmptied_obeys_of_errorFree {d : Distinction G} (h : ErrorFree G d) : (reEmptied d).ObeysSeparateFuse := by constructor · intro t hLive cases t with | floor => cases hLive | actTime w => dsimp [reEmptied, ClaimLanguage.TrueAt] have hnotIff : ¬ (d.language.TrueAt (Tier.actTime w) d.sideA ↔ d.language.TrueAt (Tier.actTime w) d.sideB) := by intro hiff exact h.left (Tier.actTime w) ⟨hLive, hiff⟩ have hsep : d.Separated (Tier.actTime w) := ⟨hLive, hnotIff⟩ intro hiff exact h.right (hiff.mp hsep) · intro t hNotLive cases t with | floor => dsimp [reEmptied, ClaimLanguage.TrueAt] constructor <;> intro _ <;> exact True.intro | actTime _ => dsimp [reEmptied, ClaimLanguage.TrueAt] constructor · intro hsep exact False.elim (hNotLive hsep.left) · intro hfreeze exact False.elim (h.right hfreeze) theorem ladder_obeys {d : Distinction G} (h : d.ObeysSeparateFuse) : ∀ n, (ladder d n).ObeysSeparateFuse := by intro n induction n with | zero => exact h | succ _ ih => exact reEmptied_obeysSeparateFuse (G := G) ih /-- Once a seed is error-free, every positive ladder level obeys without a separate obedience hypothesis at level zero. -/ theorem ladder_obeys_of_errorFree {d : Distinction G} (h : ErrorFree G d) : ∀ n, (ladder d (n + 1)).ObeysSeparateFuse := by intro n induction n with | zero => exact reEmptied_obeys_of_errorFree (G := G) h | succ _ ih => exact reEmptied_obeysSeparateFuse (G := G) ih theorem ladder_errorFree_of_errorFree {d : Distinction G} (h : ErrorFree G d) : ∀ n, ErrorFree G (ladder d (n + 1)) := by intro n exact Grid.errorFree_of_obeys G (ladder_obeys_of_errorFree (G := G) h n) theorem no_level_final_of_obeys {d : Distinction G} (h : d.ObeysSeparateFuse) : ∀ n, ¬ (ladder d n).Freeze := by intro n exact Grid.not_freeze_of_obeysSeparateFuse (ladder_obeys (G := G) h n) /-- Emptiness-sickness has no final level to name: with an error-free seed, neither level zero nor any positive re-emptying level can freeze. -/ theorem no_final_level_of_errorFree {d : Distinction G} (h : ErrorFree G d) : ¬ ∃ n, (ladder d n).Freeze := by rintro ⟨n, hfreeze⟩ cases n with | zero => exact h.right hfreeze | succ n => exact (Grid.not_freeze_of_obeysSeparateFuse (ladder_obeys_of_errorFree (G := G) h n)) hfreeze theorem ladder_collapse_self_refuting {d : Distinction G} (h : d.ObeysSeparateFuse) : ∀ n t, ¬ (ladder d n).Collapse t := by intro n t exact Grid.not_collapse_of_obeysSeparateFuse (ladder_obeys (G := G) h n) t def beingsLadder (G : Grid Contrib) : Nat → Distinction G := ladder (beingsRow G) def beforeAfterLadder (G : Grid Contrib) : Nat → Distinction G := ladder (beforeAfterRow G) def intraWeldArrowLadder (G : Grid Contrib) : Nat → Distinction G := ladder (intraWeldArrowRow G) def gridLensLadder (G : Grid Contrib) : Nat → Distinction G := ladder (gridLensRow G) def weldLadder (G : Grid Contrib) : Nat → Distinction G := ladder (weldRow G) def doerDeedLadder (G : Grid Contrib) : Nat → Distinction G := ladder (doerDeedRow G) theorem beingsLadder_obeys [∀ w : G.Weld, Decidable (AtBot (G.share w))] : ∀ n, (beingsLadder G n).ObeysSeparateFuse := ladder_obeys (G := G) (beingsRow_obeys G) theorem beingsLadder_obeys_succ : ∀ n, (beingsLadder G (n + 1)).ObeysSeparateFuse := ladder_obeys_of_errorFree (G := G) (rowOf_errorFree G (.layer .beings)) theorem beingsLadder_no_level_final : ∀ n, ¬ (beingsLadder G n).Freeze := by intro n cases n with | zero => exact beingsRow_not_freeze G | succ n => exact Grid.not_freeze_of_obeysSeparateFuse (beingsLadder_obeys_succ G n) theorem beforeAfterLadder_obeys [∀ w : G.Weld, Decidable (AtBot (G.share w))] : ∀ n, (beforeAfterLadder G n).ObeysSeparateFuse := ladder_obeys (G := G) (beforeAfterRow_obeys G) theorem beforeAfterLadder_obeys_succ : ∀ n, (beforeAfterLadder G (n + 1)).ObeysSeparateFuse := ladder_obeys_of_errorFree (G := G) (rowOf_errorFree G (.layer .directedTime)) theorem beforeAfterLadder_no_level_final : ∀ n, ¬ (beforeAfterLadder G n).Freeze := by intro n cases n with | zero => exact beforeAfterRow_not_freeze G | succ n => exact Grid.not_freeze_of_obeysSeparateFuse (beforeAfterLadder_obeys_succ G n) theorem intraWeldArrowLadder_obeys [∀ w : G.Weld, Decidable (AtBot (G.share w))] : ∀ n, (intraWeldArrowLadder G n).ObeysSeparateFuse := ladder_obeys (G := G) (intraWeldArrowRow_obeys G) theorem intraWeldArrowLadder_obeys_succ : ∀ n, (intraWeldArrowLadder G (n + 1)).ObeysSeparateFuse := ladder_obeys_of_errorFree (G := G) (rowOf_errorFree G (.layer .intraWeldArrow)) theorem intraWeldArrowLadder_no_level_final : ∀ n, ¬ (intraWeldArrowLadder G n).Freeze := by intro n cases n with | zero => exact intraWeldArrowRow_not_freeze G | succ n => exact Grid.not_freeze_of_obeysSeparateFuse (intraWeldArrowLadder_obeys_succ G n) theorem gridLensLadder_obeys [∀ w : G.Weld, Decidable (AtBot (G.share w))] : ∀ n, (gridLensLadder G n).ObeysSeparateFuse := ladder_obeys (G := G) (gridLensRow_obeys G) theorem gridLensLadder_obeys_succ : ∀ n, (gridLensLadder G (n + 1)).ObeysSeparateFuse := ladder_obeys_of_errorFree (G := G) (rowOf_errorFree G (.layer .gridLens)) theorem gridLensLadder_no_level_final : ∀ n, ¬ (gridLensLadder G n).Freeze := by intro n cases n with | zero => exact gridLensRow_not_freeze G | succ n => exact Grid.not_freeze_of_obeysSeparateFuse (gridLensLadder_obeys_succ G n) theorem weldLadder_obeys [∀ w : G.Weld, Decidable (AtBot (G.share w))] : ∀ n, (weldLadder G n).ObeysSeparateFuse := ladder_obeys (G := G) (weldRow_obeys G) theorem weldLadder_obeys_succ : ∀ n, (weldLadder G (n + 1)).ObeysSeparateFuse := ladder_obeys_of_errorFree (G := G) (rowOf_errorFree G (.layer .weldGrain)) theorem weldLadder_no_level_final : ∀ n, ¬ (weldLadder G n).Freeze := by intro n cases n with | zero => exact weldRow_not_freeze G | succ n => exact Grid.not_freeze_of_obeysSeparateFuse (weldLadder_obeys_succ G n) theorem doerDeedLadder_obeys [∀ w : G.Weld, Decidable (AtBot (G.share w))] : ∀ n, (doerDeedLadder G n).ObeysSeparateFuse := ladder_obeys (G := G) (doerDeedRow_obeys G) theorem doerDeedLadder_obeys_succ : ∀ n, (doerDeedLadder G (n + 1)).ObeysSeparateFuse := ladder_obeys_of_errorFree (G := G) (rowOf_errorFree G .doerDeed) theorem doerDeedLadder_no_level_final : ∀ n, ¬ (doerDeedLadder G n).Freeze := by intro n cases n with | zero => exact doerDeedRow_not_freeze G | succ n => exact Grid.not_freeze_of_obeysSeparateFuse (doerDeedLadder_obeys_succ G n) end GridConvention end BeingConvention end DirectedConvention end Grid end WAA ===== FILE: WeldAndArrow/Consequences/Taxonomy.lean ===== /- ================================================================================ WeldAndArrow.Consequences.Taxonomy Error taxonomy, table order, and witnesses ================================================================================ Reading and motivation: Identification/Commentary.lean, C.2. -/ import WeldAndArrow.Consequences.Basic namespace WAA namespace Grid variable {Contrib : Type} [PreorderBot Contrib] variable (G : Grid Contrib) namespace DirectedConvention namespace BeingConvention namespace GridConvention /- The lens's own vocabulary: the innermost convention. The abstract `ClaimLanguage` machinery remains at `Grid` level; this namespace supplies the concrete rows generated from it. -/ /-- The nested conventions as objects the lens can diagnose claims about. -/ inductive ConventionLayer | directedTime | intraWeldArrow | beings | gridLens | weldGrain /-- Claims for convention-layer rows. `conventionLive l` says the layer's distinction is in force; `layerDenied l` is the deflation. -/ inductive LayerClaim | conventionLive (l : ConventionLayer) | layerDenied (l : ConventionLayer) /-- Every schema-generated row of the Grade-1 table, as inspectable data. The three convention layers embed via `layer`; the level-n row is generated by `ladder` instead. -/ inductive RowTag | layer (l : ConventionLayer) | foxWeld | rungPole | doerDeed | functionShare | karmaInga | sowingReaping | deliveryIndex | weldEventType | standingDated | subjectObjectAxis | undefinedZero | perCallGlobal | terminusExit | selfPoleTransposed /-- The two sides of a schema-generated row. `inForce r` is the conventional side; `denied r` is the floor-side deflation offered as diagnosis. -/ inductive RowClaim | inForce (r : RowTag) | denied (r : RowTag) /-- Pole-affirming semantics. The conventional side is true at every act-time; the denial side is true at act-time exactly at the pole-class. Thus a pole-class act-time validates both sides by truth, not vacuity. -/ def rowLanguage (G : Grid Contrib) : ClaimLanguage G where Claim := RowClaim Holds | .floor, _ => True | .actTime _, .inForce _ => True | .actTime w, .denied _ => AtBot (G.share w) def rowOf (G : Grid Contrib) (r : RowTag) : Distinction G := { language := rowLanguage G sideA := .inForce r sideB := .denied r } theorem rowOf_separated_at_live (r : RowTag) (t : Tier G) (ht : Tier.hasLiveShare G t) : (rowOf G r).Separated t := by constructor · exact ht · cases t with | floor => cases ht | actTime w => dsimp [rowOf, rowLanguage, ClaimLanguage.TrueAt] intro hiff exact ht (hiff.mp True.intro) theorem rowOf_collapse_self_refuting (r : RowTag) (t : Tier G) : ¬ (rowOf G r).Collapse t := by intro hcollapse exact (rowOf_separated_at_live G r t hcollapse.left).right hcollapse.right theorem rowOf_not_freeze (r : RowTag) : ¬ (rowOf G r).Freeze := by intro hfreeze apply hfreeze dsimp [rowOf, rowLanguage, ClaimLanguage.TrueAt] constructor <;> intro _ <;> exact True.intro /-- The denial side can be true only where the offered tier is not live. -/ theorem denied_holds_only_where_no_live_share (r : RowTag) (t : Tier G) (h : (rowLanguage G).Holds t (.denied r)) : ¬ Tier.hasLiveShare G t := by cases t with | floor => intro hfloor exact hfloor | actTime _ => intro hLive exact hLive h theorem rowOf_errorFree (r : RowTag) : ErrorFree G (rowOf G r) := ⟨rowOf_collapse_self_refuting G r, rowOf_not_freeze G r⟩ theorem rowOf_obeys [∀ w : G.Weld, Decidable (AtBot (G.share w))] (r : RowTag) : (rowOf G r).ObeysSeparateFuse := by constructor · intro t hLive exact (rowOf_separated_at_live G r t hLive).right · intro t hNotLive cases t with | floor => dsimp [rowOf, rowLanguage, ClaimLanguage.TrueAt] constructor <;> intro _ <;> exact True.intro | actTime w => dsimp [rowOf, rowLanguage, ClaimLanguage.TrueAt] have hbot : AtBot (G.share w) := by by_cases h : AtBot (G.share w) · exact h · exact False.elim (hNotLive h) constructor · intro _h exact hbot · intro _h exact True.intro /-- For the pole-affirming row language, the refutation-only reading and full separate/fuse obedience coincide under the local decidability needed to turn `¬¬ AtBot` into `AtBot` at non-live act-times. This is not a generic theorem about arbitrary distinctions; the satori clause is the load-bearing premise. -/ theorem rowOf_obeys_iff_errorFree [∀ w : G.Weld, Decidable (AtBot (G.share w))] (r : RowTag) : (rowOf G r).ObeysSeparateFuse ↔ ErrorFree G (rowOf G r) := ⟨Grid.errorFree_of_obeys G, fun _h => rowOf_obeys G r⟩ /-- At a pole-class act-time every schema-row claim is true there. This is truth at that weld and tier, not the pole as a truth-maker elsewhere. -/ theorem pole_validates_all_claims {w : G.Weld} (h : AtBot (G.share w)) : ∀ p, (rowLanguage G).Holds (Tier.actTime w) p := by intro p cases p with | inForce _ => exact True.intro | denied _ => exact h /-- A live act-time refutes the denial side and the bare equivalence of the two sides. The conventional `inForce` side still stands. -/ theorem live_tier_refutes_denials_and_fusions (r : RowTag) (t : Tier G) (hLive : Tier.hasLiveShare G t) : (¬ (rowLanguage G).Holds t (.denied r)) ∧ ¬ ((rowLanguage G).Holds t (.inForce r) ↔ (rowLanguage G).Holds t (.denied r)) := by constructor · intro hdenied exact denied_holds_only_where_no_live_share G r t hdenied hLive · exact (rowOf_separated_at_live G r t hLive).right /-- A denial offered at a live tier does not fit that offered tier. -/ theorem denied_misfits_live_offer (r : RowTag) (u : RecordedUtterance G (rowLanguage G)) (hcontent : u.content = .denied r) (hlive : Tier.hasLiveShare G u.offeredAt) : ¬ RecordedUtterance.FitsOfferedTier u := by intro hfit change (rowLanguage G).TrueAt u.offeredAt u.content at hfit cases hoff : u.offeredAt with | floor => rw [hoff] at hlive cases hlive | actTime w => rw [hoff, hcontent] at hfit dsimp [rowLanguage, ClaimLanguage.TrueAt] at hfit rw [hoff] at hlive exact hlive hfit abbrev layerRow (G : Grid Contrib) (l : ConventionLayer) : Distinction G := rowOf G (.layer l) abbrev beforeAfterRow (G : Grid Contrib) : Distinction G := rowOf G (.layer .directedTime) abbrev beingsRow (G : Grid Contrib) : Distinction G := rowOf G (.layer .beings) abbrev gridLensRow (G : Grid Contrib) : Distinction G := rowOf G (.layer .gridLens) abbrev weldRow (G : Grid Contrib) : Distinction G := rowOf G (.layer .weldGrain) abbrev intraWeldArrowRow (G : Grid Contrib) : Distinction G := rowOf G (.layer .intraWeldArrow) theorem layerRow_obeys [∀ w : G.Weld, Decidable (AtBot (G.share w))] (l : ConventionLayer) : (layerRow G l).ObeysSeparateFuse := rowOf_obeys G (.layer l) theorem beforeAfterRow_obeys [∀ w : G.Weld, Decidable (AtBot (G.share w))] : (beforeAfterRow G).ObeysSeparateFuse := rowOf_obeys G (.layer .directedTime) theorem beingsRow_obeys [∀ w : G.Weld, Decidable (AtBot (G.share w))] : (beingsRow G).ObeysSeparateFuse := rowOf_obeys G (.layer .beings) theorem gridLensRow_obeys [∀ w : G.Weld, Decidable (AtBot (G.share w))] : (gridLensRow G).ObeysSeparateFuse := rowOf_obeys G (.layer .gridLens) theorem weldRow_obeys [∀ w : G.Weld, Decidable (AtBot (G.share w))] : (weldRow G).ObeysSeparateFuse := rowOf_obeys G (.layer .weldGrain) theorem intraWeldArrowRow_obeys [∀ w : G.Weld, Decidable (AtBot (G.share w))] : (intraWeldArrowRow G).ObeysSeparateFuse := rowOf_obeys G (.layer .intraWeldArrow) /-- Compatibility name for the migrated layer denials. -/ theorem layerDenied_holds_only_where_no_live_share (l : ConventionLayer) (t : Tier G) (h : (rowLanguage G).Holds t (.denied (.layer l))) : ¬ Tier.hasLiveShare G t := denied_holds_only_where_no_live_share G (.layer l) t h theorem beforeAfterRow_not_freeze : ¬ (beforeAfterRow G).Freeze := rowOf_not_freeze G (.layer .directedTime) /-- The before/after collapse is self-refuting at every tier; in particular, it cannot be asserted as a live diagnosis. -/ theorem no_time_collapse_self_refuting (t : Tier G) : ¬ (beforeAfterRow G).Collapse t := rowOf_collapse_self_refuting G (.layer .directedTime) t /-- The beings row cannot freeze. The freeze cell in the prose table names the position this checked row rules out asserting: designation reified into ontology against `BeingNegative`. -/ theorem beingsRow_not_freeze : ¬ (beingsRow G).Freeze := rowOf_not_freeze G (.layer .beings) /-- "There are no beings", offered as a live diagnosis, is refuted by its own tier. -/ theorem no_beings_collapse_self_refuting (t : Tier G) : ¬ (beingsRow G).Collapse t := rowOf_collapse_self_refuting G (.layer .beings) t theorem gridLensRow_not_freeze : ¬ (gridLensRow G).Freeze := rowOf_not_freeze G (.layer .gridLens) theorem lens_denial_collapse_self_refuting (t : Tier G) : ¬ (gridLensRow G).Collapse t := rowOf_collapse_self_refuting G (.layer .gridLens) t theorem weldRow_not_freeze : ¬ (weldRow G).Freeze := rowOf_not_freeze G (.layer .weldGrain) theorem weldRow_errorFree : ErrorFree G (weldRow G) := rowOf_errorFree G (.layer .weldGrain) /-- "No acts happen", offered as a live diagnosis, is refuted by its own tier. -/ theorem weld_denial_collapse_self_refuting (t : Tier G) : ¬ (weldRow G).Collapse t := rowOf_collapse_self_refuting G (.layer .weldGrain) t theorem intraWeldArrowRow_not_freeze : ¬ (intraWeldArrowRow G).Freeze := rowOf_not_freeze G (.layer .intraWeldArrow) /-- "No call/response order, so no acts", offered live, is refuted by its own act-time tier. -/ theorem no_order_collapse_self_refuting (t : Tier G) : ¬ (intraWeldArrowRow G).Collapse t := rowOf_collapse_self_refuting G (.layer .intraWeldArrow) t abbrev rungPoleRow (G : Grid Contrib) : Distinction G := rowOf G .rungPole theorem rungPoleRow_obeys [∀ w : G.Weld, Decidable (AtBot (G.share w))] : (rungPoleRow G).ObeysSeparateFuse := rowOf_obeys G .rungPole theorem rungPoleRow_not_freeze : ¬ (rungPoleRow G).Freeze := rowOf_not_freeze G .rungPole /-- Kensho read as genjo collapses a rung into the pole. -/ theorem kensho_as_genjo_collapse_self_refuting (t : Tier G) : ¬ (rungPoleRow G).Collapse t := rowOf_collapse_self_refuting G .rungPole t abbrev foxWeldRow (G : Grid Contrib) : Distinction G := rowOf G .foxWeld theorem foxWeldRow_obeys [∀ w : G.Weld, Decidable (AtBot (G.share w))] : (foxWeldRow G).ObeysSeparateFuse := rowOf_obeys G .foxWeld theorem foxWeldRow_not_freeze : ¬ (foxWeldRow G).Freeze := rowOf_not_freeze G .foxWeld /-- The fox's "not-fall" side, offered as live diagnosis, is self-refuting. -/ theorem fox_notFall_collapse_self_refuting (t : Tier G) : ¬ (foxWeldRow G).Collapse t := rowOf_collapse_self_refuting G .foxWeld t /-- "Not-fall", offered where diagnosis is live, does not fit its offered tier: Case 2 checked against the schema row itself. -/ theorem fox_utterance_misfits_live_offer (u : RecordedUtterance G (rowLanguage G)) (hcontent : u.content = .denied .foxWeld) (hlive : Tier.hasLiveShare G u.offeredAt) : ¬ RecordedUtterance.FitsOfferedTier u := denied_misfits_live_offer G .foxWeld u hcontent hlive abbrev doerDeedRow (G : Grid Contrib) : Distinction G := rowOf G .doerDeed theorem doerDeedRow_obeys [∀ w : G.Weld, Decidable (AtBot (G.share w))] : (doerDeedRow G).ObeysSeparateFuse := rowOf_obeys G .doerDeed theorem doerDeedRow_not_freeze : ¬ (doerDeedRow G).Freeze := rowOf_not_freeze G .doerDeed /-- "No doer, only deeds", offered as live diagnosis, is mounted by the very act-time being answering a call. -/ theorem no_prior_doer_collapse_self_refuting (t : Tier G) : ¬ (doerDeedRow G).Collapse t := rowOf_collapse_self_refuting G .doerDeed t abbrev functionShareRow (G : Grid Contrib) : Distinction G := rowOf G .functionShare theorem functionShareRow_obeys [∀ w : G.Weld, Decidable (AtBot (G.share w))] : (functionShareRow G).ObeysSeparateFuse := rowOf_obeys G .functionShare theorem functionShareRow_not_freeze : ¬ (functionShareRow G).Freeze := rowOf_not_freeze G .functionShare theorem functionZero_from_shareZero_collapse_self_refuting (t : Tier G) : ¬ (functionShareRow G).Collapse t := rowOf_collapse_self_refuting G .functionShare t abbrev karmaIngaRow (G : Grid Contrib) : Distinction G := rowOf G .karmaInga theorem karmaIngaRow_obeys [∀ w : G.Weld, Decidable (AtBot (G.share w))] : (karmaIngaRow G).ObeysSeparateFuse := rowOf_obeys G .karmaInga theorem karmaIngaRow_not_freeze : ¬ (karmaIngaRow G).Freeze := rowOf_not_freeze G .karmaInga theorem misfeed_collapse_self_refuting (t : Tier G) : ¬ (karmaIngaRow G).Collapse t := rowOf_collapse_self_refuting G .karmaInga t abbrev sowingReapingRow (G : Grid Contrib) : Distinction G := rowOf G .sowingReaping theorem sowingReapingRow_obeys [∀ w : G.Weld, Decidable (AtBot (G.share w))] : (sowingReapingRow G).ObeysSeparateFuse := rowOf_obeys G .sowingReaping theorem sowingReapingRow_not_freeze : ¬ (sowingReapingRow G).Freeze := rowOf_not_freeze G .sowingReaping theorem series_ownership_collapse_self_refuting (t : Tier G) : ¬ (sowingReapingRow G).Collapse t := rowOf_collapse_self_refuting G .sowingReaping t abbrev deliveryIndexRow (G : Grid Contrib) : Distinction G := rowOf G .deliveryIndex theorem deliveryIndexRow_obeys [∀ w : G.Weld, Decidable (AtBot (G.share w))] : (deliveryIndexRow G).ObeysSeparateFuse := rowOf_obeys G .deliveryIndex theorem deliveryIndexRow_not_freeze : ¬ (deliveryIndexRow G).Freeze := rowOf_not_freeze G .deliveryIndex theorem misfed_register_collapse_self_refuting (t : Tier G) : ¬ (deliveryIndexRow G).Collapse t := rowOf_collapse_self_refuting G .deliveryIndex t abbrev weldEventTypeRow (G : Grid Contrib) : Distinction G := rowOf G .weldEventType theorem weldEventTypeRow_obeys [∀ w : G.Weld, Decidable (AtBot (G.share w))] : (weldEventTypeRow G).ObeysSeparateFuse := rowOf_obeys G .weldEventType theorem weldEventTypeRow_not_freeze : ¬ (weldEventTypeRow G).Freeze := rowOf_not_freeze G .weldEventType theorem eventType_grading_collapse_self_refuting (t : Tier G) : ¬ (weldEventTypeRow G).Collapse t := rowOf_collapse_self_refuting G .weldEventType t abbrev standingDatedRow (G : Grid Contrib) : Distinction G := rowOf G .standingDated theorem standingDatedRow_obeys [∀ w : G.Weld, Decidable (AtBot (G.share w))] : (standingDatedRow G).ObeysSeparateFuse := rowOf_obeys G .standingDated theorem standingDatedRow_not_freeze : ¬ (standingDatedRow G).Freeze := rowOf_not_freeze G .standingDated theorem prognosis_as_diagnosis_collapse_self_refuting (t : Tier G) : ¬ (standingDatedRow G).Collapse t := rowOf_collapse_self_refuting G .standingDated t abbrev subjectObjectAxisRow (G : Grid Contrib) : Distinction G := rowOf G .subjectObjectAxis theorem subjectObjectAxisRow_obeys [∀ w : G.Weld, Decidable (AtBot (G.share w))] : (subjectObjectAxisRow G).ObeysSeparateFuse := rowOf_obeys G .subjectObjectAxis theorem subjectObjectAxisRow_not_freeze : ¬ (subjectObjectAxisRow G).Freeze := rowOf_not_freeze G .subjectObjectAxis theorem insentient_subject_collapse_self_refuting (t : Tier G) : ¬ (subjectObjectAxisRow G).Collapse t := rowOf_collapse_self_refuting G .subjectObjectAxis t abbrev undefinedZeroRow (G : Grid Contrib) : Distinction G := rowOf G .undefinedZero theorem undefinedZeroRow_obeys [∀ w : G.Weld, Decidable (AtBot (G.share w))] : (undefinedZeroRow G).ObeysSeparateFuse := rowOf_obeys G .undefinedZero theorem undefinedZeroRow_not_freeze : ¬ (undefinedZeroRow G).Freeze := rowOf_not_freeze G .undefinedZero theorem undefined_as_openness_collapse_self_refuting (t : Tier G) : ¬ (undefinedZeroRow G).Collapse t := rowOf_collapse_self_refuting G .undefinedZero t abbrev perCallGlobalRow (G : Grid Contrib) : Distinction G := rowOf G .perCallGlobal theorem perCallGlobalRow_obeys [∀ w : G.Weld, Decidable (AtBot (G.share w))] : (perCallGlobalRow G).ObeysSeparateFuse := rowOf_obeys G .perCallGlobal theorem perCallGlobalRow_not_freeze : ¬ (perCallGlobalRow G).Freeze := rowOf_not_freeze G .perCallGlobal theorem perCallGlobal_collapse_self_refuting (t : Tier G) : ¬ (perCallGlobalRow G).Collapse t := rowOf_collapse_self_refuting G .perCallGlobal t abbrev terminusExitRow (G : Grid Contrib) : Distinction G := rowOf G .terminusExit theorem terminusExitRow_obeys [∀ w : G.Weld, Decidable (AtBot (G.share w))] : (terminusExitRow G).ObeysSeparateFuse := rowOf_obeys G .terminusExit theorem terminusExitRow_not_freeze : ¬ (terminusExitRow G).Freeze := rowOf_not_freeze G .terminusExit theorem exit_collapse_self_refuting (t : Tier G) : ¬ (terminusExitRow G).Collapse t := rowOf_collapse_self_refuting G .terminusExit t abbrev selfPoleTransposedRow (G : Grid Contrib) : Distinction G := rowOf G .selfPoleTransposed theorem selfPoleTransposedRow_obeys [∀ w : G.Weld, Decidable (AtBot (G.share w))] : (selfPoleTransposedRow G).ObeysSeparateFuse := rowOf_obeys G .selfPoleTransposed theorem selfPoleTransposedRow_not_freeze : ¬ (selfPoleTransposedRow G).Freeze := rowOf_not_freeze G .selfPoleTransposed theorem transposition_erased_downward_collapse_self_refuting (t : Tier G) : ¬ (selfPoleTransposedRow G).Collapse t := rowOf_collapse_self_refuting G .selfPoleTransposed t /-- Rows of the Grade-1 table that remain prose; their reasons are recorded in Identification/Commentary.lean and the paper commentary. -/ inductive ProseRow | beingNonBeing | ladderTerminus | genjoSho | shoSatori | row2Row3 | descriptionInjunction /-- A table row is schema-generated, ladder-generated, or prose. -/ inductive TableRow | generated (r : RowTag) | ladderSchema | prose (p : ProseRow) def tableOrder : List TableRow := [ .prose .beingNonBeing, .ladderSchema, .prose .ladderTerminus, .generated .rungPole, .prose .genjoSho, .prose .shoSatori, .generated .foxWeld, .prose .row2Row3, .generated .doerDeed, .generated .functionShare, .generated .karmaInga, .generated .sowingReaping, .generated .deliveryIndex, .generated .weldEventType, .generated .standingDated, .generated .subjectObjectAxis, .generated .undefinedZero, .generated .perCallGlobal, .prose .descriptionInjunction, .generated (.layer .gridLens), .generated .terminusExit, .generated .selfPoleTransposed, .generated (.layer .directedTime), .generated (.layer .intraWeldArrow), .generated (.layer .beings), .generated (.layer .weldGrain) ] example : tableOrder.length = 26 := rfl /-- Metadata for whether a schema-generated row has a collapse occupant in the paper's Grade-1 table. This records table prose; it is not extra grid semantics. -/ def hasCollapseOccupant : RowTag → Bool | .perCallGlobal => false | _ => true /-- Metadata for whether a schema-generated row has a freeze occupant in the paper's Grade-1 table. This records table prose; it is not extra grid semantics. -/ def hasFreezeOccupant : RowTag → Bool | _ => true /-- A generated table dash is data, while the row's refutations remain theorem facts. The per-call/global row has no collapse occupant in the table, yet collapse and freeze are still ruled out by the row checks. -/ theorem perCallGlobal_empty_collapse_cell_anchor : hasCollapseOccupant .perCallGlobal = false ∧ hasFreezeOccupant .perCallGlobal = true ∧ (∀ t, ¬ (perCallGlobalRow G).Collapse t) ∧ ¬ (perCallGlobalRow G).Freeze := ⟨rfl, rfl, fun t => perCallGlobal_collapse_self_refuting G t, perCallGlobalRow_not_freeze G⟩ end GridConvention end BeingConvention end DirectedConvention end Grid /-- In the clock model, share-zero does not mean function-zero: the adaptive clock answers the present-listener call at bottom share while remaining non-stone. -/ theorem shareZero_not_functionZero_witness : AtBot (clockGrid.share ⟨Clock.adaptive, Listener.present, Chime.chime⟩) ∧ ¬ clockGrid.Stone Clock.adaptive := ⟨clockGrid.atBot_of_terminus_response adaptive_is_terminus rfl, adaptive_not_stone⟩ /-- In the register clock, a live share-drop rung is not yet the pole. -/ theorem rung_not_pole_witness : ∃ before : Config Nat, ∃ received : registerClockGrid.Weld, registerClockGrid.Actual received ∧ registerClockGrid.IsShareDrop before received ∧ ¬ AtBot (registerClockGrid.share received) := by refine ⟨{ tendency := 5 }, ⟨(2 : Nat), (), (3 : Nat)⟩, ?_, ?_, ?_⟩ · rfl · dsimp [Grid.IsShareDrop, Grid.share, registerClockGrid] constructor · show (2 : Nat) ≤ 5 decide · show ¬ (5 : Nat) ≤ 2 decide · dsimp [Grid.share, registerClockGrid, AtBot, shareBot] show ¬ (2 : Nat) ≤ 0 decide /-- Kensho cannot be held: a share-drop reception to the pole-class can be followed, in the same grid and by the same being, by a later actual weld with live share. There is no stored attainment for the next reception to inherit. -/ theorem backsliding_witness : ∃ (before : Config Nat) (kensho later : backslideGrid.Weld), backslideGrid.Actual kensho ∧ backslideGrid.IsShareDrop before kensho ∧ AtBot (backslideGrid.share kensho) ∧ later.agent = kensho.agent ∧ backslideGrid.Actual later ∧ backslideGrid.HasSelfPoleIndex later := by refine ⟨{ tendency := 5 }, ⟨(), Cue.gentle, ()⟩, ⟨(), Cue.harsh, ()⟩, ?_, ?_, ?_, ?_, ?_, ?_⟩ · rfl · dsimp [Grid.IsShareDrop, Grid.share, backslideGrid] constructor · show (0 : Nat) ≤ 5 decide · show ¬ (5 : Nat) ≤ 0 decide · dsimp [Grid.share, backslideGrid, AtBot, shareBot] show (0 : Nat) ≤ 0 decide · rfl · rfl · dsimp [Grid.HasSelfPoleIndex, Grid.share, backslideGrid, AtBot, shareBot] show ¬ (5 : Nat) ≤ 0 decide /-- The same backsliding witness routed through `ReceptionPair`: after the kensho reception the sequence is at the pole-class, and after the next reception it is live again. -/ theorem backsliding_rePitchSequence_witness : ∃ (before : Config Nat) (p : Grid.ReceptionPair backslideGrid), Grid.ReceptionPair.FirstConditionsSecond (G := backslideGrid) p ∧ p.second.weld.agent = p.first.weld.agent ∧ AtBot ((Grid.ReceptionPair.rePitchSequence (G := backslideGrid) before p).fst.tendency) ∧ ¬ AtBot ((Grid.ReceptionPair.rePitchSequence (G := backslideGrid) before p).snd.tendency) := by refine ⟨{ tendency := 5 }, { first := { weld := ⟨(), Cue.gentle, ()⟩, actual := rfl }, second := { weld := ⟨(), Cue.harsh, ()⟩, actual := rfl } }, ?_, ?_, ?_, ?_⟩ · exact True.intro · rfl · dsimp [Grid.ReceptionPair.rePitchSequence, Grid.rePitch, Grid.share, backslideGrid, AtBot, shareBot] show (0 : Nat) ≤ 0 decide · dsimp [Grid.ReceptionPair.rePitchSequence, Grid.rePitch, Grid.share, backslideGrid, AtBot, shareBot] show ¬ (5 : Nat) ≤ 0 decide /-- Cetanā witness A: two actual welds share the same field residue, while their shares differ. Grading tracks the completed weld rather than a common call-response event residue. -/ theorem cetana_grading_tracks_weld_not_field_witness : gradingCollisionGrid.Actual gradingCollisionLeft ∧ gradingCollisionGrid.Actual gradingCollisionRight ∧ gradingCollisionGrid.fieldOf gradingCollisionLeft = gradingCollisionGrid.fieldOf gradingCollisionRight ∧ gradingCollisionGrid.share gradingCollisionLeft ≠ gradingCollisionGrid.share gradingCollisionRight := by refine ⟨rfl, rfl, rfl, ?_⟩ dsimp [Grid.share, gradingCollisionGrid, gradingCollisionLeft, gradingCollisionRight] decide /-- Cetanā witness B: a live-share weld remains live even when every delivery relation is removed, so grading can peak where object-axis standing fails. -/ theorem cetana_live_share_without_object_standing_witness : ∃ w : (registerClockGrid.withConditions (fun _ _ => False)).Weld, (registerClockGrid.withConditions (fun _ _ => False)).Actual w ∧ (registerClockGrid.withConditions (fun _ _ => False)).HasSelfPoleIndex w ∧ ¬ Grid.DirectedConvention.ObjectAxisStanding (registerClockGrid.withConditions (fun _ _ => False)) w := by refine ⟨⟨(5 : Nat), (), (6 : Nat)⟩, ?_, ?_, ?_⟩ · rfl · dsimp [Grid.HasSelfPoleIndex, Grid.share, registerClockGrid, Grid.withConditions, AtBot, shareBot] show ¬ (5 : Nat) ≤ 0 decide · intro hstanding rcases hstanding with ⟨reception, hdelivered⟩ exact hdelivered local instance registerClockGridDecidableEqBeing : DecidableEq registerClockGrid.Being := inferInstanceAs (DecidableEq Nat) /-- Staticizing one register in the register clock really destroys that register's response function. -/ theorem registerClock_staticized_zero_stone : (registerClockGrid.staticized (0 : Nat)).Stone (0 : Nat) := registerClockGrid.futility_delivery_loss_real (0 : Nat) /-- Staticizing one register in the register clock leaves object-axis standing exactly as it was, because delivery data are untouched. -/ theorem registerClock_staticized_objectAxisStanding_iff (deed : registerClockGrid.Weld) : Grid.DirectedConvention.ObjectAxisStanding (registerClockGrid.staticized (0 : Nat)) deed ↔ Grid.DirectedConvention.ObjectAxisStanding registerClockGrid deed := Grid.DirectedConvention.staticized_objectAxisStanding_iff registerClockGrid (0 : Nat) deed /-- Assertable and displayable are different verdict voices. -/ theorem assertable_ne_displayable : Grid.VerdictVoice.assertable ≠ Grid.VerdictVoice.displayable := by intro h cases h /-- A standing tendency does not determine the dated reception: in the clock model a live prior tendency can re-pitch to a pole-class received share. -/ theorem standing_does_not_determine_dated : ∃ before : Config Nat, ∃ received : clockGrid.Weld, ¬ AtBot before.tendency ∧ AtBot (clockGrid.rePitch before received).tendency := by refine ⟨{ tendency := 5 }, ⟨Clock.adaptive, Listener.present, Chime.chime⟩, ?_, ?_⟩ · dsimp [AtBot, shareBot] show ¬ (5 : Nat) ≤ 0 decide · exact clockGrid.rePitch_tendency_atBot_of_terminus_response { tendency := 5 } adaptive_is_terminus rfl /-- Subitism as possibility: a single received weld moves the carried tendency from strictly above bottom to the pole-class. Magnitude is unconstrained by construction; frequency is asserted nowhere. -/ theorem subitism_possibility_witness : ∃ (before : Config Nat) (received : clockGrid.Weld), ¬ AtBot before.tendency ∧ clockGrid.IsShareDrop before received ∧ AtBot (clockGrid.rePitch before received).tendency := by refine ⟨{ tendency := 5 }, ⟨Clock.adaptive, Listener.present, Chime.chime⟩, ?_, ?_, ?_⟩ · dsimp [AtBot, shareBot] show ¬ (5 : Nat) ≤ 0 decide · dsimp [Grid.IsShareDrop, Grid.share, clockGrid] constructor · show (0 : Nat) ≤ 5 decide · show ¬ (5 : Nat) ≤ 0 decide · exact clockGrid.rePitch_tendency_atBot_of_terminus_response { tendency := 5 } adaptive_is_terminus rfl /-- The pole-validating act-time is inhabited by a non-stone terminus response in the clock model; the validating disjunct is not merely the vacuous stone side. -/ theorem pole_tier_buddha_inhabited : ∃ w : clockGrid.Weld, clockGrid.Actual w ∧ AtBot (clockGrid.share w) ∧ clockGrid.AtPoleClass w.agent ∧ ¬ clockGrid.Stone w.agent := by refine ⟨⟨Clock.adaptive, Listener.present, Chime.chime⟩, rfl, ?_, ?_, ?_⟩ · exact clockGrid.atBot_of_terminus_response adaptive_is_terminus rfl · exact clockGrid.atPoleClass_of_terminus Clock.adaptive adaptive_is_terminus · exact adaptive_not_stone end WAA ===== FILE: WeldAndArrow/Doctrines.lean ===== import WeldAndArrow.Doctrines.FourTruths import WeldAndArrow.Doctrines.FoxCase import WeldAndArrow.Doctrines.Sraddha import WeldAndArrow.Doctrines.Icchantika import WeldAndArrow.Doctrines.SraddhaNegative import WeldAndArrow.Doctrines.Faith import WeldAndArrow.Doctrines.FaithNegative import WeldAndArrow.Doctrines.Ethics import WeldAndArrow.Doctrines.EthicsNegative import WeldAndArrow.Doctrines.Deliberation import WeldAndArrow.Doctrines.Ledger import WeldAndArrow.Doctrines.Correlations import WeldAndArrow.Doctrines.CorrelationsNegative import WeldAndArrow.Doctrines.SuddenGradual import WeldAndArrow.Doctrines.SuddenGradualNegative import WeldAndArrow.Doctrines.OtherPower import WeldAndArrow.Doctrines.OtherPowerNegative import WeldAndArrow.Doctrines.Fetters import WeldAndArrow.Doctrines.FettersNegative import WeldAndArrow.Doctrines.Factors import WeldAndArrow.Doctrines.FactorsNegative import WeldAndArrow.Doctrines.Gradeability ===== FILE: WeldAndArrow/Doctrines/Correlations.lean ===== /- ================================================================================ WeldAndArrow.Doctrines.Correlations Ten Bulls, Five Ranks, and stage-schemes as checked correlations ================================================================================ The doctrine vocabulary here is deliberately thin: named readings over existing grid machinery, with the correlations stated as corollaries rather than new axioms. -/ import WeldAndArrow.Doctrines.Deliberation namespace WAA namespace Grid open DirectedConvention open DirectedConvention.BeingConvention variable {Contrib : Type} [PreorderBot Contrib] variable (G : Grid Contrib) /- ============================================================================== Stage-schemes as coarsenings ============================================================================== -/ /-- A stage-scheme is a diagnosis-time coarsening of fine being tags. -/ abbrev StageScheme (Stage : Type) : Type := BeingCoarsening G Stage /-- The fifty-two-stage scheme, with no extra signature field. -/ abbrev FiftyTwoStageScheme : Type := G.StageScheme (Fin 52) /-- The boundary relation read from a supplied coarsening. -/ abbrev CoarseningBoundary {Macro : Type} (κ : BeingCoarsening G Macro) : G.Being → G.Being → Prop := κ.SameFiber /- ============================================================================== Ten Bulls ============================================================================== -/ -- TODO(prose): verify Kuòān verse locus. /-- The ten pictures, as data. The interpretation lives in the predicates below and the commentary. -/ inductive BullStage | seeking | footprints | glimpse | catching | taming | ridingHome | bullForgotten | bothForgotten | returningSource | marketplace namespace BullStage /-- Bulls 1-6 are the share-drop ascent portion of the sequence. -/ def ascentIndex : BullStage → Option Nat | .seeking => some 0 | .footprints => some 1 | .glimpse => some 2 | .catching => some 3 | .taming => some 4 | .ridingHome => some 5 | .bullForgotten | .bothForgotten | .returningSource | .marketplace => none theorem seeking_ascentIndex : ascentIndex seeking = some 0 := rfl theorem footprints_ascentIndex : ascentIndex footprints = some 1 := rfl theorem glimpse_ascentIndex : ascentIndex glimpse = some 2 := rfl theorem catching_ascentIndex : ascentIndex catching = some 3 := rfl theorem taming_ascentIndex : ascentIndex taming = some 4 := rfl theorem ridingHome_ascentIndex : ascentIndex ridingHome = some 5 := rfl end BullStage /-- A finite run in which every received weld is actual and drops the current carried share, after which the configuration is re-pitched to that weld. -/ inductive ShareDropRun : Config Contrib → List G.Weld → Prop | nil (before : Config Contrib) : ShareDropRun before [] | cons {before : Config Contrib} {received : G.Weld} {rest : List G.Weld} : G.Actual received → G.IsShareDrop before received → ShareDropRun (G.rePitch before received) rest → ShareDropRun before (received :: rest) /-- Bulls 1-6 as a run-fact: the climb is per-call and stores no altitude. -/ structure BullAscent where before : Config Contrib run : List G.Weld drops : ShareDropRun G before run /-- Bull 7: probe-constancy with a live self-pole index still present. -/ def WaaBullSeven (b : G.Being) : Prop := G.ProbeConstant b (fun _ => True) ∧ ∃ w : G.Weld, G.Actual w ∧ w.agent = b ∧ G.HasSelfPoleIndex w /-- Bull 8: the empty circle as the pole-class, covering stone and terminus arrivals without collapsing them. -/ abbrev WaaBullEight (b : G.Being) : Prop := G.AtPoleClass b /-- Bull 9: return to source as call-entire terminus response. -/ abbrev WaaBullNine (b : G.Being) : Prop := G.ResponsiveTerminus b /-- Bull 10: marketplace functioning through at least one delivery line into another sentient fiber. The existential reading is the modest picture-level claim; stronger universal delivery is a separate asymptote. -/ def WaaBullTen {Macro : Type} (κ : BeingCoarsening G Macro) (b : G.Being) : Prop := G.ResponsiveTerminus b ∧ ∃ deed reception : G.Weld, κ.InFiber (κ.proj b) deed ∧ G.Actual reception ∧ ¬ κ.SameFiber deed.agent reception.agent ∧ κ.SentientTag (κ.proj reception.agent) ∧ DeliveredTo G deed reception /-- The shelved stronger bodhisattva reading: delivery reaches every other sentient fiber. The source picture does not require this strength. -/ def StrongWaaBullTen {Macro : Type} (κ : BeingCoarsening G Macro) (b : G.Being) : Prop := G.ResponsiveTerminus b ∧ ∀ m : Macro, κ.SentientTag m → m ≠ κ.proj b → ∃ deed reception : G.Weld, κ.InFiber (κ.proj b) deed ∧ κ.InFiber m reception ∧ G.Actual reception ∧ DeliveredTo G deed reception theorem bullSeven_not_terminus {b : G.Being} (h : G.WaaBullSeven b) : ¬ G.Terminus b := by intro hterm rcases h.right with ⟨w, hactual, hagent, hidx⟩ rw [← hagent] at hterm exact hidx (G.atBot_of_terminus_response hterm hactual) theorem bullSeven_not_bullEight {b : G.Being} (h : G.WaaBullSeven b) : ¬ G.WaaBullEight b := by intro height rcases h.right with ⟨w, hactual, hagent, _hidx⟩ cases height with | inl hstone => have hstoneW : G.Stone w.agent := by simpa [hagent] using hstone exact G.not_actual_of_stone w.agent hstoneW hactual | inr hterm => exact G.bullSeven_not_terminus h hterm theorem bullTen_to_bullNine {Macro : Type} {κ : BeingCoarsening G Macro} {b : G.Being} (h : G.WaaBullTen κ b) : G.WaaBullNine b := h.left theorem bullNine_to_terminus {b : G.Being} (h : G.WaaBullNine b) : G.Terminus b := h.right theorem terminus_to_bullEight {b : G.Being} (h : G.Terminus b) : G.WaaBullEight b := Or.inr h theorem bullNine_to_bullEight {b : G.Being} (h : G.WaaBullNine b) : G.WaaBullEight b := G.terminus_to_bullEight h.right theorem bullTen_to_bullEight {Macro : Type} {κ : BeingCoarsening G Macro} {b : G.Being} (h : G.WaaBullTen κ b) : G.WaaBullEight b := G.bullNine_to_bullEight h.left end Grid /- ============================================================================== Five Ranks ============================================================================== -/ /-- Dongshan's Five Ranks as data. -/ inductive FiveRank | shoChuHen | henChuSho | shoChuRai | henChuShi | kenChuTo /-- Thin reading labels for the ranks. -/ inductive RankReading | hostWithinGuest | guestWithinHost | comingFromHost | arrivingWithinGuest | marketplaceArrival namespace FiveRank def reading : FiveRank → RankReading | .shoChuHen => .hostWithinGuest | .henChuSho => .guestWithinHost | .shoChuRai => .comingFromHost | .henChuShi => .arrivingWithinGuest | .kenChuTo => .marketplaceArrival theorem kenChuTo_reading : reading kenChuTo = RankReading.marketplaceArrival := rfl end FiveRank namespace Grid open DirectedConvention.BeingConvention variable {Contrib : Type} [PreorderBot Contrib] variable (G : Grid Contrib) /-- A minimal object-language for rank-diagnosis utterances. It records the rank named by an utterance without adding a new semantic row. -/ inductive RankClaim | says (r : FiveRank) def rankLanguage : ClaimLanguage G where Claim := RankClaim Holds := fun _ _ => True abbrev RecordedRankUtterance : Type := RecordedUtterance G (G.rankLanguage) /-- The 到 rank's checked shape: marketplace arrival is exactly the Bull 10 delivery pattern under the supplied coarsening. -/ abbrev KenChuToShape {Macro : Type} (κ : BeingCoarsening G Macro) (b : G.Being) : Prop := G.WaaBullTen κ b theorem kenChuTo_implies_waaBullTen {Macro : Type} {κ : BeingCoarsening G Macro} {b : G.Being} (h : G.KenChuToShape κ b) : G.WaaBullTen κ b := h end Grid end WAA ===== FILE: WeldAndArrow/Doctrines/CorrelationsNegative.lean ===== /- ================================================================================ WeldAndArrow.Doctrines.CorrelationsNegative Negative witnesses for Bulls, ranks, and stage-coarsenings ================================================================================ -/ import WeldAndArrow.Doctrines.Correlations namespace WAA namespace CorrelationsNegative open Grid.DirectedConvention open Grid.DirectedConvention.BeingConvention /- ============================================================================== Bull 9 without Bull 10 ============================================================================== -/ inductive Being | solo | other deriving DecidableEq inductive Call | call inductive Response | response /-- A pole responder in a world where delivery never crosses fibers. -/ def solitaryGrid : Grid Nat where Being := Being Call := Call Response := Response respondsTo _ _ := some Response.response grade _ _ _ := 0 conditions deed reception := deed.agent = reception.agent def identityCoarsening : BeingCoarsening solitaryGrid Being where proj := id theorem solo_bullNine : solitaryGrid.WaaBullNine Being.solo := by constructor · intro _c exact ⟨Response.response, rfl⟩ · intro _c _r _hresp exact Nat.le_refl 0 theorem solo_not_bullTen : ¬ solitaryGrid.WaaBullTen identityCoarsening Being.solo := by intro h rcases h.right with ⟨deed, reception, _hdeed, _hactual, hnotSame, _hsentient, hdel⟩ exact hnotSame hdel /-- A pratyekabuddha-shaped witness: Bull 9 can hold while Bull 10 fails. -/ theorem pratyekabuddha_countermodel : solitaryGrid.WaaBullNine Being.solo ∧ ¬ solitaryGrid.WaaBullTen identityCoarsening Being.solo := ⟨solo_bullNine, solo_not_bullTen⟩ /- ============================================================================== No grid-carried recovery of a unique stage boundary ============================================================================== -/ /-- Two fine tags with identical grid data, as in the being-boundary witness. -/ def stageGrid : Grid Nat where Being := Bool Call := Unit Response := Unit respondsTo _ _ := some () grade _ _ _ := 0 conditions _ _ := True def stageMerge : stageGrid.StageScheme Unit where proj _ := () def stageSplit : stageGrid.StageScheme Bool where proj := id theorem stageMerge_same_fiber : stageMerge.SameFiber false true := rfl theorem stageSplit_not_same_fiber : ¬ stageSplit.SameFiber false true := by intro h cases h abbrev W := RawWeld Bool Unit Unit abbrev GridData : Type := (Bool → Unit → Option Unit) × (Bool → Unit → Unit → Nat) × (W → W → Prop) def gridData : GridData := (stageGrid.respondsTo, stageGrid.grade, stageGrid.conditions) def mergedBoundary (_p _q : Bool) : Prop := True def splitBoundary (p q : Bool) : Prop := p = q /-- The same grid data supports a merge and a split stage-coarsening. Holding either boundary as recovered from the grid is the uniform freeze. -/ theorem no_stage_boundary_recovery : ¬ ∃ recover : GridData → Bool → Bool → Prop, recover gridData = mergedBoundary ∧ recover gridData = splitBoundary := by rintro ⟨recover, hmerge, hsplit⟩ have hmerged : recover gridData false true := by rw [hmerge] exact True.intro have hsplitNot : ¬ recover gridData false true := by rw [hsplit] intro h cases h exact hsplitNot hmerged end CorrelationsNegative end WAA ===== FILE: WeldAndArrow/Doctrines/Deliberation.lean ===== /- ================================================================================ WeldAndArrow.Doctrines.Deliberation Consequentialist display and deliberator-side underdetermination ================================================================================ This module records the checked face of the deliberator block: drop-counting as a reading, the non-accumulation consequence of `rePitch`, the being-boundary and transfer countermodels, invariance of grade under delivery conditions, and a claim-language witness for delivery-arrogation. Reading and motivation: Identification/Commentary.lean, C.5. -/ import WeldAndArrow.Consequences.Basic namespace WAA namespace Grid variable {Contrib : Type} [PreorderBot Contrib] variable (G : Grid Contrib) /- ============================================================================== Consequentialist convention: descriptive readings only ============================================================================== -/ namespace ConsequentialistConvention open DirectedConvention.BeingConvention /-- The deliberator's finite sample: an initial configuration and a finite list of actual receptions. No measure, utility, probability, or command over delivery is added. -/ structure DeliberationSample (G : Grid Contrib) where before : Config Contrib run : List (ActualWeld G) /-- A descriptive objective candidate. Its domain is explicit so that further conventions have to be supplied as arguments rather than recovered from the grid. -/ abbrev Objective (G : Grid Contrib) (Convention Value : Type) := DeliberationSample G -> Convention -> Value /-- Count share-drop receptions through a finite actual run, re-pitching after every reception. -/ def DropCount [∀ before received, Decidable (G.IsShareDrop before received)] (before : Config Contrib) : List (ActualWeld G) -> Nat | [] => 0 | aw :: rest => let after := G.rePitch before aw.weld let tail := DropCount after rest if G.IsShareDrop before aw.weld then tail + 1 else tail theorem dropCount_eq_match [∀ before received, Decidable (G.IsShareDrop before received)] (before : Config Contrib) (run : List (ActualWeld G)) : DropCount G before run = match run with | [] => 0 | aw :: rest => let after := G.rePitch before aw.weld let tail := DropCount G after rest if G.IsShareDrop before aw.weld then tail + 1 else tail := by cases run <;> rfl /-- The same count restricted by a supplied being-coarsening. The run still re-pitches at every actual reception; only the counted events are filtered by the convention. -/ def DropCountInFiber [∀ before received, Decidable (G.IsShareDrop before received)] {Macro : Type} (κ : BeingCoarsening G Macro) [∀ b w, Decidable (κ.InFiber b w)] (b : Macro) (before : Config Contrib) : List (ActualWeld G) -> Nat | [] => 0 | aw :: rest => let after := G.rePitch before aw.weld let tail := DropCountInFiber κ b after rest if κ.InFiber b aw.weld then if G.IsShareDrop before aw.weld then tail + 1 else tail else tail theorem dropCountInFiber_eq_match [∀ before received, Decidable (G.IsShareDrop before received)] {Macro : Type} (κ : BeingCoarsening G Macro) [∀ b w, Decidable (κ.InFiber b w)] (b : Macro) (before : Config Contrib) (run : List (ActualWeld G)) : DropCountInFiber G κ b before run = match run with | [] => 0 | aw :: rest => let after := G.rePitch before aw.weld let tail := DropCountInFiber G κ b after rest if κ.InFiber b aw.weld then if G.IsShareDrop before aw.weld then tail + 1 else tail else tail := by cases run <;> rfl /-- Sum fiber-restricted drop counts over a supplied finite macro-tag list. -/ def DropCountInFiberSum [∀ before received, Decidable (G.IsShareDrop before received)] {Macro : Type} (κ : BeingCoarsening G Macro) [∀ b w, Decidable (κ.InFiber b w)] (tags : List Macro) (before : Config Contrib) (run : List (ActualWeld G)) : Nat := match tags with | [] => 0 | b :: rest => DropCountInFiber G κ b before run + DropCountInFiberSum κ rest before run theorem dropCountInFiber_le_dropCount [∀ before received, Decidable (G.IsShareDrop before received)] {Macro : Type} (κ : BeingCoarsening G Macro) [∀ b w, Decidable (κ.InFiber b w)] (b : Macro) (before : Config Contrib) (run : List (ActualWeld G)) : DropCountInFiber G κ b before run ≤ DropCount G before run := by induction run generalizing before with | nil => exact Nat.le_refl 0 | cons aw rest ih => unfold DropCountInFiber DropCount by_cases hfiber : κ.InFiber b aw.weld · by_cases hdrop : G.IsShareDrop before aw.weld · simp [hfiber, hdrop, ih] · simp [hfiber, hdrop, ih] · by_cases hdrop : G.IsShareDrop before aw.weld · simp [hfiber, hdrop] exact Nat.le_trans (ih (G.rePitch before aw.weld)) (Nat.le_succ _) · simp [hfiber, hdrop, ih] theorem dropCountInFiberSum_nil_run [∀ before received, Decidable (G.IsShareDrop before received)] {Macro : Type} (κ : BeingCoarsening G Macro) [∀ b w, Decidable (κ.InFiber b w)] (tags : List Macro) (before : Config Contrib) : DropCountInFiberSum G κ tags before [] = 0 := by induction tags with | nil => rfl | cons b rest ih => unfold DropCountInFiberSum DropCountInFiber simp [ih] theorem dropCountInFiberSum_cons_run_of_agent_not_mem [∀ before received, Decidable (G.IsShareDrop before received)] {Macro : Type} (κ : BeingCoarsening G Macro) [∀ b w, Decidable (κ.InFiber b w)] (tags : List Macro) (before : Config Contrib) (aw : ActualWeld G) (rest : List (ActualWeld G)) (hnotmem : κ.proj aw.weld.agent ∉ tags) : DropCountInFiberSum G κ tags before (aw :: rest) = DropCountInFiberSum G κ tags (G.rePitch before aw.weld) rest := by induction tags with | nil => rfl | cons b tags ih => simp at hnotmem have hnotFiber : ¬ κ.InFiber b aw.weld := by intro hfiber exact hnotmem.left hfiber unfold DropCountInFiberSum DropCountInFiber simp [hnotFiber, ih hnotmem.right] rw [← dropCountInFiber_eq_match (G := G) κ b (G.rePitch before aw.weld) rest] theorem dropCountInFiberSum_cons_run_of_not_shareDrop [∀ before received, Decidable (G.IsShareDrop before received)] {Macro : Type} (κ : BeingCoarsening G Macro) [∀ b w, Decidable (κ.InFiber b w)] (tags : List Macro) (before : Config Contrib) (aw : ActualWeld G) (rest : List (ActualWeld G)) (hdrop : ¬ G.IsShareDrop before aw.weld) : DropCountInFiberSum G κ tags before (aw :: rest) = DropCountInFiberSum G κ tags (G.rePitch before aw.weld) rest := by induction tags with | nil => rfl | cons b tags ih => unfold DropCountInFiberSum DropCountInFiber by_cases hfiber : κ.InFiber b aw.weld · simp [hfiber, hdrop, ih] rw [← dropCountInFiber_eq_match (G := G) κ b (G.rePitch before aw.weld) rest] · simp [hfiber, ih] rw [← dropCountInFiber_eq_match (G := G) κ b (G.rePitch before aw.weld) rest] theorem dropCountInFiberSum_cons_run_of_shareDrop [∀ before received, Decidable (G.IsShareDrop before received)] {Macro : Type} (κ : BeingCoarsening G Macro) [∀ b w, Decidable (κ.InFiber b w)] (tags : List Macro) (before : Config Contrib) (aw : ActualWeld G) (rest : List (ActualWeld G)) (hnodup : tags.Nodup) (hmem : κ.proj aw.weld.agent ∈ tags) (hdrop : G.IsShareDrop before aw.weld) : DropCountInFiberSum G κ tags before (aw :: rest) = DropCountInFiberSum G κ tags (G.rePitch before aw.weld) rest + 1 := by induction tags with | nil => cases hmem | cons b tags ih => cases hnodup with | cons hnotmem hnodup => by_cases hfiber : κ.InFiber b aw.weld · have htailNotMem : κ.proj aw.weld.agent ∉ tags := by intro htail exact (hnotmem (κ.proj aw.weld.agent) htail) hfiber.symm have htail := dropCountInFiberSum_cons_run_of_agent_not_mem (G := G) κ tags before aw rest htailNotMem unfold DropCountInFiberSum DropCountInFiber simp [hfiber, hdrop, htail] rw [← dropCountInFiber_eq_match (G := G) κ b (G.rePitch before aw.weld) rest] simp [Nat.add_assoc, Nat.add_comm] · have hneq : κ.proj aw.weld.agent ≠ b := hfiber have htailMem : κ.proj aw.weld.agent ∈ tags := by simpa [hneq] using hmem have htail := ih hnodup htailMem unfold DropCountInFiberSum DropCountInFiber simp [hfiber, htail, Nat.add_assoc] rw [← dropCountInFiber_eq_match (G := G) κ b (G.rePitch before aw.weld) rest] theorem dropCount_eq_sum_dropCountInFiber [∀ before received, Decidable (G.IsShareDrop before received)] {Macro : Type} (κ : BeingCoarsening G Macro) [∀ b w, Decidable (κ.InFiber b w)] (tags : List Macro) (hnodup : tags.Nodup) (hmem : ∀ p : G.Being, κ.proj p ∈ tags) (before : Config Contrib) (run : List (ActualWeld G)) : DropCountInFiberSum G κ tags before run = DropCount G before run := by induction run generalizing before with | nil => simpa [DropCount] using (dropCountInFiberSum_nil_run (G := G) κ tags before) | cons aw rest ih => by_cases hdrop : G.IsShareDrop before aw.weld · calc DropCountInFiberSum G κ tags before (aw :: rest) = DropCountInFiberSum G κ tags (G.rePitch before aw.weld) rest + 1 := dropCountInFiberSum_cons_run_of_shareDrop (G := G) κ tags before aw rest hnodup (hmem aw.weld.agent) hdrop _ = DropCount G (G.rePitch before aw.weld) rest + 1 := by exact congrArg (fun n => n + 1) (ih (G.rePitch before aw.weld)) _ = DropCount G before (aw :: rest) := by unfold DropCount simp [hdrop] rw [← dropCount_eq_match (G := G) (G.rePitch before aw.weld) rest] · calc DropCountInFiberSum G κ tags before (aw :: rest) = DropCountInFiberSum G κ tags (G.rePitch before aw.weld) rest := dropCountInFiberSum_cons_run_of_not_shareDrop (G := G) κ tags before aw rest hdrop _ = DropCount G (G.rePitch before aw.weld) rest := by exact ih (G.rePitch before aw.weld) _ = DropCount G before (aw :: rest) := by unfold DropCount simp [hdrop] rw [← dropCount_eq_match (G := G) (G.rePitch before aw.weld) rest] /-- Claim object for a plan that treats delivery as commanded: this deed's fruit is asserted to land at that reception. -/ structure DeliveryCommand (G : Grid Contrib) where deed : G.Weld reception : G.Weld /-- A tiny object language for delivery-command claims. It makes such claims satisfiable only where the field-side delivery relation holds. -/ def deliveryCommandLanguage (G : Grid Contrib) : ClaimLanguage G where Claim := DeliveryCommand G Holds := fun _ claim => DirectedConvention.DeliveredTo G claim.deed claim.reception /-- A recorded delivery-command utterance fits its offered tier only when the commanded delivery is in fact delivered. -/ theorem deliveryCommand_unfit_of_not_delivered (u : RecordedUtterance G (deliveryCommandLanguage G)) (hnot : ¬ DirectedConvention.DeliveredTo G u.content.deed u.content.reception) : ¬ u.FitsOfferedTier := by intro hfit change (deliveryCommandLanguage G).TrueAt u.offeredAt u.content at hfit dsimp [deliveryCommandLanguage, ClaimLanguage.TrueAt] at hfit exact hnot hfit end ConsequentialistConvention end Grid namespace AccumulationNegative /-- Named face of `Grid.rePitch_forgets` for the deliberator block. -/ theorem rePitch_forgets {Contrib : Type} [PreorderBot Contrib] (G : Grid Contrib) (before₁ before₂ : Config Contrib) (received : G.Weld) : G.rePitch before₁ received = G.rePitch before₂ received := Grid.rePitch_forgets G before₁ before₂ received /-- Named face of the no-accumulation corollary for run-valued scores that factor through `Config`. -/ theorem accumulated_attainment_constant_of_same_final {Contrib α : Type} [PreorderBot Contrib] (G : Grid Contrib) (score : Config Contrib -> α) (before₁ before₂ : Config Contrib) (received : G.Weld) : score (G.rePitch before₁ received) = score (G.rePitch before₂ received) := Grid.accumulated_attainment_constant_of_same_final G score before₁ before₂ received end AccumulationNegative /- ============================================================================== Objective negative: "my drops" requires a supplied being-convention ============================================================================== -/ namespace ObjectiveNegative open Grid open Grid.ConsequentialistConvention open Grid.DirectedConvention.BeingConvention /-- Two fine tags with different live shares. Merging or splitting them is still a diagnosis-time convention; the grid itself carries no macro owner. -/ def objectiveGrid : Grid Nat where Being := Bool Call := Unit Response := Unit respondsTo _ _ := some () grade b _ _ := match b with | false => 2 | true => 1 conditions _ _ := True instance objectiveGrid_isShareDrop_decidable (before : Config Nat) (received : objectiveGrid.Weld) : Decidable (objectiveGrid.IsShareDrop before received) := by cases received with | mk agent _ _ => cases agent · dsimp [Grid.IsShareDrop, Grid.share, objectiveGrid, Strict] change Decidable (((2 : Nat) ≤ before.tendency) ∧ ¬ before.tendency ≤ (2 : Nat)) infer_instance · dsimp [Grid.IsShareDrop, Grid.share, objectiveGrid, Strict] change Decidable (((1 : Nat) ≤ before.tendency) ∧ ¬ before.tendency ≤ (1 : Nat)) infer_instance def mergeCoarsening : BeingCoarsening objectiveGrid Unit where proj _ := () def splitCoarsening : BeingCoarsening objectiveGrid Bool where proj := id instance mergeCoarsening_inFiber_decidable (b : Unit) (w : objectiveGrid.Weld) : Decidable (mergeCoarsening.InFiber b w) := by dsimp [Grid.DirectedConvention.BeingConvention.BeingCoarsening.InFiber, mergeCoarsening] infer_instance instance splitCoarsening_inFiber_decidable (b : Bool) (w : objectiveGrid.Weld) : Decidable (splitCoarsening.InFiber b w) := by dsimp [Grid.DirectedConvention.BeingConvention.BeingCoarsening.InFiber, splitCoarsening] infer_instance def wFalse : objectiveGrid.Weld := ⟨false, (), ()⟩ def wTrue : objectiveGrid.Weld := ⟨true, (), ()⟩ def before : Config Nat := { tendency := 3 } def run : List (ActualWeld objectiveGrid) := [ { weld := wFalse, actual := rfl }, { weld := wTrue, actual := rfl } ] def mergedDropCount : Nat := DropCountInFiber objectiveGrid mergeCoarsening () before run def splitFalseDropCount : Nat := DropCountInFiber objectiveGrid splitCoarsening false before run def splitTrueDropCount : Nat := DropCountInFiber objectiveGrid splitCoarsening true before run def splitDropCountSum : Nat := DropCountInFiberSum objectiveGrid splitCoarsening [false, true] before run theorem merge_dropCount : mergedDropCount = 2 := by decide theorem split_false_dropCount : splitFalseDropCount = 1 := by decide theorem split_true_dropCount : splitTrueDropCount = 1 := by decide theorem split_dropCount_sum : splitDropCountSum = 2 := by decide theorem split_dropCount_sum_eq_mergedDropCount : splitDropCountSum = mergedDropCount := by decide /-- The same finite run receives different "my drops" counts under different legal being conventions. -/ theorem fiber_dropCounts_differ : mergedDropCount ≠ splitFalseDropCount := by decide abbrev W := RawWeld Bool Unit Unit /-- The grid data visible to a convention-free recovery function. -/ abbrev GridData : Type := (Bool -> Unit -> Option Unit) × (Bool -> Unit -> Unit -> Nat) × (W -> W -> Prop) def gridData : GridData := (objectiveGrid.respondsTo, objectiveGrid.grade, objectiveGrid.conditions) /-- No convention-free function of the same grid data can return both legal "my drop" readings. -/ theorem no_grid_data_objective_for_my_drops : ¬ ∃ recover : GridData -> Nat, recover gridData = mergedDropCount ∧ recover gridData = splitFalseDropCount := by rintro ⟨_recover, hmerge, hsplit⟩ exact fiber_dropCounts_differ (hmerge.symm.trans hsplit) end ObjectiveNegative /- ============================================================================== Transfer negative: track records underdetermine adaptive landing ============================================================================== -/ namespace TransferNegative inductive Teacher | teacher deriving DecidableEq inductive Call | seen | fresh deriving DecidableEq inductive Response | track | lands | misses deriving DecidableEq def trackClass : Call -> Prop | .seen => True | .fresh => False def landingGrid : Grid Nat where Being := Teacher Call := Call Response := Response respondsTo _ c := match c with | .seen => some .track | .fresh => some .lands grade _ c _ := match c with | .seen => 5 | .fresh => 0 conditions _ _ := True def missingGrid : Grid Nat where Being := Teacher Call := Call Response := Response respondsTo _ c := match c with | .seen => some .track | .fresh => some .misses grade _ c _ := match c with | .seen => 5 | .fresh => 1 conditions _ _ := True /-- The restricted track record: response and grade behavior on the seen call. -/ abbrev TrackData : Type := Option Response × (Response -> Nat) def landingTrackData : TrackData := (landingGrid.respondsTo Teacher.teacher Call.seen, fun r => landingGrid.grade Teacher.teacher Call.seen r) def missingTrackData : TrackData := (missingGrid.respondsTo Teacher.teacher Call.seen, fun r => missingGrid.grade Teacher.teacher Call.seen r) theorem restricted_track_agrees : landingTrackData = missingTrackData := rfl theorem respondsTo_agrees_on_trackClass {c : Call} (hc : trackClass c) : landingGrid.respondsTo Teacher.teacher c = missingGrid.respondsTo Teacher.teacher c := by cases c with | seen => rfl | fresh => cases hc theorem grade_agrees_on_trackClass {c : Call} (hc : trackClass c) (r : Response) : landingGrid.grade Teacher.teacher c r = missingGrid.grade Teacher.teacher c r := by cases c with | seen => rfl | fresh => cases hc def landingFreshEffect : Nat := landingGrid.grade Teacher.teacher Call.fresh Response.lands def missingFreshEffect : Nat := missingGrid.grade Teacher.teacher Call.fresh Response.misses theorem fresh_effect_disagrees : landingFreshEffect ≠ missingFreshEffect := by decide theorem landing_adaptive : landingGrid.ResponseVariesWithCall Teacher.teacher := by refine ⟨Call.seen, Call.fresh, Response.track, Response.lands, rfl, rfl, ?_⟩ intro h cases h theorem missing_adaptive : missingGrid.ResponseVariesWithCall Teacher.teacher := by refine ⟨Call.seen, Call.fresh, Response.track, Response.misses, rfl, rfl, ?_⟩ intro h cases h /-- Agreement on the teacher's whole seen track record does not determine the fresh-call effect for adaptive responders. -/ theorem no_estimator_from_restricted_track : ¬ ∃ estimate : TrackData -> Nat, estimate landingTrackData = landingFreshEffect ∧ estimate missingTrackData = missingFreshEffect := by rintro ⟨estimate, hlanding, hmissing⟩ have heq : landingFreshEffect = missingFreshEffect := by calc landingFreshEffect = estimate landingTrackData := hlanding.symm _ = estimate missingTrackData := congrArg estimate restricted_track_agrees _ = missingFreshEffect := hmissing exact fresh_effect_disagrees heq theorem adaptive_track_record_underdetermines_new_effect : landingGrid.ResponseVariesWithCall Teacher.teacher ∧ missingGrid.ResponseVariesWithCall Teacher.teacher ∧ landingTrackData = missingTrackData ∧ landingFreshEffect ≠ missingFreshEffect ∧ ¬ ∃ estimate : TrackData -> Nat, estimate landingTrackData = landingFreshEffect ∧ estimate missingTrackData = missingFreshEffect := ⟨landing_adaptive, missing_adaptive, restricted_track_agrees, fresh_effect_disagrees, no_estimator_from_restricted_track⟩ /-- In the invariant/static case, any mounted fresh-call response is the same response already seen in the restricted record. This is the contrast case: transfer holds exactly where response-adaptivity is absent. -/ theorem responseInvariant_determines_response {Contrib : Type} [PreorderBot Contrib] {G : Grid Contrib} {b : G.Being} {seen fresh : G.Call} {rSeen rFresh : G.Response} (h : G.ResponseInvariant b) (hseen : G.respondsTo b seen = some rSeen) (hfresh : G.respondsTo b fresh = some rFresh) : rFresh = rSeen := h fresh seen rFresh rSeen hfresh hseen def staticGrid : Grid Nat where Being := Teacher Call := Call Response := Response respondsTo _ _ := some Response.track grade _ _ _ := 5 conditions _ _ := True theorem static_responseInvariant : staticGrid.ResponseInvariant Teacher.teacher := by intro _c₁ _c₂ _r₁ _r₂ h₁ h₂ cases h₁ cases h₂ rfl theorem static_fresh_response_determined : Response.track = Response.track := responseInvariant_determines_response (G := staticGrid) (b := Teacher.teacher) (seen := Call.seen) (fresh := Call.fresh) (rSeen := Response.track) (rFresh := Response.track) static_responseInvariant rfl rfl end TransferNegative /- ============================================================================== Delivery-arrogation negative: a command is quotable, not satisfiable ============================================================================== -/ namespace DeliveryArrogationNegative open Grid open Grid.ConsequentialistConvention inductive Being | planner deriving DecidableEq inductive Call | deed | fruit deriving DecidableEq inductive Response | utter deriving DecidableEq def commandGrid : Grid Nat where Being := Being Call := Call Response := Response respondsTo _ _ := some Response.utter grade _ _ _ := 1 conditions _ _ := False def deed : commandGrid.Weld := ⟨Being.planner, Call.deed, Response.utter⟩ def reception : commandGrid.Weld := ⟨Being.planner, Call.fruit, Response.utter⟩ def commandUtterance : RecordedUtterance commandGrid (deliveryCommandLanguage commandGrid) where weld := deed actual := rfl offeredAt := Tier.actTime deed content := { deed := deed, reception := reception } theorem command_not_delivered : ¬ DirectedConvention.DeliveredTo commandGrid deed reception := by intro h cases h theorem command_utterance_not_fits : ¬ commandUtterance.FitsOfferedTier := deliveryCommand_unfit_of_not_delivered (G := commandGrid) commandUtterance command_not_delivered theorem command_utterance_is_quotable : commandUtterance.answersCall = Call.deed ∧ ¬ commandUtterance.FitsOfferedTier := ⟨rfl, command_utterance_not_fits⟩ end DeliveryArrogationNegative end WAA ===== FILE: WeldAndArrow/Doctrines/Ethics.lean ===== /- ================================================================================ WeldAndArrow.Doctrines.Ethics Ethics as the bundled faith-conditional code ================================================================================ Ethics as the bundled faith-conditional code. The grid proves the conditional; it discharges neither the principle nor the faith, and the detached injunction appears nowhere in the assertable voice. Reading and motivation: Identification/Commentary.lean, C.4. -/ import WeldAndArrow.Doctrines.Faith namespace WAA namespace Grid namespace DirectedConvention variable {Contrib : Type} [PreorderBot Contrib] variable (G : Grid Contrib) /- ============================================================================== Ethics as faith-conditional code ============================================================================== -/ /-- The ethics stance: exactly what the agent brings and the grid never discharges. Principle plus faith in one being's full enlightenment. Reading and motivation: Identification/Commentary.lean, C.4. -/ structure WaaEthicsStance (Faith : Prop -> Prop) (b : G.Being) : Prop where principle : WaaFaithPrinciple G (waaPathClaimLanguage G) Faith faith : Faith (WaaFullyEnlightened G b) /-- The ethical code as an implication type only. One stance yields, for every recorded utterance of the faith-object, delivered into a live aversion context, the share-drop landing. The detached consequent appears nowhere. Reading and motivation: Identification/Commentary.lean, C.4. -/ def WaaEthicalCode (Faith : Prop -> Prop) (b : G.Being) : Prop := WaaEthicsStance G Faith b -> forall u : RecordedUtterance G (waaPathClaimLanguage G), u.weld.agent = b -> DeliveredTo G u.content.deed u.content.reception -> WaaAversionContext G u.content.before u.content.reception -> HasShareDropLanding G u.content.before u.content.deed /-- Under a stance, the faith-object's testimony is true at its offered tier: the "what they say is true" half. Thin wrapper over `waa_says_true_of_faith`. Reading and motivation: Identification/Commentary.lean, C.4. -/ theorem waa_stance_says_true {Faith : Prop -> Prop} {b : G.Being} (hstance : WaaEthicsStance G Faith b) (u : RecordedUtterance G (waaPathClaimLanguage G)) (hutter : u.weld.agent = b) : u.FitsOfferedTier := waa_says_true_of_faith G hstance.principle hstance.faith u hutter /-- Under a stance, one delivered utterance met with live aversion yields the landing: the per-utterance ought. Route through `waa_path_landing_of_faithPrinciple`. Reading and motivation: Identification/Commentary.lean, C.4. -/ theorem waa_ethics_landing_of_stance {Faith : Prop -> Prop} {b : G.Being} (hstance : WaaEthicsStance G Faith b) (u : RecordedUtterance G (waaPathClaimLanguage G)) (hutter : u.weld.agent = b) (hdel : DeliveredTo G u.content.deed u.content.reception) (hctx : WaaAversionContext G u.content.before u.content.reception) : HasShareDropLanding G u.content.before u.content.deed := waa_path_landing_of_faithPrinciple G hstance.principle hstance.faith u hutter hdel hctx /-- The grid proves the whole code as one conditional, hypothesis-free. Reading and motivation: Identification/Commentary.lean, C.4. -/ theorem waaEthicalCode_conditional (Faith : Prop -> Prop) (b : G.Being) : WaaEthicalCode G Faith b := by intro hstance u hutter hdel hctx exact waa_ethics_landing_of_stance G hstance u hutter hdel hctx /-- Bridge: each instance of the code is a `WaaFaithOught`, so the ethics layer adds bundling and naming, not new assertive content. Reading and motivation: Identification/Commentary.lean, C.4. -/ theorem waaFaithOught_of_ethicalCode {Faith : Prop -> Prop} {b : G.Being} (hcode : WaaEthicalCode G Faith b) (u : RecordedUtterance G (waaPathClaimLanguage G)) : WaaFaithOught G Faith b u := by intro hprinciple hfaith hutter hdel hctx exact hcode ⟨hprinciple, hfaith⟩ u hutter hdel hctx namespace BeingConvention namespace GridConvention /-- The ethics conditional is a grammatical verdict item. Reading and motivation: Identification/Commentary.lean, C.4. -/ def WaaEthicsConditionalVoice : ErrorGrade := ErrorGrade.verdict /-- The detached ethics injunction is only displayable as shortfall-voiced. Reading and motivation: Identification/Commentary.lean, C.4. -/ def WaaEthicsDetachedVoice : ErrorGrade := ErrorGrade.shortfall /-- The conditional ethics voice is assertable. Reading and motivation: Identification/Commentary.lean, C.4. -/ theorem waa_ethics_conditional_voice_assertable : ErrorGrade.voice WaaEthicsConditionalVoice = VerdictVoice.assertable := rfl /-- The detached ethics voice is displayable. Reading and motivation: Identification/Commentary.lean, C.4. -/ theorem waa_ethics_detached_voice_displayable : ErrorGrade.voice WaaEthicsDetachedVoice = VerdictVoice.displayable := rfl end GridConvention end BeingConvention end DirectedConvention end Grid end WAA ===== FILE: WeldAndArrow/Doctrines/EthicsNegative.lean ===== /- ================================================================================ WeldAndArrow.Doctrines.EthicsNegative Negative witnesses for the bundled ethics conditional ================================================================================ Reading and motivation: Identification/Commentary.lean, C.4. -/ import WeldAndArrow.Doctrines.Ethics namespace WAA namespace EthicsNegative open Grid open Grid.DirectedConvention /- ============================================================================== Concrete grid for ethics honesty clauses ============================================================================== -/ /-- The beings used by the ethics negative witnesses. -/ inductive Being | buddha | disciple | receiver /-- The single call used by the ethics negative witnesses. -/ inductive Call | call /-- The single response used by the ethics negative witnesses. -/ inductive Response | response /-- A concrete grid where the buddha is a responsive terminus, while the disciple's delivered deed reaches a receiver whose live share does not drop. -/ def grid : Grid Nat where Being := Being Call := Call Response := Response respondsTo _ _ := some Response.response grade b _ _ := match b with | .buddha => 0 | .disciple => 1 | .receiver => 1 conditions deed reception := deed.agent = Being.disciple ∧ reception.agent = Being.receiver /-- The live prior configuration used by the false-testimony witness. -/ def liveBefore : Config Nat := { tendency := 1 } /-- The pole prior configuration used by the empty-at-the-pole witness. -/ def poleBefore : Config Nat := { tendency := 0 } /-- The disciple deed delivered in the concrete grid. -/ def discipleDeed : grid.Weld := ⟨Being.disciple, Call.call, Response.response⟩ /-- The receiver weld reached by the disciple deed. -/ def reception : grid.Weld := ⟨Being.receiver, Call.call, Response.response⟩ /-- The buddha weld that records the false testimony. -/ def buddhaWeld : grid.Weld := ⟨Being.buddha, Call.call, Response.response⟩ /-- The live prior tendency is not at the pole. -/ theorem liveBefore_not_atBot : ¬ AtBot liveBefore.tendency := by intro h exact Nat.not_succ_le_zero 0 h /-- The pole prior tendency is at the pole. -/ theorem poleBefore_atBot : AtBot poleBefore.tendency := Nat.le_refl 0 /-- The disciple deed is actual in the concrete grid. -/ theorem discipleDeed_actual : grid.Actual discipleDeed := rfl /-- The receiver weld is actual in the concrete grid. -/ theorem reception_actual : grid.Actual reception := rfl /-- The buddha weld is actual in the concrete grid. -/ theorem buddhaWeld_actual : grid.Actual buddhaWeld := rfl /-- The disciple deed is delivered to the receiver weld. -/ theorem delivered : DeliveredTo grid discipleDeed reception := ⟨rfl, rfl⟩ /-- The receiver weld has a live self-pole index. -/ theorem reception_hasSelfPoleIndex : grid.HasSelfPoleIndex reception := by intro hbot exact Nat.not_succ_le_zero 0 hbot /-- The live receiver-side aversion context holds in the concrete grid. -/ theorem aversionContext : WaaAversionContext grid liveBefore reception := { liveBefore := liveBefore_not_atBot mismatchLive := ⟨reception_actual, reception_hasSelfPoleIndex⟩ } /-- The disciple deed has no share-drop landing for the live prior tendency. -/ theorem not_hasShareDropLanding_liveBefore : ¬ HasShareDropLanding grid liveBefore discipleDeed := by rintro ⟨received, hland⟩ have hreceiver : received.agent = Being.receiver := hland.left.left.right have hdrop : Strict (grid.share received) liveBefore.tendency := hland.right have hstrict : Strict (1 : Nat) 1 := by simpa [grid, Grid.share, liveBefore, hreceiver] using hdrop exact strict_irrefl (1 : Nat) hstrict /-- The buddha's recorded path claim about the disciple's deed is false: delivery occurs, the prior tendency is live, and no share-drop landing exists. -/ def falseClaim : RecordedUtterance grid (waaPathClaimLanguage grid) where weld := buddhaWeld actual := buddhaWeld_actual offeredAt := Tier.floor content := ⟨liveBefore, discipleDeed, reception⟩ /-- The buddha's false claim does not fit its offered tier. -/ theorem falseClaim_not_fitsOfferedTier : ¬ falseClaim.FitsOfferedTier := by intro hfit change (waaPathClaimLanguage grid).TrueAt falseClaim.offeredAt falseClaim.content at hfit dsimp [waaPathClaimLanguage, ClaimLanguage.TrueAt, falseClaim, ShortfallClosedAt] at hfit exact not_hasShareDropLanding_liveBefore (hfit liveBefore_not_atBot delivered) /- ============================================================================== Ethics negative witnesses ============================================================================== -/ /-- Even with a stance as a hypothesis, a pole-prior receiver has no live aversion antecedent and no share-drop landing. Faith does not manufacture a practical claim where no live shortfall exists. -/ theorem no_ethics_bearing_at_pole (Faith : Prop -> Prop) (b : Being) (_hstance : WaaEthicsStance grid Faith b) : ¬ WaaAversionContext grid poleBefore reception ∧ ¬ HasShareDropLanding grid poleBefore discipleDeed := ⟨no_waa_aversion_context_at_pole grid poleBefore_atBot reception, no_waa_path_at_pole grid poleBefore_atBot discipleDeed⟩ /-- No faith operator can support an ethics stance toward the buddha over this false testimony: the stance would force the false recorded claim to fit its offered tier. -/ theorem no_stance_over_false_testimony (Faith : Prop -> Prop) : ¬ WaaEthicsStance grid Faith Being.buddha := by intro hstance exact falseClaim_not_fitsOfferedTier (waa_stance_says_true grid hstance falseClaim rfl) /-- The disciple's own recorded claim, used to witness faith-object relativity. -/ def discipleClaim : RecordedUtterance grid (waaPathClaimLanguage grid) where weld := discipleDeed actual := discipleDeed_actual offeredAt := Tier.floor content := ⟨liveBefore, discipleDeed, reception⟩ /-- A buddha-directed ethical code does not cover a disciple-recorded utterance: the speaker-equality antecedent is false, so the `b` parameter keeps the code relative to its faith-object. -/ theorem ethicalCode_relative_to_faith_object (Faith : Prop -> Prop) (_hcode : WaaEthicalCode grid Faith Being.buddha) : ¬ discipleClaim.weld.agent = Being.buddha := by intro h exact Being.noConfusion h end EthicsNegative end WAA ===== FILE: WeldAndArrow/Doctrines/Factors.lean ===== /- ================================================================================ WeldAndArrow.Doctrines.Factors Path-factor hold/release readings over the fetter table ================================================================================ -/ import WeldAndArrow.Doctrines.Fetters import WeldAndArrow.Doctrines.SuddenGradual namespace WAA /- ============================================================================== Factor data and derived classes ============================================================================== -/ inductive PathFactor | rites | view | resolve | speech | conduct namespace PathFactor /-- Factor blocker classes are derived from the supplied fetter reading. The first stream-entry pair covers rites-grasp plus the blockers of right view; speech and conduct are named but intentionally inert in this phase. -/ def blockerClass {Contrib : Type} [PreorderBot Contrib] {G : Grid Contrib} (fr : G.FetterReading) : PathFactor → G.Call → Prop | .rites, c => fr.provocationClass Fetter.ritesGrasp c | .view, c => fr.provocationClass Fetter.identityView c ∨ fr.provocationClass Fetter.doubt c | .resolve, c => fr.provocationClass Fetter.sensualDesire c ∨ fr.provocationClass Fetter.illWill c | .speech, _ => False | .conduct, _ => False end PathFactor namespace Grid open DirectedConvention open DirectedConvention.BeingConvention variable {Contrib : Type} [PreorderBot Contrib] variable (G : Grid Contrib) theorem ritesView_union_covers_streamEntry_fetters (fr : G.FetterReading) (c : G.Call) : (PathFactor.blockerClass fr PathFactor.rites c ∨ PathFactor.blockerClass fr PathFactor.view c) ↔ Path.cutClasses fr Path.streamEntry c := by constructor · intro h rcases h with hrites | hview · exact ⟨Fetter.ritesGrasp, rfl, hrites⟩ · rcases hview with hidentity | hdoubt · exact ⟨Fetter.identityView, rfl, hidentity⟩ · exact ⟨Fetter.doubt, rfl, hdoubt⟩ · rintro ⟨f, hf, hclass⟩ cases f with | identityView => exact Or.inr (Or.inl hclass) | doubt => exact Or.inr (Or.inr hclass) | ritesGrasp => exact Or.inl hclass | sensualDesire => cases hf | illWill => cases hf | formDesire => cases hf | formlessDesire => cases hf | conceit => cases hf | restlessness => cases hf | ignorance => cases hf theorem resolve_covers_nonReturn_fetters (fr : G.FetterReading) (c : G.Call) : PathFactor.blockerClass fr PathFactor.resolve c ↔ ∃ f : Fetter, Fetter.abandonedAt f = Path.nonReturn ∧ fr.provocationClass f c := by constructor · intro h rcases h with hsensual | hill · exact ⟨Fetter.sensualDesire, rfl, hsensual⟩ · exact ⟨Fetter.illWill, rfl, hill⟩ · rintro ⟨f, hf, hclass⟩ cases f with | identityView => cases hf | doubt => cases hf | ritesGrasp => cases hf | sensualDesire => exact Or.inl hclass | illWill => exact Or.inr hclass | formDesire => cases hf | formlessDesire => cases hf | conceit => cases hf | restlessness => cases hf | ignorance => cases hf /-- The three active factor blocker classes cover exactly the lower-fetter provocation classes. This extends the table-coherence anchor `Fetter.kind_lower_iff_cut_by_nonReturn`: the lower fetters are precisely those cut by non-return, now regrouped as rites, view, and resolve. -/ theorem lower_fetters_covered_by_rites_view_resolve (fr : G.FetterReading) (c : G.Call) : (PathFactor.blockerClass fr PathFactor.rites c ∨ PathFactor.blockerClass fr PathFactor.view c ∨ PathFactor.blockerClass fr PathFactor.resolve c) ↔ Path.cutClasses fr Path.nonReturn c := by constructor · intro h rcases h with hrites | hview | hresolve · exact ⟨Fetter.ritesGrasp, Or.inl rfl, hrites⟩ · rcases hview with hidentity | hdoubt · exact ⟨Fetter.identityView, Or.inl rfl, hidentity⟩ · exact ⟨Fetter.doubt, Or.inl rfl, hdoubt⟩ · rcases hresolve with hsensual | hill · exact ⟨Fetter.sensualDesire, Or.inr rfl, hsensual⟩ · exact ⟨Fetter.illWill, Or.inr rfl, hill⟩ · rintro ⟨f, hf, hclass⟩ cases f with | identityView => exact Or.inr (Or.inl (Or.inl hclass)) | doubt => exact Or.inr (Or.inl (Or.inr hclass)) | ritesGrasp => exact Or.inl hclass | sensualDesire => exact Or.inr (Or.inr (Or.inl hclass)) | illWill => exact Or.inr (Or.inr (Or.inr hclass)) | formDesire => rcases hf with h | h <;> cases h | formlessDesire => rcases hf with h | h <;> cases h | conceit => rcases hf with h | h <;> cases h | restlessness => rcases hf with h | h <;> cases h | ignorance => rcases hf with h | h <;> cases h /- ============================================================================== Hold / Release ============================================================================== -/ /-- A factor is HELD when a live self-pole weld in its blocker class is witnessed in the seen run. Hold is not an error: a stage-appropriate hold can be correct. The Hold/Release pair lives on the agent-factor frame, unlike freeze/collapse on the utterance/distinction frame and unlike clench/quietness on the share frame. -/ def FactorHeld {Macro : Type} (κ : BeingCoarsening G Macro) (b : Macro) (fr : G.FetterReading) (φ : PathFactor) (run : List G.Weld) : Prop := ∃ w ∈ run, G.Actual w ∧ κ.InFiber b w ∧ PathFactor.blockerClass fr φ w.call ∧ G.HasSelfPoleIndex w /-- A factor is RELEASED when the fiber is at pole on its blocker class. This is a whole-class cut, so one actual in-fiber live weld in the class refutes it. -/ def FactorReleased {Macro : Type} (κ : BeingCoarsening G Macro) (b : Macro) (fr : G.FetterReading) (φ : PathFactor) : Prop := κ.FiberAtPoleOn b (PathFactor.blockerClass fr φ) theorem not_factorHeld_of_factorReleased {Macro : Type} {κ : BeingCoarsening G Macro} {b : Macro} {fr : G.FetterReading} {φ : PathFactor} {run : List G.Weld} (h : G.FactorReleased κ b fr φ) : ¬ G.FactorHeld κ b fr φ run := by rintro ⟨w, _hmem, hactual, hfiber, hclass, hidx⟩ exact (κ.no_live_index_under_fiberAtPoleOn h hactual hfiber hclass) hidx theorem factorReleased_rites_iff_ritesGrasp_cut {Macro : Type} (κ : BeingCoarsening G Macro) (b : Macro) (fr : G.FetterReading) : G.FactorReleased κ b fr PathFactor.rites ↔ G.FetterCut κ b fr Fetter.ritesGrasp := Iff.rfl theorem factorReleased_view_iff {Macro : Type} (κ : BeingCoarsening G Macro) (b : Macro) (fr : G.FetterReading) : G.FactorReleased κ b fr PathFactor.view ↔ G.FetterCut κ b fr Fetter.identityView ∧ G.FetterCut κ b fr Fetter.doubt := by constructor · intro h constructor · intro w hactual hfiber hclass exact h w hactual hfiber (Or.inl hclass) · intro w hactual hfiber hclass exact h w hactual hfiber (Or.inr hclass) · rintro ⟨hidentity, hdoubt⟩ w hactual hfiber hclass rcases hclass with hclass | hclass · exact hidentity w hactual hfiber hclass · exact hdoubt w hactual hfiber hclass theorem factorReleased_resolve_iff {Macro : Type} (κ : BeingCoarsening G Macro) (b : Macro) (fr : G.FetterReading) : G.FactorReleased κ b fr PathFactor.resolve ↔ G.FetterCut κ b fr Fetter.sensualDesire ∧ G.FetterCut κ b fr Fetter.illWill := by constructor · intro h constructor · intro w hactual hfiber hclass exact h w hactual hfiber (Or.inl hclass) · intro w hactual hfiber hclass exact h w hactual hfiber (Or.inr hclass) · rintro ⟨hsensual, hill⟩ w hactual hfiber hclass rcases hclass with hclass | hclass · exact hsensual w hactual hfiber hclass · exact hill w hactual hfiber hclass /- ============================================================================== Stage readings ============================================================================== -/ def WaaStreamEnterer {Macro : Type} (κ : BeingCoarsening G Macro) (b : Macro) (fr : G.FetterReading) (run : List G.Weld) : Prop := G.FactorReleased κ b fr PathFactor.rites ∧ G.FactorHeld κ b fr PathFactor.view run def WaaStreamWinner {Macro : Type} (κ : BeingCoarsening G Macro) (b : Macro) (fr : G.FetterReading) : Prop := G.FactorReleased κ b fr PathFactor.rites ∧ G.FactorReleased κ b fr PathFactor.view def WaaOnceReturner {Macro : Type} (κ : BeingCoarsening G Macro) (b : Macro) (fr : G.FetterReading) (run : List G.Weld) : Prop := G.WaaStreamWinner κ b fr ∧ G.FactorHeld κ b fr PathFactor.resolve run def WaaNonReturner {Macro : Type} (κ : BeingCoarsening G Macro) (b : Macro) (fr : G.FetterReading) : Prop := G.WaaStreamWinner κ b fr ∧ G.FactorReleased κ b fr PathFactor.resolve /- The upper-half pair is deliberately named and inert in this phase. `PathFactor.speech` and `PathFactor.conduct` currently have `False` blocker classes. The open question is what "holding a factor" should mean in grid terms when the arhat is at `FiberAtPole`: `FactorHeld` requires `HasSelfPoleIndex`, while the existing arhat anchors refute live indexes fiber-wide. The reserved prose name `Seclusion` belongs to the future speech-release stage's held factor; no declaration is introduced yet. -/ theorem waaStreamWinner_iff_streamEntry_cutClasses {Macro : Type} (κ : BeingCoarsening G Macro) (b : Macro) (fr : G.FetterReading) : G.WaaStreamWinner κ b fr ↔ κ.FiberAtPoleOn b (Path.cutClasses fr Path.streamEntry) := by constructor · rintro ⟨hrites, hview⟩ w hactual hfiber hclass have hcovered : PathFactor.blockerClass fr PathFactor.rites w.call ∨ PathFactor.blockerClass fr PathFactor.view w.call := (G.ritesView_union_covers_streamEntry_fetters fr w.call).mpr hclass rcases hcovered with hcovered | hcovered · exact hrites w hactual hfiber hcovered · exact hview w hactual hfiber hcovered · intro hcut constructor · intro w hactual hfiber hclass exact hcut w hactual hfiber ((G.ritesView_union_covers_streamEntry_fetters fr w.call).mp (Or.inl hclass)) · intro w hactual hfiber hclass exact hcut w hactual hfiber ((G.ritesView_union_covers_streamEntry_fetters fr w.call).mp (Or.inr hclass)) theorem waaNonReturner_iff_nonReturn_cut {Macro : Type} (κ : BeingCoarsening G Macro) (b : Macro) (fr : G.FetterReading) : G.WaaNonReturner κ b fr ↔ κ.FiberAtPoleOn b (Path.cutClasses fr Path.nonReturn) := by constructor · rintro ⟨hstream, hresolve⟩ w hactual hfiber hclass have hcovered : PathFactor.blockerClass fr PathFactor.rites w.call ∨ PathFactor.blockerClass fr PathFactor.view w.call ∨ PathFactor.blockerClass fr PathFactor.resolve w.call := (G.lower_fetters_covered_by_rites_view_resolve fr w.call).mpr hclass rcases hcovered with hrites | hview | hresolveClass · exact hstream.left w hactual hfiber hrites · exact hstream.right w hactual hfiber hview · exact hresolve w hactual hfiber hresolveClass · intro hcut constructor · constructor · intro w hactual hfiber hclass exact hcut w hactual hfiber ((G.lower_fetters_covered_by_rites_view_resolve fr w.call).mp (Or.inl hclass)) · intro w hactual hfiber hclass exact hcut w hactual hfiber ((G.lower_fetters_covered_by_rites_view_resolve fr w.call).mp (Or.inr (Or.inl hclass))) · intro w hactual hfiber hclass exact hcut w hactual hfiber ((G.lower_fetters_covered_by_rites_view_resolve fr w.call).mp (Or.inr (Or.inr hclass))) theorem waaNonReturner_of_arhatFiber {κ : G.PathScheme} (fr : G.FetterReading) (h : κ.FiberAtPole Path.arhatship) : G.WaaNonReturner κ Path.arhatship fr := by apply (G.waaNonReturner_iff_nonReturn_cut κ Path.arhatship fr).mpr intro w hactual hfiber _hclass exact h w hactual hfiber theorem waaStreamWinner_of_waaNonReturner {Macro : Type} {κ : BeingCoarsening G Macro} {b : Macro} {fr : G.FetterReading} (h : G.WaaNonReturner κ b fr) : G.WaaStreamWinner κ b fr := h.left theorem not_waaStreamEnterer_view_hold_of_waaStreamWinner {Macro : Type} {κ : BeingCoarsening G Macro} {b : Macro} {fr : G.FetterReading} {run : List G.Weld} (h : G.WaaStreamWinner κ b fr) : ¬ G.FactorHeld κ b fr PathFactor.view run := G.not_factorHeld_of_factorReleased h.right theorem not_waaStreamEnterer_of_waaStreamWinner {Macro : Type} {κ : BeingCoarsening G Macro} {b : Macro} {fr : G.FetterReading} {run : List G.Weld} (h : G.WaaStreamWinner κ b fr) : ¬ G.WaaStreamEnterer κ b fr run := by intro henterer exact G.not_waaStreamEnterer_view_hold_of_waaStreamWinner h henterer.right /- ============================================================================== Once-return attenuation ============================================================================== -/ /-- A share-drop run restricted to one supplied call-class. -/ def ShareDropRunOn (before : Config Contrib) (cs : G.Call → Prop) (run : List G.Weld) : Prop := G.ShareDropRun before run ∧ ∀ w : G.Weld, w ∈ run → cs w.call theorem shareDropRunOn_univ_iff_shareDropRun (before : Config Contrib) (run : List G.Weld) : G.ShareDropRunOn before (fun _ => True) run ↔ G.ShareDropRun before run := by constructor · intro h exact h.left · intro h exact ⟨h, fun _w _hmem => True.intro⟩ def ShareDropRunOnFactor (fr : G.FetterReading) (φ : PathFactor) (run : List G.Weld) : Prop := ∃ before : Config Contrib, G.ShareDropRunOn before (PathFactor.blockerClass fr φ) run /-- Once-return attenuation is a real resolve-class share-drop run whose final tendency has not yet reached the pole. It gives once-return positive checked content without adding a new cut class. -/ def WaaResolveAttenuation {Macro : Type} (_κ : BeingCoarsening G Macro) (_b : Macro) (fr : G.FetterReading) (run : List G.Weld) : Prop := ∃ (before : Config Contrib) (received : G.Weld) (rest : List G.Weld), run = received :: rest ∧ G.ShareDropRunOn before (PathFactor.blockerClass fr PathFactor.resolve) run ∧ ¬ AtBot before.tendency ∧ ¬ AtBot ((G.rePitchRun before run).tendency) def registerResolveFactorReading : registerClockGrid.FetterReading where provocationClass | Fetter.sensualDesire, _ => True | _, _ => False def registerResolveWeld : registerClockGrid.Weld := ⟨(2 : Nat), (), (3 : Nat)⟩ def registerResolveRun : List registerClockGrid.Weld := [registerResolveWeld] theorem registerResolve_streamWinner : registerClockGrid.WaaStreamWinner registerClockCoarsening () registerResolveFactorReading := by constructor · intro _w _hactual _hfiber hclass cases hclass · intro _w _hactual _hfiber hclass rcases hclass with hclass | hclass <;> cases hclass theorem registerResolve_held : registerClockGrid.FactorHeld registerClockCoarsening () registerResolveFactorReading PathFactor.resolve registerResolveRun := by refine ⟨registerResolveWeld, ?_, rfl, rfl, ?_, ?_⟩ · simp [registerResolveRun] · exact Or.inl True.intro · dsimp [Grid.HasSelfPoleIndex, Grid.share, registerClockGrid, registerResolveWeld, AtBot, shareBot] change ¬ (2 : Nat) ≤ 0 exact Nat.not_succ_le_zero 1 theorem registerResolve_attenuation : registerClockGrid.WaaResolveAttenuation registerClockCoarsening () registerResolveFactorReading registerResolveRun := by refine ⟨{ tendency := 5 }, registerResolveWeld, [], rfl, ?_, ?_, ?_⟩ · constructor · refine Grid.ShareDropRun.cons ?_ ?_ ?_ · rfl · dsimp [Grid.IsShareDrop, Grid.share, registerClockGrid, registerResolveWeld] constructor · change (2 : Nat) ≤ 5 decide · change ¬ (5 : Nat) ≤ 2 decide · exact Grid.ShareDropRun.nil _ · intro w hmem simp [registerResolveRun] at hmem subst w exact Or.inl True.intro · dsimp [AtBot, shareBot] change ¬ (5 : Nat) ≤ 0 exact Nat.not_succ_le_zero 4 · dsimp [Grid.rePitchRun, Grid.rePitch, Grid.share, registerClockGrid, registerResolveRun, registerResolveWeld, AtBot, shareBot] change ¬ (2 : Nat) ≤ 0 exact Nat.not_succ_le_zero 1 theorem registerResolve_not_released : ¬ registerClockGrid.FactorReleased registerClockCoarsening () registerResolveFactorReading PathFactor.resolve := by intro hrelease have hbot : AtBot (registerClockGrid.share registerResolveWeld) := hrelease registerResolveWeld rfl rfl (Or.inl True.intro) dsimp [Grid.share, registerClockGrid, registerResolveWeld, AtBot, shareBot] at hbot change (2 : Nat) ≤ 0 at hbot exact Nat.not_succ_le_zero 1 hbot theorem waaOnceReturner_attenuation_witness : ∃ (fr : registerClockGrid.FetterReading) (run : List registerClockGrid.Weld), registerClockGrid.WaaOnceReturner registerClockCoarsening () fr run ∧ registerClockGrid.WaaResolveAttenuation registerClockCoarsening () fr run ∧ ¬ registerClockGrid.FactorReleased registerClockCoarsening () fr PathFactor.resolve := by refine ⟨registerResolveFactorReading, registerResolveRun, ?_, registerResolve_attenuation, registerResolve_not_released⟩ exact ⟨registerResolve_streamWinner, registerResolve_held⟩ theorem attenuation_not_release : ∃ (fr : registerClockGrid.FetterReading) (run : List registerClockGrid.Weld), registerClockGrid.WaaResolveAttenuation registerClockCoarsening () fr run ∧ ¬ registerClockGrid.FactorReleased registerClockCoarsening () fr PathFactor.resolve := by rcases waaOnceReturner_attenuation_witness with ⟨fr, run, _honce, hatt, hnotRelease⟩ exact ⟨fr, run, hatt, hnotRelease⟩ /- ============================================================================== Serial factor regime ============================================================================== -/ def RunsExhibitFactorOrder (fr : G.FetterReading) (runs : List (List G.Weld)) : Prop := ∃ ritesRun viewRun resolveRun : List G.Weld, runs = [ritesRun, viewRun, resolveRun] ∧ G.ShareDropRunOnFactor fr PathFactor.rites ritesRun ∧ G.ShareDropRunOnFactor fr PathFactor.view viewRun ∧ G.ShareDropRunOnFactor fr PathFactor.resolve resolveRun /-- The serial-factor regime is the conditional voice for "usually runs in order": if the seen runs exhibit share-drops in the derived factor order rites-before-view-before-resolve, the supplied regime promotes the path readings to their corresponding fruit readings along those runs. The grid does not discharge the antecedent. The guards are `WaaSuddenArrival` and `SuddenGradualNegative.subitism_frequency_underdetermined`; no frequency claim is introduced, only ordering inside this regime. -/ def WaaSerialFactorRegime {Macro : Type} (κ : BeingCoarsening G Macro) (b : Macro) (fr : G.FetterReading) (runs : List (List G.Weld)) : Prop := G.RunsExhibitFactorOrder fr runs → (∀ run ∈ runs, G.WaaStreamEnterer κ b fr run → G.WaaStreamWinner κ b fr) ∧ (∀ run ∈ runs, G.WaaOnceReturner κ b fr run → G.WaaNonReturner κ b fr) theorem waaSerialFactorRegime_conditional {Macro : Type} {κ : BeingCoarsening G Macro} {b : Macro} {fr : G.FetterReading} {runs : List (List G.Weld)} (hregime : G.WaaSerialFactorRegime κ b fr runs) (horder : G.RunsExhibitFactorOrder fr runs) : (∀ run ∈ runs, G.WaaStreamEnterer κ b fr run → G.WaaStreamWinner κ b fr) ∧ (∀ run ∈ runs, G.WaaOnceReturner κ b fr run → G.WaaNonReturner κ b fr) := hregime horder theorem waaSuddenArrival_consistent_with_factorScheme {κ : G.PathScheme} {before : Config Contrib} {received : G.Weld} (fr : G.FetterReading) (hsudden : G.WaaSuddenArrival before received) (hfiber : κ.FiberAtPole Path.arhatship) : G.WaaSuddenArrival before received ∧ G.WaaStreamWinner κ Path.arhatship fr ∧ G.WaaNonReturner κ Path.arhatship fr := by have hnonReturner : G.WaaNonReturner κ Path.arhatship fr := G.waaNonReturner_of_arhatFiber fr hfiber exact ⟨hsudden, hnonReturner.left, hnonReturner⟩ end Grid end WAA ===== FILE: WeldAndArrow/Doctrines/FactorsNegative.lean ===== /- ================================================================================ WeldAndArrow.Doctrines.FactorsNegative Negative witnesses for factor readings ================================================================================ -/ import WeldAndArrow.Doctrines.Factors import WeldAndArrow.Doctrines.CorrelationsNegative namespace WAA namespace FactorsNegative open Grid.DirectedConvention open Grid.DirectedConvention.BeingConvention /- ============================================================================== Hold/conceit boundary recovery ============================================================================== -/ def holdConceitGrid : Grid Nat where Being := Unit Call := Unit Response := Unit respondsTo _ _ := some () grade _ _ _ := 1 conditions _ _ := True def holdConceitCoarsening : BeingCoarsening holdConceitGrid Unit where proj _ := () def factorHoldReading : holdConceitGrid.FetterReading where provocationClass | Fetter.identityView, _ => True | _, _ => False def conceitReading : holdConceitGrid.FetterReading where provocationClass | Fetter.conceit, _ => True | _, _ => False def holdConceitWeld : holdConceitGrid.Weld := ⟨(), (), ()⟩ def holdConceitRun : List holdConceitGrid.Weld := [holdConceitWeld] theorem factor_reading_holds_view : holdConceitGrid.FactorHeld holdConceitCoarsening () factorHoldReading PathFactor.view holdConceitRun := by refine ⟨holdConceitWeld, ?_, rfl, rfl, ?_, ?_⟩ · simp [holdConceitRun] · exact Or.inl True.intro · dsimp [Grid.HasSelfPoleIndex, Grid.share, holdConceitGrid, holdConceitWeld, AtBot, shareBot] change ¬ (1 : Nat) ≤ 0 exact Nat.not_succ_le_zero 0 theorem conceit_reading_live : ∃ w ∈ holdConceitRun, holdConceitGrid.Actual w ∧ holdConceitCoarsening.InFiber () w ∧ conceitReading.provocationClass Fetter.conceit w.call ∧ holdConceitGrid.HasSelfPoleIndex w := by refine ⟨holdConceitWeld, ?_, rfl, rfl, True.intro, ?_⟩ · simp [holdConceitRun] · dsimp [Grid.HasSelfPoleIndex, Grid.share, holdConceitGrid, holdConceitWeld, AtBot, shareBot] change ¬ (1 : Nat) ≤ 0 exact Nat.not_succ_le_zero 0 abbrev HoldConceitGridData : Type := (Unit → Unit → Option Unit) × (Unit → Unit → Unit → Nat) × (holdConceitGrid.Weld → holdConceitGrid.Weld → Prop) def holdConceitGridData : HoldConceitGridData := (holdConceitGrid.respondsTo, holdConceitGrid.grade, holdConceitGrid.conditions) def factorHoldBoundary (_c : Unit) : Prop := True def conceitAsHoldBoundary (_c : Unit) : Prop := False /-- The same response/grade/share data support a live factor-hold reading and a live conceit reading. No function of the shared grid data recovers which boundary is in force; the hold/conceit line is supplied diagnosis-time data. -/ theorem no_hold_conceit_boundary_recovery : ¬ ∃ recover : HoldConceitGridData → Unit → Prop, recover holdConceitGridData = factorHoldBoundary ∧ recover holdConceitGridData = conceitAsHoldBoundary := by rintro ⟨recover, hfactor, hconceit⟩ have hheld : recover holdConceitGridData () := by rw [hfactor] exact True.intro have hnotHeld : ¬ recover holdConceitGridData () := by rw [hconceit] intro h cases h exact hnotHeld hheld theorem hold_conceit_boundary_underdetermined : holdConceitGrid.FactorHeld holdConceitCoarsening () factorHoldReading PathFactor.view holdConceitRun ∧ (∃ w ∈ holdConceitRun, holdConceitGrid.Actual w ∧ holdConceitCoarsening.InFiber () w ∧ conceitReading.provocationClass Fetter.conceit w.call ∧ holdConceitGrid.HasSelfPoleIndex w) ∧ ¬ ∃ recover : HoldConceitGridData → Unit → Prop, recover holdConceitGridData = factorHoldBoundary ∧ recover holdConceitGridData = conceitAsHoldBoundary := ⟨factor_reading_holds_view, conceit_reading_live, no_hold_conceit_boundary_recovery⟩ /- ============================================================================== Factor-order underdetermination ============================================================================== -/ inductive OrderCall | rites | first | second inductive OrderResponse | response def factorOrderGrid : Grid Nat where Being := Unit Call := OrderCall Response := OrderResponse respondsTo _ _ := some OrderResponse.response grade _ c _ := match c with | OrderCall.rites => 3 | OrderCall.first => 2 | OrderCall.second => 1 conditions _ _ := True def orderRitesWeld : factorOrderGrid.Weld := ⟨(), OrderCall.rites, OrderResponse.response⟩ def orderFirstWeld : factorOrderGrid.Weld := ⟨(), OrderCall.first, OrderResponse.response⟩ def orderSecondWeld : factorOrderGrid.Weld := ⟨(), OrderCall.second, OrderResponse.response⟩ def orderRitesRun : List factorOrderGrid.Weld := [orderRitesWeld] def orderFirstRun : List factorOrderGrid.Weld := [orderFirstWeld] def orderSecondRun : List factorOrderGrid.Weld := [orderSecondWeld] def orderRuns : List (List factorOrderGrid.Weld) := [orderRitesRun, orderFirstRun, orderSecondRun] def orderSerialReading : factorOrderGrid.FetterReading where provocationClass | Fetter.ritesGrasp, OrderCall.rites => True | Fetter.identityView, OrderCall.first => True | Fetter.sensualDesire, OrderCall.second => True | _, _ => False def orderReversedReading : factorOrderGrid.FetterReading where provocationClass | Fetter.ritesGrasp, OrderCall.rites => True | Fetter.identityView, OrderCall.second => True | Fetter.sensualDesire, OrderCall.first => True | _, _ => False abbrev FactorOrderSeenData : Type := (Unit → OrderCall → Option OrderResponse) × (Unit → OrderCall → OrderResponse → Nat) def serialOrderSeenData : FactorOrderSeenData := (factorOrderGrid.respondsTo, factorOrderGrid.grade) def reversedOrderSeenData : FactorOrderSeenData := (factorOrderGrid.respondsTo, factorOrderGrid.grade) theorem orderRites_shareDrop_serial : factorOrderGrid.ShareDropRunOnFactor orderSerialReading PathFactor.rites orderRitesRun := by refine ⟨{ tendency := 5 }, ?_⟩ constructor · refine Grid.ShareDropRun.cons ?_ ?_ ?_ · rfl · dsimp [Grid.IsShareDrop, Grid.share, factorOrderGrid, orderRitesWeld] constructor · change (3 : Nat) ≤ 5 decide · change ¬ (5 : Nat) ≤ 3 decide · exact Grid.ShareDropRun.nil _ · intro w hmem simp [orderRitesRun] at hmem subst w exact True.intro theorem orderView_shareDrop_serial : factorOrderGrid.ShareDropRunOnFactor orderSerialReading PathFactor.view orderFirstRun := by refine ⟨{ tendency := 5 }, ?_⟩ constructor · refine Grid.ShareDropRun.cons ?_ ?_ ?_ · rfl · dsimp [Grid.IsShareDrop, Grid.share, factorOrderGrid, orderFirstWeld] constructor · change (2 : Nat) ≤ 5 decide · change ¬ (5 : Nat) ≤ 2 decide · exact Grid.ShareDropRun.nil _ · intro w hmem simp [orderFirstRun] at hmem subst w exact Or.inl True.intro theorem orderResolve_shareDrop_serial : factorOrderGrid.ShareDropRunOnFactor orderSerialReading PathFactor.resolve orderSecondRun := by refine ⟨{ tendency := 5 }, ?_⟩ constructor · refine Grid.ShareDropRun.cons ?_ ?_ ?_ · rfl · dsimp [Grid.IsShareDrop, Grid.share, factorOrderGrid, orderSecondWeld] constructor · change (1 : Nat) ≤ 5 decide · change ¬ (5 : Nat) ≤ 1 decide · exact Grid.ShareDropRun.nil _ · intro w hmem simp [orderSecondRun] at hmem subst w exact Or.inl True.intro theorem orderSerial_runsExhibit : factorOrderGrid.RunsExhibitFactorOrder orderSerialReading orderRuns := by exact ⟨orderRitesRun, orderFirstRun, orderSecondRun, rfl, orderRites_shareDrop_serial, orderView_shareDrop_serial, orderResolve_shareDrop_serial⟩ theorem orderReversed_not_runsExhibit : ¬ factorOrderGrid.RunsExhibitFactorOrder orderReversedReading orderRuns := by rintro ⟨ritesRun, viewRun, resolveRun, hseq, _hrites, hview, _hresolve⟩ dsimp [orderRuns] at hseq cases hseq rcases hview with ⟨_before, _hdrop, hall⟩ have hclass : PathFactor.blockerClass orderReversedReading PathFactor.view orderFirstWeld.call := hall orderFirstWeld (by simp [orderFirstRun]) dsimp [PathFactor.blockerClass, orderReversedReading, orderFirstWeld] at hclass rcases hclass with hclass | hclass <;> cases hclass /-- The same seen response and grade data do not determine the factor order: one supplied reading sees the runs as rites-before-view-before-resolve, while another reverses the view/resolve diagnosis on the same calls. -/ theorem seen_run_underdetermines_factorOrder : serialOrderSeenData = reversedOrderSeenData ∧ factorOrderGrid.RunsExhibitFactorOrder orderSerialReading orderRuns ∧ ¬ factorOrderGrid.RunsExhibitFactorOrder orderReversedReading orderRuns := ⟨rfl, orderSerial_runsExhibit, orderReversed_not_runsExhibit⟩ /- ============================================================================== Lineage-switching witness ============================================================================== -/ inductive LineageStage | theravada (p : Path) | bulls (b : Grid.BullStage) def lineageGrid : Grid Nat where Being := Unit Call := Unit Response := Unit respondsTo _ _ := some () grade _ _ _ := 0 conditions _ _ := True def lineageWeld : lineageGrid.Weld := ⟨(), (), ()⟩ def lineageRun : List lineageGrid.Weld := [lineageWeld] def theravadaFactorScheme : lineageGrid.StageScheme LineageStage where proj _ := LineageStage.theravada Path.onceReturn def bullsLineageScheme : lineageGrid.StageScheme LineageStage where proj _ := LineageStage.bulls Grid.BullStage.taming abbrev LineageSeenData : Type := (Unit → Unit → Option Unit) × (Unit → Unit → Unit → Nat) def lineageSeenData : LineageSeenData := (lineageGrid.respondsTo, lineageGrid.grade) def theravadaStageTag (_p : Unit) : LineageStage := LineageStage.theravada Path.onceReturn def bullsStageTag (_p : Unit) : LineageStage := LineageStage.bulls Grid.BullStage.taming theorem no_lineage_stage_recovery : ¬ ∃ recover : LineageSeenData → Unit → LineageStage, recover lineageSeenData = theravadaStageTag ∧ recover lineageSeenData = bullsStageTag := by rintro ⟨recover, htheravada, hbulls⟩ have htheravadaTag : recover lineageSeenData () = LineageStage.theravada Path.onceReturn := by rw [htheravada] rfl have hbullsTag : recover lineageSeenData () = LineageStage.bulls Grid.BullStage.taming := by rw [hbulls] rfl rw [htheravadaTag] at hbullsTag cases hbullsTag /-- Specializing `CorrelationsNegative.no_stage_boundary_recovery`: the same grid and run can be re-diagnosed under a Theravada-shaped factor tag or a Bulls-shaped tag. Switching lineage changes the supplied reading in force, not the welds seen by the grid. -/ theorem lineage_underdetermined_by_seen_run : lineageRun = [lineageWeld] ∧ theravadaFactorScheme.proj () = LineageStage.theravada Path.onceReturn ∧ bullsLineageScheme.proj () = LineageStage.bulls Grid.BullStage.taming ∧ theravadaFactorScheme.proj () ≠ bullsLineageScheme.proj () ∧ ¬ ∃ recover : LineageSeenData → Unit → LineageStage, recover lineageSeenData = theravadaStageTag ∧ recover lineageSeenData = bullsStageTag := by constructor · rfl · constructor · rfl · constructor · rfl · constructor · intro h cases h · exact no_lineage_stage_recovery end FactorsNegative end WAA ===== FILE: WeldAndArrow/Doctrines/Faith.lean ===== /- ================================================================================ WeldAndArrow.Doctrines.Faith Testimonial abstraction of the sraddha conditional ================================================================================ Faith is modeled as an arbitrary attitude operator on propositions. The grid never derives it and the principle below is held only as an antecedent: faith in a fully enlightened being transmits truth to that being's recorded utterances. Reading and motivation: Identification/Commentary.lean, C.4. -/ import WeldAndArrow.Doctrines.Sraddha namespace WAA namespace Grid namespace DirectedConvention variable {Contrib : Type} [PreorderBot Contrib] variable (G : Grid Contrib) /- ============================================================================== Faith as testimonial truth-transmission ============================================================================== -/ /-- A path claim records the local physician sentence: for this prior configuration, this delivered deed closes shortfall at this reception. -/ structure WaaPathClaim where before : Config Contrib deed : G.Weld reception : G.Weld /-- The object language for path claims. Its truth condition is exactly local shortfall closure; the tier is ignored because the claim is not a separate/fuse distinction. -/ def waaPathClaimLanguage : ClaimLanguage G where Claim := WaaPathClaim G Holds := fun _ claim => ShortfallClosedAt G claim.before claim.deed claim.reception /-- A lawless faith attitude supports testimony only when paired with this principle: faith in a fully enlightened being makes that being's recorded utterances true at their offered tier. -/ def WaaFaithPrinciple (L : ClaimLanguage G) (Faith : Prop → Prop) : Prop := ∀ b : G.Being, Faith (WaaFullyEnlightened G b) → ∀ u : RecordedUtterance G L, u.weld.agent = b → u.FitsOfferedTier /-- Direct use of the faith principle: what a trusted fully enlightened speaker says is true, in the existing offered-tier sense. -/ theorem waa_says_true_of_faith {L : ClaimLanguage G} {Faith : Prop → Prop} (hprinciple : WaaFaithPrinciple G L Faith) {b : G.Being} (hfaith : Faith (WaaFullyEnlightened G b)) (u : RecordedUtterance G L) (hutter : u.weld.agent = b) : u.FitsOfferedTier := hprinciple b hfaith u hutter /-- On own-deed path claims, the old direct route already supplies truth: `WaaFullyEnlightened` closes shortfall for the being's own delivered deeds, no matter who records the claim. -/ theorem fitsOfferedTier_of_waaFullyEnlightened_ownDeed {b : G.Being} (h : WaaFullyEnlightened G b) (u : RecordedUtterance G (waaPathClaimLanguage G)) (hdeed : u.content.deed.agent = b) : u.FitsOfferedTier := by change (waaPathClaimLanguage G).TrueAt u.offeredAt u.content dsimp [waaPathClaimLanguage, ClaimLanguage.TrueAt] exact h.right u.content.before u.content.deed u.content.reception hdeed /-- The testimonial route to the sraddha landing. Unlike the direct route in `Sraddha`, the deed need not be the speaker's own deed; the principle covers what the faith-object says. -/ theorem waa_path_landing_of_faithPrinciple {Faith : Prop → Prop} {b : G.Being} (hprinciple : WaaFaithPrinciple G (waaPathClaimLanguage G) Faith) (hfaith : Faith (WaaFullyEnlightened G b)) (u : RecordedUtterance G (waaPathClaimLanguage G)) (hutter : u.weld.agent = b) (hdel : DeliveredTo G u.content.deed u.content.reception) (hctx : WaaAversionContext G u.content.before u.content.reception) : HasShareDropLanding G u.content.before u.content.deed := by have hfit : u.FitsOfferedTier := hprinciple b hfaith u hutter have hclosed : ShortfallClosedAt G u.content.before u.content.deed u.content.reception := by change (waaPathClaimLanguage G).TrueAt u.offeredAt u.content at hfit simpa [waaPathClaimLanguage, ClaimLanguage.TrueAt] using hfit exact hclosed hctx.liveBefore hdel /-- The faith-mediated fourth-truth ought as an implication type only. -/ def WaaFaithOught (Faith : Prop → Prop) (b : G.Being) (u : RecordedUtterance G (waaPathClaimLanguage G)) : Prop := WaaFaithPrinciple G (waaPathClaimLanguage G) Faith → Faith (WaaFullyEnlightened G b) → u.weld.agent = b → DeliveredTo G u.content.deed u.content.reception → WaaAversionContext G u.content.before u.content.reception → HasShareDropLanding G u.content.before u.content.deed /-- The grid proves only the conditional: principle, faith, testimony, delivery, and live aversion imply the landing. -/ theorem waaFaithOught_conditional (Faith : Prop → Prop) (b : G.Being) (u : RecordedUtterance G (waaPathClaimLanguage G)) : WaaFaithOught G Faith b u := by intro hprinciple hfaith hutter hdel hctx exact waa_path_landing_of_faithPrinciple G hprinciple hfaith u hutter hdel hctx end DirectedConvention end Grid end WAA ===== FILE: WeldAndArrow/Doctrines/FaithNegative.lean ===== /- ================================================================================ WeldAndArrow.Doctrines.FaithNegative Negative witnesses for the abstracted faith principle ================================================================================ Two facts keep `WaaFaithPrinciple` honest as a faith-shaped antecedent: 1. `waaFaithPrinciple_id_fails`: even taking `WaaFullyEnlightened G b` as a premise does not yield the principle. A fully enlightened buddha can utter a path claim about another being's deed, and nothing in the enlightenment proposition makes that claim true. 2. `waaFaithPrinciple_trivial_fails`: free faith (`Faith := fun _ => True`) does not supply truth-transmission either. Together with `SraddhaNegative`, the abstraction adds no assertion the old bundling avoided. -/ import WeldAndArrow.Doctrines.Faith namespace WAA namespace FaithNegative open Grid open Grid.DirectedConvention inductive Being | buddha | disciple | receiver inductive Call | call inductive Response | response /-- A grid in which the buddha is fully enlightened for free: its own deeds are never delivered, so shortfall closure for its own deeds is vacuous. The disciple's deed is delivered to a receiver whose live share does not drop. -/ def grid : Grid Nat where Being := Being Call := Call Response := Response respondsTo _ _ := some Response.response grade b _ _ := match b with | .buddha => 0 | .disciple => 1 | .receiver => 1 conditions deed reception := deed.agent = Being.disciple ∧ reception.agent = Being.receiver def liveBefore : Config Nat := { tendency := 1 } def discipleDeed : grid.Weld := ⟨Being.disciple, Call.call, Response.response⟩ def reception : grid.Weld := ⟨Being.receiver, Call.call, Response.response⟩ def buddhaWeld : grid.Weld := ⟨Being.buddha, Call.call, Response.response⟩ theorem liveBefore_not_atBot : ¬ AtBot liveBefore.tendency := by intro h exact Nat.not_succ_le_zero 0 h theorem delivered : DeliveredTo grid discipleDeed reception := ⟨rfl, rfl⟩ theorem buddhaWeld_actual : grid.Actual buddhaWeld := rfl theorem buddha_responsiveTerminus : grid.ResponsiveTerminus Being.buddha := by constructor · intro _c exact ⟨Response.response, rfl⟩ · intro _c _r _hresp exact Nat.le_refl 0 /-- The buddha's own deeds are never delivered in this grid, so the shortfall closure conjunct holds vacuously. -/ theorem buddha_waaFullyEnlightened : WaaFullyEnlightened grid Being.buddha := by refine ⟨buddha_responsiveTerminus, ?_⟩ intro before deed reception hdeed _hlive hdel obtain ⟨hdisciple, _hreceiver⟩ := hdel rw [hdeed] at hdisciple exact Being.noConfusion hdisciple theorem not_hasShareDropLanding : ¬ HasShareDropLanding grid liveBefore discipleDeed := by rintro ⟨received, hland⟩ have hreceiver : received.agent = Being.receiver := hland.left.left.right have hdrop : Strict (grid.share received) liveBefore.tendency := hland.right have hstrict : Strict (1 : Nat) 1 := by simpa [grid, Grid.share, liveBefore, hreceiver] using hdrop exact strict_irrefl (1 : Nat) hstrict /-- The buddha's recorded path claim about the disciple's deed is false: the delivered deed does not land as a share-drop for the live receiver context. -/ def falseClaim : RecordedUtterance grid (waaPathClaimLanguage grid) where weld := buddhaWeld actual := buddhaWeld_actual offeredAt := Tier.floor content := ⟨liveBefore, discipleDeed, reception⟩ theorem falseClaim_not_fitsOfferedTier : ¬ falseClaim.FitsOfferedTier := by intro hfit change (waaPathClaimLanguage grid).TrueAt falseClaim.offeredAt falseClaim.content at hfit dsimp [waaPathClaimLanguage, ClaimLanguage.TrueAt, falseClaim, ShortfallClosedAt] at hfit exact not_hasShareDropLanding (hfit liveBefore_not_atBot delivered) /-- Taking-as-premise faith does not validate the unrestricted principle: the enlightenment proposition itself is in hand, but the uttered path claim about another being's deed is still false. -/ theorem waaFaithPrinciple_id_fails : ¬ WaaFaithPrinciple grid (waaPathClaimLanguage grid) (fun P => P) := by intro hFP exact falseClaim_not_fitsOfferedTier (hFP Being.buddha buddha_waaFullyEnlightened falseClaim rfl) /-- Nor does free faith: an operator holding everywhere, without the truth-transmission principle, lands nothing. -/ theorem waaFaithPrinciple_trivial_fails : ¬ WaaFaithPrinciple grid (waaPathClaimLanguage grid) (fun _ => True) := by intro hFP exact falseClaim_not_fitsOfferedTier (hFP Being.buddha trivial falseClaim rfl) end FaithNegative end WAA ===== FILE: WeldAndArrow/Doctrines/Fetters.lean ===== /- ================================================================================ WeldAndArrow.Doctrines.Fetters The ten fetters and path-scheme readings ================================================================================ -/ import WeldAndArrow.Doctrines.Correlations namespace WAA /- ============================================================================== Data ============================================================================== -/ inductive Fetter | identityView | doubt | ritesGrasp | sensualDesire | illWill | formDesire | formlessDesire | conceit | restlessness | ignorance inductive FetterClass | lower | higher inductive Path | streamEntry | onceReturn | nonReturn | arhatship inductive FetterRegister | field namespace Fetter def kind : Fetter → FetterClass | .identityView | .doubt | .ritesGrasp | .sensualDesire | .illWill => .lower | .formDesire | .formlessDesire | .conceit | .restlessness | .ignorance => .higher def abandonedAt : Fetter → Path | .identityView => .streamEntry | .doubt => .streamEntry | .ritesGrasp => .streamEntry | .sensualDesire => .nonReturn | .illWill => .nonReturn | .formDesire => .arhatship | .formlessDesire => .arhatship | .conceit => .arhatship | .restlessness => .arhatship | .ignorance => .arhatship /-- Fetters are standing field-register tendencies in this reading. -/ def register (_f : Fetter) : FetterRegister := .field theorem identityView_class : kind identityView = FetterClass.lower := rfl theorem ignorance_class : kind ignorance = FetterClass.higher := rfl theorem identityView_abandonedAt : abandonedAt identityView = Path.streamEntry := rfl theorem doubt_abandonedAt : abandonedAt doubt = Path.streamEntry := rfl theorem ritesGrasp_abandonedAt : abandonedAt ritesGrasp = Path.streamEntry := rfl theorem sensualDesire_abandonedAt : abandonedAt sensualDesire = Path.nonReturn := rfl theorem illWill_abandonedAt : abandonedAt illWill = Path.nonReturn := rfl theorem formDesire_abandonedAt : abandonedAt formDesire = Path.arhatship := rfl theorem formlessDesire_abandonedAt : abandonedAt formlessDesire = Path.arhatship := rfl theorem conceit_abandonedAt : abandonedAt conceit = Path.arhatship := rfl theorem restlessness_abandonedAt : abandonedAt restlessness = Path.arhatship := rfl theorem ignorance_abandonedAt : abandonedAt ignorance = Path.arhatship := rfl theorem identityView_register : register identityView = FetterRegister.field := rfl theorem conceit_register : register conceit = FetterRegister.field := rfl end Fetter /- ============================================================================== Checked path-scheme readings ============================================================================== -/ namespace Grid open DirectedConvention open DirectedConvention.BeingConvention variable {Contrib : Type} [PreorderBot Contrib] variable (G : Grid Contrib) /-- The four paths are another diagnosis-time coarsening. -/ abbrev PathScheme : Type := G.StageScheme Path /-- The model-supplied assignment of each fetter to a class of provocations. The grid cannot recover "sensual call" or "identity-view call" unaided. -/ structure FetterReading where provocationClass : Fetter → G.Call → Prop /-- The model-supplied assignment of fine tags to the speech/thought region. The grid cannot recover "speech/thought tag" or "instinctual tag" unaided; the boundary is diagnosis-time data, never grid-carried anatomy. -/ structure SomaReading where speechThoughtTag : G.Being → Prop /-- A fetter is cut in a fiber when that fiber reads at pole on the fetter's supplied provocation class. -/ def FetterCut {Macro : Type} (κ : BeingCoarsening G Macro) (b : Macro) (fr : G.FetterReading) (f : Fetter) : Prop := κ.FiberAtPoleOn b (fr.provocationClass f) /-- A fetter is cut within a tag-region when the fiber reads at pole on the fetter's provocation class restricted to that region. Cessation of enactment in the rectangle; no anti-fetter is possessed. -/ def FetterCutWithin {Macro : Type} (κ : BeingCoarsening G Macro) (b : Macro) (fr : G.FetterReading) (f : Fetter) (ts : G.Being → Prop) : Prop := κ.FiberAtPoleOnWithin b (fr.provocationClass f) ts theorem fetterCutWithin_univ_iff_fetterCut {Macro : Type} (κ : BeingCoarsening G Macro) (b : Macro) (fr : G.FetterReading) (f : Fetter) : G.FetterCutWithin κ b fr f (fun _ => True) ↔ G.FetterCut κ b fr f := κ.fiberAtPoleOnWithin_univTags_iff b (fr.provocationClass f) /-- A seen run is quiet on a class. This is display over a finite track record, not a claim about fresh calls. -/ def RunQuiet {Macro : Type} (κ : BeingCoarsening G Macro) (b : Macro) (cs : G.Call → Prop) (run : List G.Weld) : Prop := ∀ w : G.Weld, w ∈ run → G.Actual w → κ.InFiber b w → cs w.call → AtBot (G.share w) /-- A seen run is quiet on a call-class within a tag-region. This remains finite display, not a claim about fresh calls or fresh tags. -/ def RunQuietWithin {Macro : Type} (κ : BeingCoarsening G Macro) (b : Macro) (cs : G.Call → Prop) (ts : G.Being → Prop) (run : List G.Weld) : Prop := ∀ w : G.Weld, w ∈ run → G.Actual w → κ.InFiber b w → cs w.call → ts w.agent → AtBot (G.share w) theorem runQuiet_of_fetterCut {Macro : Type} {κ : BeingCoarsening G Macro} {b : Macro} {fr : G.FetterReading} {f : Fetter} {run : List G.Weld} (h : G.FetterCut κ b fr f) : G.RunQuiet κ b (fr.provocationClass f) run := fun w _hmem hactual hfiber hclass => h w hactual hfiber hclass theorem runQuietWithin_of_fetterCutWithin {Macro : Type} {κ : BeingCoarsening G Macro} {b : Macro} {fr : G.FetterReading} {f : Fetter} {ts : G.Being → Prop} {run : List G.Weld} (h : G.FetterCutWithin κ b fr f ts) : G.RunQuietWithin κ b (fr.provocationClass f) ts run := fun w _hmem hactual hfiber hclass htag => h w hactual hfiber hclass htag /-- The forward-looking guarantee as a conditional: a regime may promote a finite class-quiet track record to a whole-fiber cut, but the grid does not discharge that antecedent. -/ def WaaIrreversibleRegime {Macro : Type} (κ : BeingCoarsening G Macro) (b : Macro) (fr : G.FetterReading) (run : List G.Weld) : Prop := ∀ f : Fetter, G.RunQuiet κ b (fr.provocationClass f) run → G.FetterCut κ b fr f theorem waaIrreversibleRegime_conditional {Macro : Type} {κ : BeingCoarsening G Macro} {b : Macro} {fr : G.FetterReading} {run : List G.Weld} {f : Fetter} (hregime : G.WaaIrreversibleRegime κ b fr run) (hseen : G.RunQuiet κ b (fr.provocationClass f) run) : G.FetterCut κ b fr f := hregime f hseen /-- The same forward-looking guarantee restricted to a supplied tag-region. The guarantee remains conditional; the grid does not infer the regime. -/ def WaaIrreversibleRegimeWithin {Macro : Type} (κ : BeingCoarsening G Macro) (b : Macro) (fr : G.FetterReading) (ts : G.Being → Prop) (run : List G.Weld) : Prop := ∀ f : Fetter, G.RunQuietWithin κ b (fr.provocationClass f) ts run → G.FetterCutWithin κ b fr f ts theorem waaIrreversibleRegimeWithin_conditional {Macro : Type} {κ : BeingCoarsening G Macro} {b : Macro} {fr : G.FetterReading} {ts : G.Being → Prop} {run : List G.Weld} {f : Fetter} (hregime : G.WaaIrreversibleRegimeWithin κ b fr ts run) (hseen : G.RunQuietWithin κ b (fr.provocationClass f) ts run) : G.FetterCutWithin κ b fr f ts := hregime f hseen end Grid namespace Path /-- Which named fetters have been abandoned at a path. Once-return adds no new cut classes; it is retained as a path tag for the prose weakening clause. `Doctrines/Factors.lean` gives that weakening checked content as `WaaResolveAttenuation`. -/ def cutsFetter : Path → Fetter → Prop | .streamEntry, f => Fetter.abandonedAt f = .streamEntry | .onceReturn, f => Fetter.abandonedAt f = .streamEntry | .nonReturn, f => Fetter.abandonedAt f = .streamEntry ∨ Fetter.abandonedAt f = .nonReturn | .arhatship, _ => True /-- The call-class quieted by a path under a supplied fetter reading. The arhat class is total, closing the family back into `FiberAtPole`. -/ def cutClasses {Contrib : Type} [PreorderBot Contrib] {G : Grid Contrib} (fr : G.FetterReading) : Path → G.Call → Prop | .streamEntry, c => ∃ f : Fetter, cutsFetter .streamEntry f ∧ fr.provocationClass f c | .onceReturn, c => ∃ f : Fetter, cutsFetter .onceReturn f ∧ fr.provocationClass f c | .nonReturn, c => ∃ f : Fetter, cutsFetter .nonReturn f ∧ fr.provocationClass f c | .arhatship, _ => True theorem streamEntry_cuts_identityView : cutsFetter streamEntry Fetter.identityView := rfl theorem streamEntry_cuts_doubt : cutsFetter streamEntry Fetter.doubt := rfl theorem nonReturn_cuts_sensualDesire : cutsFetter nonReturn Fetter.sensualDesire := Or.inr rfl theorem nonReturn_cuts_illWill : cutsFetter nonReturn Fetter.illWill := Or.inr rfl theorem arhatship_cuts_ignorance : cutsFetter arhatship Fetter.ignorance := True.intro theorem streamEntry_cutClasses_subset_onceReturn {Contrib : Type} [PreorderBot Contrib] {G : Grid Contrib} (fr : G.FetterReading) : ∀ c : G.Call, cutClasses fr streamEntry c → cutClasses fr onceReturn c := by intro c h rcases h with ⟨f, hf, hc⟩ exact ⟨f, hf, hc⟩ theorem onceReturn_cutClasses_subset_nonReturn {Contrib : Type} [PreorderBot Contrib] {G : Grid Contrib} (fr : G.FetterReading) : ∀ c : G.Call, cutClasses fr onceReturn c → cutClasses fr nonReturn c := by intro c h rcases h with ⟨f, hf, hc⟩ exact ⟨f, Or.inl hf, hc⟩ theorem nonReturn_cutClasses_subset_arhatship {Contrib : Type} [PreorderBot Contrib] {G : Grid Contrib} (fr : G.FetterReading) : ∀ c : G.Call, cutClasses fr nonReturn c → cutClasses fr arhatship c := fun _c _h => True.intro end Path namespace Fetter theorem kind_lower_iff_cut_by_nonReturn (f : Fetter) : kind f = FetterClass.lower ↔ Path.cutsFetter Path.nonReturn f := by cases f <;> constructor <;> intro h · exact Or.inl rfl · rfl · exact Or.inl rfl · rfl · exact Or.inl rfl · rfl · exact Or.inr rfl · rfl · exact Or.inr rfl · rfl · cases h · rcases h with h | h <;> cases h · cases h · rcases h with h | h <;> cases h · cases h · rcases h with h | h <;> cases h · cases h · rcases h with h | h <;> cases h · cases h · rcases h with h | h <;> cases h end Fetter namespace Grid open DirectedConvention open DirectedConvention.BeingConvention variable {Contrib : Type} [PreorderBot Contrib] variable (G : Grid Contrib) /-- Class quietness is monotone under subclass restriction. -/ theorem classQuiet_mono {Macro : Type} {κ : BeingCoarsening G Macro} {b : Macro} {cs ds : G.Call → Prop} (h : κ.FiberAtPoleOn b cs) (hsub : ∀ c : G.Call, ds c → cs c) : κ.FiberAtPoleOn b ds := κ.fiberAtPoleOn_mono h hsub /-- Quiet on the total class is exactly ordinary `FiberAtPole`. -/ theorem fiberAtPole_iff_classQuiet_univ {Macro : Type} (κ : BeingCoarsening G Macro) (b : Macro) : κ.FiberAtPole b ↔ κ.FiberAtPoleOn b (fun _ => True) := (κ.fiberAtPoleOn_univ_iff b).symm /-- Path quietness inside a supplied tag-region: the same path call-class lattice, now restricted to a fine tag-class as well. -/ def PathQuietWithin {Macro : Type} (κ : BeingCoarsening G Macro) (b : Macro) (fr : G.FetterReading) (p : Path) (ts : G.Being → Prop) : Prop := κ.FiberAtPoleOnWithin b (Path.cutClasses fr p) ts /-- The arhat path-class is total, so path quietness at arhatship is ordinary fiber-at-pole typing. -/ theorem arhatPathQuiet_iff_fiberAtPole {κ : G.PathScheme} (fr : G.FetterReading) : κ.FiberAtPoleOn Path.arhatship (Path.cutClasses fr Path.arhatship) ↔ κ.FiberAtPole Path.arhatship := by change κ.FiberAtPoleOn Path.arhatship (fun _ => True) ↔ κ.FiberAtPole Path.arhatship exact (G.fiberAtPole_iff_classQuiet_univ κ Path.arhatship).symm theorem all_fetters_cut_at_arhatFiber {κ : G.PathScheme} (fr : G.FetterReading) (h : κ.FiberAtPole Path.arhatship) : ∀ f : Fetter, G.FetterCut κ Path.arhatship fr f := fun _f w hactual hfiber _hclass => h w hactual hfiber /-- At arhatship the call-class is total, so path quietness within a region is exactly tag-restricted fiber-at-pole. -/ theorem arhatPathQuietWithin_iff_fiberAtPoleWithin {κ : G.PathScheme} (fr : G.FetterReading) (ts : G.Being → Prop) : G.PathQuietWithin κ Path.arhatship fr Path.arhatship ts ↔ κ.FiberAtPoleWithin Path.arhatship ts := by change κ.FiberAtPoleOnWithin Path.arhatship (fun _ => True) ts ↔ κ.FiberAtPoleWithin Path.arhatship ts exact κ.fiberAtPoleOnWithin_univCalls_iff Path.arhatship ts /-- At total calls and total tags, the two-axis path lattice closes back to ordinary `FiberAtPole`: the top point adds no new predicate. The word "buddha" belongs only to the layered reading above this neutral cut: `FettersNegative.total_cut_carries_no_function` shows that the top point alone carries no function conjunct, while `FettersNegative.total_cut_with_function_not_waaFullyEnlightened` and `waaFullyEnlightened_of_responsiveTerminus_of_undelivered` keep effectiveness regime-relational. Arhat reading remains `PathQuietWithin` at a supplied `SomaReading.speechThoughtTag`; vasana is residual clench in the complement region after the call-axis closes. -/ theorem arhatWithin_univTags_iff_fiberAtPole {κ : G.PathScheme} (fr : G.FetterReading) : G.PathQuietWithin κ Path.arhatship fr Path.arhatship (fun _ => True) ↔ κ.FiberAtPole Path.arhatship := by change κ.FiberAtPoleOnWithin Path.arhatship (fun _ => True) (fun _ => True) ↔ κ.FiberAtPole Path.arhatship exact κ.fiberAtPoleOnWithin_univ_univ_iff Path.arhatship /-- If a class-restricted cut holds, no actual weld in that fiber and class carries a live self-pole index. -/ theorem classQuiet_no_clench_in_class {Macro : Type} {κ : BeingCoarsening G Macro} {b : Macro} {fr : G.FetterReading} {f : Fetter} {w : G.Weld} (h : G.FetterCut κ b fr f) (hactual : G.Actual w) (hfiber : κ.InFiber b w) (hclass : fr.provocationClass f w.call) : ¬ G.HasSelfPoleIndex w := κ.no_live_index_under_fiberAtPoleOn h hactual hfiber hclass /-- Stream-entry removes identity-view when the arhat fiber is live at pole: pole-fiber typing refutes the self-apt tag directly. -/ theorem identityView_excluded_at_arhatFiber {κ : G.PathScheme} (h : κ.LiveFiberAtPole Path.arhatship) : ¬ κ.SelfAptTag Path.arhatship := κ.liveFiberAtPole_not_selfAptTag h /-- Identity-view is excluded in the supplied speech/thought region once that region is live at pole. -/ theorem identityView_excluded_at_speechThoughtRegion {Macro : Type} {κ : BeingCoarsening G Macro} {b : Macro} (sr : G.SomaReading) (h : κ.LiveFiberAtPoleWithin b sr.speechThoughtTag) : ¬ κ.SelfAptTagWithin b sr.speechThoughtTag := κ.liveFiberAtPoleWithin_not_selfAptTagWithin h /-- Conceit as a live self-share is refuted fiber-wide by `FiberAtPole`. -/ theorem conceit_excluded_at_arhatFiber {κ : G.PathScheme} (h : κ.FiberAtPole Path.arhatship) : ∀ w : G.Weld, G.Actual w → κ.InFiber Path.arhatship w → ¬ G.HasSelfPoleIndex w := fun _w hactual hfiber => κ.no_live_index_under_fiberAtPole h hactual hfiber /-- Conceit as a live self-share is refuted throughout the supplied region by tag-restricted fiber-at-pole. -/ theorem conceit_excluded_within {Macro : Type} {κ : BeingCoarsening G Macro} {b : Macro} {ts : G.Being → Prop} (h : κ.FiberAtPoleWithin b ts) : ∀ w : G.Weld, G.Actual w → κ.InFiber b w → ts w.agent → ¬ G.HasSelfPoleIndex w := fun _w hactual hfiber htag => κ.no_live_index_under_fiberAtPoleOnWithin h hactual hfiber True.intro htag /-- If every fine tag under the arhat fiber is terminus-typed, the whole actual fiber is at pole. -/ theorem arhatFiber_of_termini {κ : G.PathScheme} (h : ∀ p : G.Being, κ.proj p = Path.arhatship → G.Terminus p) : κ.FiberAtPole Path.arhatship := κ.fiberAtPole_of_fiber_termini h /-- Doctrine-facing name for region-restricted termini sufficiency. -/ theorem regionFiber_of_termini {Macro : Type} {κ : BeingCoarsening G Macro} {b : Macro} {ts : G.Being → Prop} (h : ∀ p : G.Being, κ.proj p = b → ts p → G.Terminus p) : κ.FiberAtPoleWithin b ts := κ.fiberAtPoleWithin_of_class_termini h /-- The speech/thought region in the register-clock witness: register `0`. The boundary is supplied data, not recovered from the grid. -/ def registerSpeechThoughtTag (p : registerClockGrid.Being) : Prop := p = (0 : Nat) theorem registerSpeechThoughtTag_cut : registerClockCoarsening.FiberAtPoleWithin () registerSpeechThoughtTag := by intro w _hactual _hfiber _hclass htag cases w with | mk agent call response => dsimp [registerSpeechThoughtTag] at htag rw [htag] dsimp [Grid.share, registerClockGrid, AtBot, shareBot] show (0 : Nat) ≤ 0 decide theorem registerSpeechThoughtTag_mounts : registerClockGrid.MountsSomewhere (0 : Nat) := ⟨(), ⟨(1 : Nat), rfl⟩⟩ def registerUncutWeld : registerClockGrid.Weld := ⟨(1 : Nat), (), (2 : Nat)⟩ theorem registerUncutWeld_live_index : registerClockGrid.HasSelfPoleIndex registerUncutWeld := by dsimp [Grid.HasSelfPoleIndex, Grid.share, registerClockGrid, registerUncutWeld, AtBot, shareBot] change ¬ (1 : Nat) ≤ 0 exact Nat.not_succ_le_zero 0 /-- Region cuts constrain share, not function. In the register-clock witness, the cut region mounts a response at the pole, while an uncut tag outside the region also mounts a response and carries a live self-pole index. -/ theorem unquiet_region_still_functions_witness : registerClockCoarsening.FiberAtPoleWithin () registerSpeechThoughtTag ∧ registerClockGrid.MountsSomewhere (0 : Nat) ∧ ∃ p : registerClockGrid.Being, ¬ registerSpeechThoughtTag p ∧ registerClockGrid.MountsSomewhere p ∧ ∃ w : registerClockGrid.Weld, registerClockGrid.Actual w ∧ w.agent = p ∧ registerClockGrid.HasSelfPoleIndex w := ⟨registerSpeechThoughtTag_cut, registerSpeechThoughtTag_mounts, ⟨(1 : Nat), by intro h dsimp [registerSpeechThoughtTag] at h exact Nat.succ_ne_zero 0 h, ⟨(), ⟨(2 : Nat), rfl⟩⟩, ⟨registerUncutWeld, rfl, rfl, registerUncutWeld_live_index⟩⟩⟩ end Grid end WAA ===== FILE: WeldAndArrow/Doctrines/FettersNegative.lean ===== /- ================================================================================ WeldAndArrow.Doctrines.FettersNegative Fresh-call underdetermination for run-assigned fetter tags ================================================================================ -/ import WeldAndArrow.Doctrines.Fetters import WeldAndArrow.Doctrines.SraddhaNegative namespace WAA namespace FettersNegative open Grid.DirectedConvention open Grid.DirectedConvention.BeingConvention /- ============================================================================== The total-rectangle cut carries no function conjunct ============================================================================== -/ /-- A one-tag all-stone grid: no being mounts any response at any call. -/ def stoneGrid : Grid Nat where Being := Unit Call := Unit Response := Unit respondsTo _ _ := none grade _ _ _ := 0 conditions _ _ := False def stoneCoarsening : BeingCoarsening stoneGrid Unit where proj _ := () theorem stone_fiber_total_cut : stoneCoarsening.FiberAtPoleOnWithin () (fun _ => True) (fun _ => True) := by intro w hactual _hfiber _hclass _htag cases w with | mk agent call response => cases agent cases call cases response change (none : Option Unit) = some () at hactual cases hactual theorem stone_fiber_all_stone : ∀ p : stoneGrid.Being, stoneCoarsening.proj p = () → stoneGrid.Stone p := by intro p _hp c hmount rcases hmount with ⟨r, hresp⟩ cases p cases c cases r change (none : Option Unit) = some () at hresp cases hresp theorem stone_fiber_not_sentient : ¬ stoneCoarsening.SentientTag () := (stoneCoarsening.not_sentientTag_iff_fiber_all_stone ()).mpr stone_fiber_all_stone theorem stone_fiber_atPole : stoneCoarsening.FiberAtPole () := (stoneCoarsening.fiberAtPoleOnWithin_univ_univ_iff ()).mp stone_fiber_total_cut theorem stone_fiber_not_live : ¬ stoneCoarsening.LiveFiberAtPole () := by intro hlive exact stone_fiber_not_sentient ((stoneCoarsening.sentientTag_iff_actualFiberInhabited ()).mpr hlive.left) /-- The lattice's top point is share-only. In this all-stone witness the total calls/total tags cut holds vacuously, but `SentientTag` and hence `LiveFiberAtPole` fail by `sentientTag_iff_actualFiberInhabited`. This is the buddha/stone convergence blocked by the function/share split. -/ theorem total_cut_carries_no_function : stoneCoarsening.FiberAtPoleOnWithin () (fun _ => True) (fun _ => True) ∧ ¬ stoneCoarsening.SentientTag () ∧ stoneCoarsening.FiberAtPole () ∧ ¬ stoneCoarsening.LiveFiberAtPole () := ⟨stone_fiber_total_cut, stone_fiber_not_sentient, stone_fiber_atPole, stone_fiber_not_live⟩ /- ============================================================================== Function still does not close the effectiveness gap ============================================================================== -/ def sraddhaEffectCoarsening : BeingCoarsening SraddhaNegative.zeroEffectGrid SraddhaNegative.Being where proj := id theorem sraddha_fiber_total_cut : sraddhaEffectCoarsening.FiberAtPoleOnWithin SraddhaNegative.Being.sraddha (fun _ => True) (fun _ => True) := by intro w _hactual hfiber _hclass _htag cases w with | mk agent c r => cases agent with | sraddha => dsimp [Grid.share, SraddhaNegative.zeroEffectGrid, AtBot, shareBot] exact Nat.le_refl 0 | receiver => dsimp [sraddhaEffectCoarsening, Grid.DirectedConvention.BeingConvention.BeingCoarsening.InFiber] at hfiber cases hfiber theorem sraddha_fiber_sentient : sraddhaEffectCoarsening.SentientTag SraddhaNegative.Being.sraddha := by refine ⟨SraddhaNegative.Being.sraddha, rfl, ?_⟩ exact ⟨SraddhaNegative.Call.call, ⟨SraddhaNegative.Response.response, rfl⟩⟩ theorem sraddha_liveFiberAtPole : sraddhaEffectCoarsening.LiveFiberAtPole SraddhaNegative.Being.sraddha := by have hpole : sraddhaEffectCoarsening.FiberAtPole SraddhaNegative.Being.sraddha := (sraddhaEffectCoarsening.fiberAtPoleOnWithin_univ_univ_iff SraddhaNegative.Being.sraddha).mp sraddha_fiber_total_cut have hinh : sraddhaEffectCoarsening.ActualFiberInhabited SraddhaNegative.Being.sraddha := (sraddhaEffectCoarsening.sentientTag_iff_actualFiberInhabited SraddhaNegative.Being.sraddha).mp sraddha_fiber_sentient exact ⟨hinh, hpole⟩ /-- Rung 2 to rung 3 is strict. Dressing the zero-effect sraddha countermodel with the identity fiber gives total calls and total tags plus function (`LiveFiberAtPole`), while `WaaFullyEnlightened` still fails: quiet-and- functioning is not regime effectiveness. This is the tag-axis sibling of `OrthogonalityNegative.waaFullyEnlightened_stronger_than_terminus`. -/ theorem total_cut_with_function_not_waaFullyEnlightened : sraddhaEffectCoarsening.FiberAtPoleOnWithin SraddhaNegative.Being.sraddha (fun _ => True) (fun _ => True) ∧ sraddhaEffectCoarsening.SentientTag SraddhaNegative.Being.sraddha ∧ sraddhaEffectCoarsening.LiveFiberAtPole SraddhaNegative.Being.sraddha ∧ ¬ WaaFullyEnlightened SraddhaNegative.zeroEffectGrid SraddhaNegative.Being.sraddha := ⟨sraddha_fiber_total_cut, sraddha_fiber_sentient, sraddha_liveFiberAtPole, SraddhaNegative.not_waaFullyEnlightened⟩ inductive Being | practitioner inductive Call | seen | fresh deriving DecidableEq inductive Response | response /-- The seen call is quiet; the fresh call is quiet too. -/ def quietGrid : Grid Nat where Being := Being Call := Call Response := Response respondsTo _ _ := some Response.response grade _ _ _ := 0 conditions _ _ := True /-- The same seen behavior, but the fresh call carries live share. -/ def freshClenchGrid : Grid Nat where Being := Being Call := Call Response := Response respondsTo _ _ := some Response.response grade _ c _ := match c with | .seen => 0 | .fresh => 5 conditions _ _ := True def quietPath : quietGrid.PathScheme where proj _ := Path.streamEntry def freshPath : freshClenchGrid.PathScheme where proj _ := Path.streamEntry /-- Identity-view provocations are modeled here as the whole call domain. -/ def quietReading : quietGrid.FetterReading where provocationClass | Fetter.identityView, _ => True | _, _ => False def freshReading : freshClenchGrid.FetterReading where provocationClass | Fetter.identityView, _ => True | _, _ => False def quietSeen : quietGrid.Weld := ⟨Being.practitioner, Call.seen, Response.response⟩ def freshSeen : freshClenchGrid.Weld := ⟨Being.practitioner, Call.seen, Response.response⟩ def freshWeld : freshClenchGrid.Weld := ⟨Being.practitioner, Call.fresh, Response.response⟩ def quietRun : List quietGrid.Weld := [quietSeen] def freshRun : List freshClenchGrid.Weld := [freshSeen] /-- The restricted seen track record: response and grade behavior on `seen`. -/ abbrev TrackData : Type := Option Response × (Response → Nat) def quietSeenTrackData : TrackData := (quietGrid.respondsTo Being.practitioner Call.seen, fun r => quietGrid.grade Being.practitioner Call.seen r) def freshSeenTrackData : TrackData := (freshClenchGrid.respondsTo Being.practitioner Call.seen, fun r => freshClenchGrid.grade Being.practitioner Call.seen r) theorem seen_track_agrees : quietSeenTrackData = freshSeenTrackData := rfl theorem quiet_seen_runQuiet : quietGrid.RunQuiet quietPath Path.streamEntry (quietReading.provocationClass Fetter.identityView) quietRun := by intro w hmem _hactual _hfiber _hclass simp [quietRun, quietSeen] at hmem subst w dsimp [Grid.share, quietGrid, AtBot, shareBot] show (0 : Nat) ≤ 0 decide theorem fresh_seen_runQuiet : freshClenchGrid.RunQuiet freshPath Path.streamEntry (freshReading.provocationClass Fetter.identityView) freshRun := by intro w hmem _hactual _hfiber _hclass simp [freshRun, freshSeen] at hmem subst w dsimp [Grid.share, freshClenchGrid, AtBot, shareBot] show (0 : Nat) ≤ 0 decide theorem quiet_fetterCut : quietGrid.FetterCut quietPath Path.streamEntry quietReading Fetter.identityView := by intro w _hactual _hfiber _hclass dsimp [Grid.share, quietGrid, AtBot, shareBot] show (0 : Nat) ≤ 0 decide theorem fresh_not_fetterCut : ¬ freshClenchGrid.FetterCut freshPath Path.streamEntry freshReading Fetter.identityView := by intro hcut have hbot : AtBot (freshClenchGrid.share freshWeld) := hcut freshWeld rfl rfl True.intro dsimp [Grid.share, freshClenchGrid, freshWeld, AtBot, shareBot] at hbot exact Nat.not_succ_le_zero 4 hbot theorem fresh_share_disagrees : quietGrid.grade Being.practitioner Call.fresh Response.response ≠ freshClenchGrid.grade Being.practitioner Call.fresh Response.response := by decide /-- A finite seen class-quiet track does not determine the fresh call. -/ theorem seen_run_underdetermines_fetterCut : quietSeenTrackData = freshSeenTrackData ∧ quietGrid.RunQuiet quietPath Path.streamEntry (quietReading.provocationClass Fetter.identityView) quietRun ∧ freshClenchGrid.RunQuiet freshPath Path.streamEntry (freshReading.provocationClass Fetter.identityView) freshRun ∧ quietGrid.FetterCut quietPath Path.streamEntry quietReading Fetter.identityView ∧ ¬ freshClenchGrid.FetterCut freshPath Path.streamEntry freshReading Fetter.identityView := ⟨seen_track_agrees, quiet_seen_runQuiet, fresh_seen_runQuiet, quiet_fetterCut, fresh_not_fetterCut⟩ theorem quiet_seen_runQuietWithin : quietGrid.RunQuietWithin quietPath Path.streamEntry (quietReading.provocationClass Fetter.identityView) (fun _ => True) quietRun := by intro w hmem hactual hfiber hclass _htag exact quiet_seen_runQuiet w hmem hactual hfiber hclass theorem fresh_seen_runQuietWithin : freshClenchGrid.RunQuietWithin freshPath Path.streamEntry (freshReading.provocationClass Fetter.identityView) (fun _ => True) freshRun := by intro w hmem hactual hfiber hclass _htag exact fresh_seen_runQuiet w hmem hactual hfiber hclass theorem quiet_fetterCutWithin : quietGrid.FetterCutWithin quietPath Path.streamEntry quietReading Fetter.identityView (fun _ => True) := by intro w hactual hfiber hclass _htag exact quiet_fetterCut w hactual hfiber hclass theorem fresh_not_fetterCutWithin : ¬ freshClenchGrid.FetterCutWithin freshPath Path.streamEntry freshReading Fetter.identityView (fun _ => True) := by intro hcut have hbot : AtBot (freshClenchGrid.share freshWeld) := hcut freshWeld rfl rfl True.intro True.intro dsimp [Grid.share, freshClenchGrid, freshWeld, AtBot, shareBot] at hbot exact Nat.not_succ_le_zero 4 hbot /-- A finite seen class-quiet track in a tag-region does not determine the fresh call. The tag class is total here, so the old fresh-call obstruction transfers directly to the product predicate. -/ theorem seen_run_underdetermines_fetterCutWithin : quietSeenTrackData = freshSeenTrackData ∧ quietGrid.RunQuietWithin quietPath Path.streamEntry (quietReading.provocationClass Fetter.identityView) (fun _ => True) quietRun ∧ freshClenchGrid.RunQuietWithin freshPath Path.streamEntry (freshReading.provocationClass Fetter.identityView) (fun _ => True) freshRun ∧ quietGrid.FetterCutWithin quietPath Path.streamEntry quietReading Fetter.identityView (fun _ => True) ∧ ¬ freshClenchGrid.FetterCutWithin freshPath Path.streamEntry freshReading Fetter.identityView (fun _ => True) := ⟨seen_track_agrees, quiet_seen_runQuietWithin, fresh_seen_runQuietWithin, quiet_fetterCutWithin, fresh_not_fetterCutWithin⟩ /- ============================================================================== No grid-carried recovery of a unique soma boundary ============================================================================== -/ /-- Two fine tags with identical grid data and incompatible region readings. -/ def somaGrid : Grid Nat where Being := Bool Call := Unit Response := Unit respondsTo _ _ := some () grade _ _ _ := 0 conditions _ _ := True def somaMergeReading : somaGrid.SomaReading where speechThoughtTag _ := True def somaSplitReading : somaGrid.SomaReading where speechThoughtTag p := p = false theorem somaMerge_true_in_region : somaMergeReading.speechThoughtTag true := True.intro theorem somaSplit_true_not_in_region : ¬ somaSplitReading.speechThoughtTag true := by intro h cases h abbrev SomaW := RawWeld Bool Unit Unit abbrev SomaGridData : Type := (Bool → Unit → Option Unit) × (Bool → Unit → Unit → Nat) × (SomaW → SomaW → Prop) def somaGridData : SomaGridData := (somaGrid.respondsTo, somaGrid.grade, somaGrid.conditions) def mergedRegion (_p : Bool) : Prop := True def splitRegion (p : Bool) : Prop := p = false /-- The same grid data supports incompatible supplied soma-readings. Holding a speech/thought region as recovered from the grid is the uniform freeze on the tag axis. -/ theorem no_region_boundary_recovery : ¬ ∃ recover : SomaGridData → Bool → Prop, recover somaGridData = mergedRegion ∧ recover somaGridData = splitRegion := by rintro ⟨recover, hmerge, hsplit⟩ have hmerged : recover somaGridData true := by rw [hmerge] exact True.intro have hsplitNot : ¬ recover somaGridData true := by rw [hsplit] intro h cases h exact hsplitNot hmerged theorem soma_boundary_underdetermined : somaMergeReading.speechThoughtTag true ∧ ¬ somaSplitReading.speechThoughtTag true ∧ ¬ ∃ recover : SomaGridData → Bool → Prop, recover somaGridData = mergedRegion ∧ recover somaGridData = splitRegion := ⟨somaMerge_true_in_region, somaSplit_true_not_in_region, no_region_boundary_recovery⟩ end FettersNegative end WAA ===== FILE: WeldAndArrow/Doctrines/FourTruths.lean ===== /- ================================================================================ WeldAndArrow.Doctrines.FourTruths Checked four-truth-facing consequences in the grid's own vocabulary ================================================================================ This module names the dukkha-facing mismatch grade without adding a new measure. WaaMismatch covaries with share because it is read from the same Row-2 display value; the grid proves the implication-shape facts and does not assert any detached injunction. -/ import WeldAndArrow.Consequences.Basic namespace WAA namespace Grid variable {Contrib : Type} [PreorderBot Contrib] variable (G : Grid Contrib) /- ============================================================================== Truths 1-3: mismatch as a display reading ============================================================================== -/ /-- `WaaMismatchGrade` is read from the same structure as share. This is covariation, not a second operational measure. -/ def WaaMismatchGrade (w : G.Weld) : Contrib := G.share w @[simp] theorem waaMismatchGrade_eq_share (w : G.Weld) : G.WaaMismatchGrade w = G.share w := rfl /-- Ordinal covariation: lowering share lowers mismatch grade in the same display order, because the two readings unfold to the same value. -/ theorem waaMismatchGrade_le_of_share_le {w₁ w₂ : G.Weld} (h : G.share w₁ ≼ G.share w₂) : G.WaaMismatchGrade w₁ ≼ G.WaaMismatchGrade w₂ := h /-- Live mismatch is an actual occurrence with a live self-pole index. -/ def WaaMismatchLive (w : G.Weld) : Prop := G.Actual w ∧ G.HasSelfPoleIndex w /-- Given occurrence actuality, live mismatch is exactly the live self-pole index condition. -/ theorem waaMismatchLive_iff_hasSelfPoleIndex {w : G.Weld} (hactual : G.Actual w) : G.WaaMismatchLive w ↔ G.HasSelfPoleIndex w := by constructor · intro h exact h.right · intro hidx exact ⟨hactual, hidx⟩ /-- Stones are outside the actual occurrence-domain for live mismatch. -/ theorem not_waaMismatchLive_of_stone (b : G.Being) (hstone : G.Stone b) {c : G.Call} {r : G.Response} : ¬ G.WaaMismatchLive ⟨b, c, r⟩ := by intro h exact G.not_actual_of_stone b hstone h.left /-- A terminus response has mismatch grade at the pole-class. -/ theorem waaMismatch_atBot_of_terminus_response {b : G.Being} {c : G.Call} {r : G.Response} (hterm : G.Terminus b) (hresp : G.respondsTo b c = some r) : AtBot (G.WaaMismatchGrade ⟨b, c, r⟩) := G.atBot_of_terminus_response hterm hresp /-- A terminus response is not live mismatch. -/ theorem not_waaMismatchLive_of_terminus_response {b : G.Being} {c : G.Call} {r : G.Response} (hterm : G.Terminus b) (hresp : G.respondsTo b c = some r) : ¬ G.WaaMismatchLive ⟨b, c, r⟩ := by intro h exact h.right (G.waaMismatch_atBot_of_terminus_response hterm hresp) end Grid end WAA ===== FILE: WeldAndArrow/Doctrines/FoxCase.lean ===== /- ================================================================================ WeldAndArrow.Doctrines.FoxCase Dukkha-facing fox case checks ================================================================================ The concrete fox grid lives in `Consequences/FoxCase.lean`. This adjacent doctrine module adds only the Four Truths vocabulary needed to say that a clenched fox-life reception is the worked dukkha example. Reading and motivation: Identification/Commentary.lean, C.7a. -/ import WeldAndArrow.Consequences.FoxCase import WeldAndArrow.Doctrines.FourTruths namespace WAA namespace FoxCase /-- "Each clenched reception is that life's dukkha": live mismatch is present, and its grade is definitionally the reception's share. -/ theorem fox_dukkha_per_life (n : Nat) : foxGrid.WaaMismatchLive (lifeReception (n + 1)) ∧ foxGrid.WaaMismatchGrade (lifeReception (n + 1)) = foxGrid.share (lifeReception (n + 1)) := ⟨fox_reception_clenched n, rfl⟩ end FoxCase end WAA ===== FILE: WeldAndArrow/Doctrines/Gradeability.lean ===== /- ================================================================================ WeldAndArrow.Doctrines.Gradeability Gradeability for call-carrying records ================================================================================ The theorem-file gradeability rule says that the taxonomy may grade a recorded utterance only where the record carries its call. This module checks the formal part of that rule: severing a response from its call underdetermines the grade, while a `RecordedUtterance` carries the call through its `weld`. The normative discipline, the koan-form genre claim, and the Hakuin-epigram pedigree note remain prose. Reading and motivation: Identification/Commentary.lean, C.10. -/ import WeldAndArrow.Signature.Claims import WeldAndArrow.Signature.Models namespace WAA namespace Grid variable {Contrib : Type} [PreorderBot Contrib] /-- A quotation in its strongest severed form: the response is attributed to an agent, but the call that made it an occurrence has been forgotten. There is deliberately no `call`, no `offeredAt`, and no `actual` field here. With no `offeredAt`, this record cannot even be supplied to `FitsOfferedTier`: nothing is positioned for the taxonomy to classify. The generator-side standing verdict is therefore `severedVerdict`, a decline rather than a grade. -/ structure SeveredTranscript (G : Grid Contrib) where agent : G.Being response : G.Response namespace Weld /-- Forget the call carried by a weld. -/ def sever {G : Grid Contrib} (w : G.Weld) : SeveredTranscript G := { agent := w.agent, response := w.response } @[simp] theorem sever_agent {G : Grid Contrib} (w : G.Weld) : (w.sever).agent = w.agent := rfl @[simp] theorem sever_response {G : Grid Contrib} (w : G.Weld) : (w.sever).response = w.response := rfl /-- Two welds with the same attributed agent and response have the same severed transcript, regardless of the calls they answered. -/ theorem sever_eq_of_agent_response {G : Grid Contrib} {w₁ w₂ : G.Weld} (hagent : w₁.agent = w₂.agent) (hresponse : w₁.response = w₂.response) : w₁.sever = w₂.sever := by cases w₁ cases w₂ dsimp [sever] at hagent hresponse ⊢ cases hagent cases hresponse rfl end Weld namespace RecordedUtterance /-- A recorded utterance is severed by forgetting the call already carried in its weld. -/ def sever {G : Grid Contrib} {L : ClaimLanguage G} (u : RecordedUtterance G L) : SeveredTranscript G := u.weld.sever @[simp] theorem sever_eq_weld_sever {G : Grid Contrib} {L : ClaimLanguage G} (u : RecordedUtterance G L) : u.sever = u.weld.sever := rfl end RecordedUtterance /-- The generator's public standing for a severed transcript: no call-carried utterance is present, so the taxonomy declines rather than grading. -/ def severedVerdict (G : Grid Contrib) : GeneratorOutcome G := .declined end Grid /-- The compliant record carries the whole weld, so its grade is definitionally the grade of the agent-call-response occurrence stored in that record. The identification of this call-carrying form with the koan genre remains a prose claim; the checked point is the carried call. -/ theorem recordedUtterance_grade_determined {Contrib : Type} [PreorderBot Contrib] {G : Grid Contrib} {L : Grid.ClaimLanguage G} (u : Grid.RecordedUtterance G L) : G.share u.weld = G.grade u.weld.agent u.weld.call u.weld.response := rfl namespace GradeabilityNegative variable {Contrib : Type} [PreorderBot Contrib] /-- If two same-agent/same-response welds differ in grade, the missing field is necessarily the call. -/ theorem call_ne_of_severed_grade_collision {G : Grid Contrib} {w₁ w₂ : G.Weld} (hagent : w₁.agent = w₂.agent) (hresponse : w₁.response = w₂.response) (hshare : G.share w₁ ≠ G.share w₂) : w₁.call ≠ w₂.call := by intro hcall have hw : w₁ = w₂ := by cases w₁ cases w₂ dsimp at hagent hresponse hcall cases hagent cases hcall cases hresponse rfl exact hshare (by rw [hw]) /-- Under a same-agent/same-response collision with different shares, no function from severed transcripts can correctly recover the grade of every actual weld. Because the collision already fixes the agent, the still barer response-only quotation is covered a fortiori. -/ theorem no_grade_recovery_from_severed {G : Grid Contrib} {w₁ w₂ : G.Weld} (hactual₁ : G.Actual w₁) (hactual₂ : G.Actual w₂) (hagent : w₁.agent = w₂.agent) (hresponse : w₁.response = w₂.response) (hshare : G.share w₁ ≠ G.share w₂) : ¬ ∃ estimate : Grid.SeveredTranscript G -> Contrib, ∀ w : G.Weld, G.Actual w -> estimate w.sever = G.share w := by rintro ⟨estimate, hestimate⟩ have hsever : w₁.sever = w₂.sever := Grid.Weld.sever_eq_of_agent_response hagent hresponse have hsame : estimate w₁.sever = estimate w₂.sever := congrArg estimate hsever have hshares : G.share w₁ = G.share w₂ := by calc G.share w₁ = estimate w₁.sever := (hestimate w₁ hactual₁).symm _ = estimate w₂.sever := hsame _ = G.share w₂ := hestimate w₂ hactual₂ exact hshare hshares /-- The gentle call in `backslideGrid`: same agent and response as the harsh call, but pole-class share. -/ def severedGentle : backslideGrid.Weld := ⟨(), Cue.gentle, ()⟩ /-- The harsh call in `backslideGrid`: same agent and response as the gentle call, but live share. -/ def severedHarsh : backslideGrid.Weld := ⟨(), Cue.harsh, ()⟩ /-- Concrete carrier for the gradeability rule's underdetermination face: same attributed quotation, different calls, different grades. -/ theorem gradeability_severed_underdetermination_witness : backslideGrid.Actual severedGentle ∧ backslideGrid.Actual severedHarsh ∧ severedGentle.agent = severedHarsh.agent ∧ severedGentle.response = severedHarsh.response ∧ severedGentle.call ≠ severedHarsh.call ∧ backslideGrid.share severedGentle ≠ backslideGrid.share severedHarsh := by refine ⟨rfl, rfl, rfl, rfl, ?_, ?_⟩ · intro h cases h · dsimp [Grid.share, backslideGrid, severedGentle, severedHarsh] decide /-- In the concrete backsliding grid, a severed transcript cannot be graded correctly for every actual weld. -/ theorem severed_transcript_ungradeable : ¬ ∃ estimate : Grid.SeveredTranscript backslideGrid -> Nat, ∀ w : backslideGrid.Weld, backslideGrid.Actual w -> estimate w.sever = backslideGrid.share w := no_grade_recovery_from_severed (G := backslideGrid) (w₁ := severedGentle) (w₂ := severedHarsh) rfl rfl rfl rfl (by dsimp [Grid.share, backslideGrid, severedGentle, severedHarsh] decide) end GradeabilityNegative end WAA ===== FILE: WeldAndArrow/Doctrines/Icchantika.lean ===== /- ================================================================================ WeldAndArrow.Doctrines.Icchantika The icchantika as a declined foreclosure case ================================================================================ Reading and motivation: Identification/Commentary.lean, C.13. -/ import WeldAndArrow.Doctrines.Sraddha namespace WAA open Grid.DirectedConvention variable {Contrib : Type} [PreorderBot Contrib] /- ============================================================================== Icchantika typing ============================================================================== -/ /-- The icchantika read literally as a run-shape, not as a stored nature: function is mounted somewhere, and every mounted response remains live at the self-pole index. Reading and motivation: `Identification/Commentary.lean`, C.13. -/ def Icchantika (G : Grid Contrib) (b : G.Being) : Prop := G.MountsSomewhere b ∧ ∀ c r, G.respondsTo b c = some r → G.HasSelfPoleIndex ⟨b, c, r⟩ /-- An icchantika is constructible on the function side, so it is not a stone. Reading and motivation: `Identification/Commentary.lean`, C.13. -/ theorem icchantika_not_stone {G : Grid Contrib} {b : G.Being} (h : Icchantika G b) : ¬ G.Stone b := G.not_stone_of_mountsSomewhere b h.left /-- An icchantika is the terminus's inverse on its mounted run: the mounted witness supplies a live self-pole index where terminus typing would force the pole-class. Reading and motivation: `Identification/Commentary.lean`, C.13. -/ theorem icchantika_not_terminus {G : Grid Contrib} {b : G.Being} (h : Icchantika G b) : ¬ G.Terminus b := by intro hterm rcases h.left with ⟨c, r, hresp⟩ exact h.right c r hresp (G.atBot_of_terminus_response hterm hresp) /-- The honest negative fact: an icchantika cannot be seated as a fully enlightened agent on this run, because `WaaFullyEnlightened` includes terminus typing. This is not a verdict that the being cannot become buddha. Reading and motivation: `Identification/Commentary.lean`, C.13. -/ theorem not_waaFullyEnlightened_of_icchantika {G : Grid Contrib} {b : G.Being} (h : Icchantika G b) : ¬ WaaFullyEnlightened G b := by intro hfull exact icchantika_not_terminus (G := G) h hfull.left.right /-- Receiver-side correction: whenever an actual reception is made by an icchantika and the prior tendency is live, the sraddha aversion antecedent is available. Reading and motivation: `Identification/Commentary.lean`, C.13. -/ theorem aversionContext_of_icchantika_reception {G : Grid Contrib} {before : Config Contrib} {b : G.Being} {reception : G.Weld} (hagent : reception.agent = b) (hic : Icchantika G b) (hactual : G.Actual reception) (hlive : ¬ AtBot before.tendency) : WaaAversionContext G before reception := by refine { liveBefore := hlive mismatchLive := ?_ } refine ⟨hactual, ?_⟩ subst b simpa using hic.right reception.call reception.response hactual /-- If a fully enlightened deliverer reaches an icchantika reception, the existing sraddha theorem supplies the share-drop landing: the icchantika is reachable as receiver even though it cannot be seated as the enlightened agent on its run. Reading and motivation: `Identification/Commentary.lean`, C.13. -/ theorem icchantika_reachable {G : Grid Contrib} {g b : G.Being} {before : Config Contrib} {deed reception : G.Weld} (hfaith : WaaFullyEnlightened G g) (hdeed : deed.agent = g) (hdel : DeliveredTo G deed reception) (hreceiver : reception.agent = b) (hic : Icchantika G b) (hactual : G.Actual reception) (hlive : ¬ AtBot before.tendency) : HasShareDropLanding G before deed := waa_path_landing G hfaith hdeed hdel (aversionContext_of_icchantika_reception (G := G) hreceiver hic hactual hlive) /- ============================================================================== Concrete non-foreclosure witness ============================================================================== -/ namespace IcchantikaCase /-- The small carrier used only to witness the declined foreclosure reading. -/ inductive Being | buddha | icchantika /-- The single call used by the icchantika witness. -/ inductive Call | call /-- The single response used by the icchantika witness. -/ inductive Response | response /-- A concrete grid where the icchantika mounts a live response and a buddha deed is delivered to that response. -/ def grid : Grid Nat where Being := Being Call := Call Response := Response respondsTo _ _ := some Response.response grade b _ _ := match b with | .buddha => 0 | .icchantika => 1 conditions deed reception := deed.agent = Being.buddha ∧ reception.agent = Being.icchantika /-- A live prior tendency high enough for the icchantika reception itself to be a share-drop. -/ def liveBefore : Config Nat := { tendency := 2 } /-- The delivered buddha-side deed in the concrete witness. -/ def deed : grid.Weld := ⟨Being.buddha, Call.call, Response.response⟩ /-- The icchantika-side reception in the concrete witness. -/ def reception : grid.Weld := ⟨Being.icchantika, Call.call, Response.response⟩ /-- The prior tendency in the witness is live. -/ theorem liveBefore_not_atBot : ¬ AtBot liveBefore.tendency := by dsimp [liveBefore, AtBot, shareBot] show ¬ (2 : Nat) ≤ 0 decide /-- The icchantika response is actual in the witness grid. -/ theorem reception_actual : grid.Actual reception := rfl /-- The buddha deed is actual in the witness grid. -/ theorem deed_actual : grid.Actual deed := rfl /-- The witness receiver satisfies the icchantika run-shape. -/ theorem receiver_icchantika : Icchantika grid Being.icchantika := by constructor · exact ⟨Call.call, Response.response, rfl⟩ · intro c r _hresp cases c cases r dsimp [Grid.HasSelfPoleIndex, Grid.share, grid, AtBot, shareBot] show ¬ (1 : Nat) ≤ 0 decide /-- The buddha deed is delivered to the icchantika reception. -/ theorem delivered : DeliveredTo grid deed reception := ⟨rfl, rfl⟩ /-- The icchantika reception is itself a share-drop from the live prior tendency. -/ theorem reception_shareDrop : grid.IsShareDrop liveBefore reception := by dsimp [Grid.IsShareDrop, Grid.share, liveBefore, reception, grid] constructor · show (1 : Nat) ≤ 2 decide · show ¬ (2 : Nat) ≤ 1 decide /-- The concrete icchantika receiver is constructible. -/ theorem constructible : ∃ b : grid.Being, Icchantika grid b := ⟨Being.icchantika, receiver_icchantika⟩ /-- The delivered icchantika reception lands as a share-drop in the concrete witness. -/ theorem landing : HasShareDropLanding grid liveBefore deed := by exact ⟨reception, ⟨⟨delivered, reception_actual⟩, reception_shareDrop⟩⟩ end IcchantikaCase /-- Foreclosure is not recovered from the icchantika run: in a concrete grid an icchantika-typed receiver is actual, delivered to, and itself participates in a share-drop landing from a live prior tendency. Reading and motivation: `Identification/Commentary.lean`, C.13. -/ theorem icchantika_release_not_foreclosed : ∃ (before : Config Nat) (b : IcchantikaCase.grid.Being) (deed reception : IcchantikaCase.grid.Weld), Icchantika IcchantikaCase.grid b ∧ reception.agent = b ∧ IcchantikaCase.grid.Actual reception ∧ ¬ AtBot before.tendency ∧ DeliveredTo IcchantikaCase.grid deed reception ∧ IcchantikaCase.grid.IsShareDrop before reception ∧ HasShareDropLanding IcchantikaCase.grid before deed := by refine ⟨IcchantikaCase.liveBefore, IcchantikaCase.Being.icchantika, IcchantikaCase.deed, IcchantikaCase.reception, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩ · exact IcchantikaCase.receiver_icchantika · rfl · exact IcchantikaCase.reception_actual · exact IcchantikaCase.liveBefore_not_atBot · exact IcchantikaCase.delivered · exact IcchantikaCase.reception_shareDrop · exact IcchantikaCase.landing end WAA ===== FILE: WeldAndArrow/Doctrines/Ledger.lean ===== /- ================================================================================ WeldAndArrow.Doctrines.Ledger Productivity-ledger register, reception commands, and the purge face ================================================================================ This module records the checked face of the ledger case. The neutral machinery states that landings inherit the call modality of the receiving function; the case model then runs the Baizhang/Huichang shape without adding a new taxonomy row or a state-sized being. Reading and motivation: Identification/Commentary.lean, C.7. -/ import WeldAndArrow.Consequences.Taxonomy namespace WAA namespace Grid variable {Contrib : Type} [PreorderBot Contrib] variable (G : Grid Contrib) namespace DirectedConvention open BeingConvention /- ============================================================================== Function-side modality ============================================================================== -/ /-- A being mounts responses only at calls in a supplied modality. This is neutral function-side vocabulary: the modality is a predicate on calls, not a value judgement about the receiver. -/ def MountsOnlyIn (b : G.Being) (M : G.Call -> Prop) : Prop := ∀ c r, G.respondsTo b c = some r -> M c /-- An actual weld at a modality-restricted receiver carries a call in that modality. -/ theorem modality_of_actual {M : G.Call -> Prop} {w : G.Weld} (hM : MountsOnlyIn G w.agent M) (hactual : G.Actual w) : M w.call := hM w.call w.response hactual /-- Any landing at a modality-restricted receiver carries a call in that modality. -/ theorem landing_call_in_modality {M : G.Call -> Prop} {deed reception : G.Weld} (hM : MountsOnlyIn G reception.agent M) (hland : LandsAt G deed reception) : M reception.call := modality_of_actual G hM hland.right /-- A weld whose call lies outside the receiver's modality cannot be actual. -/ theorem not_actual_outside_modality {M : G.Call -> Prop} {w : G.Weld} (hM : MountsOnlyIn G w.agent M) (hout : ¬ M w.call) : ¬ G.Actual w := fun hactual => hout (modality_of_actual G hM hactual) /-- A reception whose call lies outside the receiver's modality cannot be a landing. -/ theorem no_landing_outside_modality {M : G.Call -> Prop} {deed reception : G.Weld} (hM : MountsOnlyIn G reception.agent M) (hout : ¬ M reception.call) : ¬ LandsAt G deed reception := fun hland => hout (landing_call_in_modality G hM hland) namespace BeingConvention /-- If every fine tag under a macro tag shares a modality restriction, then any landing in that fiber carries a call in the same modality. -/ theorem fiber_landing_call_in_modality {Macro : Type} (κ : BeingCoarsening G Macro) {b : Macro} {M : G.Call -> Prop} (hfiberM : ∀ p : G.Being, κ.proj p = b -> MountsOnlyIn G p M) {deed reception : G.Weld} (hfiber : κ.InFiber b reception) (hland : LandsAt G deed reception) : M reception.call := landing_call_in_modality G (hfiberM reception.agent hfiber) hland end BeingConvention end DirectedConvention /- ============================================================================== Reception-command language ============================================================================== -/ /-- Claim object for a command that treats reception itself as commanded: this deed is asserted to land at that reception. -/ structure ReceptionCommand where deed : G.Weld reception : G.Weld /-- A tiny object language for reception-command claims. Such claims are satisfiable only where the field-side delivery reaches an actual reception. -/ def receptionCommandLanguage : ClaimLanguage G where Claim := ReceptionCommand G Holds := fun _ claim => DirectedConvention.LandsAt G claim.deed claim.reception /-- A recorded reception-command utterance fits its offered tier only when the commanded reception actually lands. -/ theorem receptionCommand_unfit_of_no_landing (u : RecordedUtterance G (receptionCommandLanguage G)) (hnot : ¬ DirectedConvention.LandsAt G u.content.deed u.content.reception) : ¬ u.FitsOfferedTier := by intro hfit change (receptionCommandLanguage G).TrueAt u.offeredAt u.content at hfit dsimp [receptionCommandLanguage, ClaimLanguage.TrueAt] at hfit exact hnot hfit namespace DirectedConvention namespace BeingConvention namespace GridConvention /-- The ledger census face delegates to the existing per-call/global row. -/ theorem ledger_census_misfits_live_offer (u : RecordedUtterance G (rowLanguage G)) (hcontent : u.content = .denied .perCallGlobal) (hlive : Tier.hasLiveShare G u.offeredAt) : ¬ u.FitsOfferedTier := denied_misfits_live_offer G .perCallGlobal u hcontent hlive /-- The ledger prognosis face delegates to the existing standing/dated row. -/ theorem ledger_prognosis_misfits_live_offer (u : RecordedUtterance G (rowLanguage G)) (hcontent : u.content = .denied .standingDated) (hlive : Tier.hasLiveShare G u.offeredAt) : ¬ u.FitsOfferedTier := denied_misfits_live_offer G .standingDated u hcontent hlive end GridConvention end BeingConvention end DirectedConvention end Grid /- ============================================================================== Ledger case ============================================================================== -/ namespace LedgerCase open Grid open Grid.DirectedConvention open Grid.DirectedConvention.BeingConvention inductive Being | master | official | practitioner deriving DecidableEq inductive Call | economic | floor | decree deriving DecidableEq inductive Response | code | comply | display deriving DecidableEq /-- The economic modality: the one call class the official ledger can receive. -/ def economicModality : Call -> Prop | .economic => True | .floor => False | .decree => False /-- Three beings, three calls, three responses, constant live grade. Delivery reaches exactly receptions whose response is `code` or `comply`; actuality remains controlled by `respondsTo`. -/ def ledgerGrid : Grid Nat where Being := Being Call := Call Response := Response respondsTo b c := match b, c with | .master, .economic => some .code | .master, .decree => some .display | .official, .economic => some .comply | .practitioner, .economic => some .code | _, _ => none grade _ _ _ := 1 conditions _ reception := match reception.response with | .code => True | .comply => True | .display => False def codeWeld : ledgerGrid.Weld := ⟨Being.master, Call.economic, Response.code⟩ def officialComplyWeld : ledgerGrid.Weld := ⟨Being.official, Call.economic, Response.comply⟩ def practitionerCodeWeld : ledgerGrid.Weld := ⟨Being.practitioner, Call.economic, Response.code⟩ def decreeWeld : ledgerGrid.Weld := ⟨Being.master, Call.decree, Response.display⟩ def commandedReception : ledgerGrid.Weld := ⟨Being.official, Call.floor, Response.comply⟩ theorem codeWeld_actual : ledgerGrid.Actual codeWeld := rfl theorem officialComplyWeld_actual : ledgerGrid.Actual officialComplyWeld := rfl theorem practitionerCodeWeld_actual : ledgerGrid.Actual practitionerCodeWeld := rfl theorem decreeWeld_actual : ledgerGrid.Actual decreeWeld := rfl theorem official_mountsOnlyIn_economic : MountsOnlyIn ledgerGrid Being.official economicModality := by intro c r h cases c <;> cases r <;> simp [ledgerGrid, economicModality] at h ⊢ theorem official_not_stone : ¬ ledgerGrid.Stone Being.official := fun hstone => hstone Call.economic ⟨Response.comply, rfl⟩ theorem official_landing_only_economic {deed reception : ledgerGrid.Weld} (hagent : reception.agent = Being.official) (hland : LandsAt ledgerGrid deed reception) : economicModality reception.call := by cases reception with | mk agent call response => cases hagent exact landing_call_in_modality ledgerGrid official_mountsOnlyIn_economic hland theorem floor_speech_never_lands_at_official {deed reception : ledgerGrid.Weld} (hagent : reception.agent = Being.official) (hcall : reception.call = Call.floor) : ¬ LandsAt ledgerGrid deed reception := by intro hland have hmod : economicModality reception.call := official_landing_only_economic hagent hland rw [hcall] at hmod exact hmod theorem code_lands_at_official : LandsAt ledgerGrid codeWeld officialComplyWeld := ⟨True.intro, officialComplyWeld_actual⟩ theorem code_lands_at_practitioner : LandsAt ledgerGrid codeWeld practitionerCodeWeld := ⟨True.intro, practitionerCodeWeld_actual⟩ theorem code_ruler_not_exempt : LandsAt ledgerGrid codeWeld codeWeld := ⟨True.intro, codeWeld_actual⟩ theorem one_act_two_receivers : LandsAt ledgerGrid codeWeld officialComplyWeld ∧ LandsAt ledgerGrid codeWeld practitionerCodeWeld := ⟨code_lands_at_official, code_lands_at_practitioner⟩ inductive Sector | state | sangha deriving DecidableEq def sectorCoarsening : BeingCoarsening ledgerGrid Sector where proj | Being.official => Sector.state | _ => Sector.sangha theorem state_tag_sentient : sectorCoarsening.SentientTag Sector.state := ⟨Being.official, rfl, ⟨Call.economic, ⟨Response.comply, rfl⟩⟩⟩ theorem state_fiber_shares_register : ∀ p : ledgerGrid.Being, sectorCoarsening.proj p = Sector.state -> MountsOnlyIn ledgerGrid p economicModality := by intro p hp cases p with | official => exact official_mountsOnlyIn_economic | master => cases hp | practitioner => cases hp theorem state_fiber_landing_economic {deed reception : ledgerGrid.Weld} (hfiber : sectorCoarsening.InFiber Sector.state reception) (hland : LandsAt ledgerGrid deed reception) : economicModality reception.call := fiber_landing_call_in_modality ledgerGrid sectorCoarsening state_fiber_shares_register hfiber hland theorem commandedReception_delivered : DeliveredTo ledgerGrid decreeWeld commandedReception := True.intro theorem commandedReception_not_actual : ¬ ledgerGrid.Actual commandedReception := by intro h cases h theorem commandedReception_not_lands : ¬ LandsAt ledgerGrid decreeWeld commandedReception := fun hland => commandedReception_not_actual hland.right def decreeUtterance : RecordedUtterance ledgerGrid (receptionCommandLanguage ledgerGrid) where weld := decreeWeld actual := decreeWeld_actual offeredAt := Tier.actTime decreeWeld content := { deed := decreeWeld, reception := commandedReception } theorem decree_utterance_not_fits : ¬ decreeUtterance.FitsOfferedTier := receptionCommand_unfit_of_no_landing ledgerGrid decreeUtterance commandedReception_not_lands /-- The decree can engineer the delivery line while failing to command the purported reception. -/ theorem decree_engineers_calls_not_receptions : DeliveredTo ledgerGrid decreeWeld commandedReception ∧ ¬ ledgerGrid.Actual commandedReception ∧ ¬ decreeUtterance.FitsOfferedTier := ⟨commandedReception_delivered, commandedReception_not_actual, decree_utterance_not_fits⟩ local instance ledgerGridDecidableEqBeing : DecidableEq ledgerGrid.Being := inferInstanceAs (DecidableEq Being) abbrev purgedGrid : Grid Nat := ledgerGrid.staticized (show ledgerGrid.Being from Being.master) theorem purge_delivery_loss_real : purgedGrid.Stone Being.master := ledgerGrid.futility_delivery_loss_real Being.master theorem purge_adaptive_to_static : purgedGrid.ResponseInvariant Being.master := ledgerGrid.staticized_responseInvariant Being.master theorem purge_loop_runs_on : purgedGrid.Actual officialComplyWeld := by dsimp [purgedGrid, Grid.staticized, Grid.withRespondsTo, Grid.Actual, ledgerGrid, officialComplyWeld] theorem purge_object_axis_subtraction_nil : purgedGrid.conditions = ledgerGrid.conditions := ledgerGrid.futility_object_axis_subtraction_nil Being.master theorem corpus_still_delivered : DeliveredTo purgedGrid codeWeld officialComplyWeld := True.intro end LedgerCase end WAA ===== FILE: WeldAndArrow/Doctrines/OtherPower.lean ===== /- ================================================================================ WeldAndArrow.Doctrines.OtherPower Other-power as delivery-regime, not a second act grammar ================================================================================ Reception is a deed either way. Tariki names a delivery-regime, not a second act-grammar: Dogen's passive "being verified" reading is modeled by ordinary reception-welds whose delivery line is supplied from elsewhere. No theorem in this module ranks self-power and other-power against one another; that no-polemic clause is part of the model design. The checked surface uses only existing predicates: `Actual`, `share`, `conditions`/`DeliveredTo`, `ResponseInvariant`, and `HasShareDropLanding`. -/ import WeldAndArrow.Consequences.Basic namespace WAA namespace Grid namespace DirectedConvention variable {Contrib : Type} [PreorderBot Contrib] variable (G : Grid Contrib) /-- Changing only the delivery relation does not change the reception's grade, share, or actuality. The sower's identity is delivery data; reception typing reads the weld itself. -/ theorem reception_typing_ignores_sower (conditions₁ conditions₂ : G.Weld -> G.Weld -> Prop) (reception : G.Weld) : (G.withConditions conditions₁).grade reception.agent reception.call reception.response = (G.withConditions conditions₂).grade reception.agent reception.call reception.response ∧ (G.withConditions conditions₁).share reception = (G.withConditions conditions₂).share reception ∧ ((G.withConditions conditions₁).Actual reception ↔ (G.withConditions conditions₂).Actual reception) := ⟨G.grade_independent_of_conditions conditions₁ conditions₂ reception.agent reception.call reception.response, G.share_independent_of_conditions conditions₁ conditions₂ reception, Iff.rfl⟩ /-- Same-agent lines and cross-agent lines both fill the ordinary reach-back relation once the model supplies the delivery line. The actuality hypothesis records that the reception is a deed; the conclusion is just the shared first conjunct of the two delivery-regime predicates. -/ theorem waaReachBack_filled_either_regime {deed reception : G.Weld} (_hactual : G.Actual reception) : (SameAgentDelivery G deed reception → WaaReachBackFull G deed reception) ∧ (CrossAgentDelivery G deed reception → WaaReachBackFull G deed reception) := ⟨fun h => h.left, fun h => h.left⟩ /-- Other-power line: a cross-agent delivery line read in WAA vocabulary. -/ abbrev WaaTarikiLine (deed reception : G.Weld) : Prop := CrossAgentDelivery G deed reception /-- Self-power line: a same-agent delivery line read in WAA vocabulary. -/ abbrev WaaJirikiLine (deed reception : G.Weld) : Prop := SameAgentDelivery G deed reception end DirectedConvention end Grid /- ============================================================================== Tariki perfected limit model ============================================================================== -/ namespace TarikiCase open Grid open Grid.DirectedConvention inductive Being | invoker | name deriving DecidableEq inductive Call | heard deriving DecidableEq inductive Response | chime | receive deriving DecidableEq /-- A two-being model: the name chimes independent of the call, the invoker receives, and delivery sends the name's weld to every invoker reception. This checks grammar only; it asserts no Pure Land doctrine and no ranking of regimes. -/ def tarikiGrid : Grid Nat where Being := Being Call := Call Response := Response respondsTo b _ := match b with | .name => some Response.chime | .invoker => some Response.receive grade b _ _ := match b with | .name => 0 | .invoker => 1 conditions deed reception := deed.agent = Being.name ∧ reception.agent = Being.invoker def liveBefore : Config Nat := { tendency := 2 } /-- The fixed call-source weld. Its call is still carried by the weld; a quotation severed from its call would be quotable, never gradeable. -/ def nameWeld : tarikiGrid.Weld := ⟨Being.name, Call.heard, Response.chime⟩ def invokerReception : tarikiGrid.Weld := ⟨Being.invoker, Call.heard, Response.receive⟩ theorem nameWeld_actual : tarikiGrid.Actual nameWeld := rfl theorem invokerReception_actual : tarikiGrid.Actual invokerReception := rfl theorem liveBefore_not_atBot : ¬ AtBot liveBefore.tendency := by intro h exact Nat.not_succ_le_zero 1 h theorem name_responseInvariant : tarikiGrid.ResponseInvariant Being.name := by intro c₁ c₂ r₁ r₂ h₁ h₂ cases c₁ cases c₂ cases r₁ <;> cases r₂ <;> simp [tarikiGrid] at h₁ h₂ ⊢ theorem name_mountsSomewhere : tarikiGrid.MountsSomewhere Being.name := ⟨Call.heard, ⟨Response.chime, rfl⟩⟩ theorem name_not_stone : ¬ tarikiGrid.Stone Being.name := tarikiGrid.not_stone_of_mountsSomewhere Being.name name_mountsSomewhere theorem name_share_bot (w : tarikiGrid.Weld) (hagent : w.agent = Being.name) : tarikiGrid.share w = 0 := by cases w with | mk agent call response => cases hagent rfl theorem name_object_axis_entire (reception : tarikiGrid.Weld) (hagent : reception.agent = Being.invoker) : DeliveredTo tarikiGrid nameWeld reception := ⟨rfl, hagent⟩ /-- The fixed-call source lands at every actual invoker reception as a share-drop from `liveBefore`. This is the effective corner opposite `OrthogonalityNegative`: non-adaptivity does not by itself decide effectiveness. -/ theorem universal_fixed_call_lands_without_reading (reception : tarikiGrid.Weld) (hagent : reception.agent = Being.invoker) (hactual : tarikiGrid.Actual reception) : HasShareDropLanding tarikiGrid liveBefore nameWeld := by refine ⟨reception, ⟨⟨name_object_axis_entire reception hagent, hactual⟩, ?_⟩⟩ cases reception with | mk agent call response => cases hagent dsimp [Grid.IsShareDrop, Grid.share, tarikiGrid, liveBefore] constructor · show (1 : Nat) ≤ 2 decide · show ¬ (2 : Nat) ≤ 1 decide theorem name_to_invoker_tarikiLine : WaaTarikiLine tarikiGrid nameWeld invokerReception := by constructor · exact name_object_axis_entire invokerReception rfl · intro h cases h theorem fixed_call_landing_witness : HasShareDropLanding tarikiGrid liveBefore nameWeld := universal_fixed_call_lands_without_reading invokerReception rfl invokerReception_actual /-- The invoker's reception is an ordinary actual deed with ordinary live share, even though the delivery-regime is cross-agent. -/ theorem invoker_reception_is_deed : tarikiGrid.Actual invokerReception ∧ tarikiGrid.share invokerReception = 1 ∧ tarikiGrid.HasSelfPoleIndex invokerReception := by constructor · exact invokerReception_actual · constructor · rfl · intro hbot exact Nat.not_succ_le_zero 0 hbot end TarikiCase end WAA ===== FILE: WeldAndArrow/Doctrines/OtherPowerNegative.lean ===== /- ================================================================================ WeldAndArrow.Doctrines.OtherPowerNegative Negative witnesses for regime/share polemics ================================================================================ The positive module types same-agent and cross-agent delivery as regimes over the same act grammar. This sibling keeps the no-polemic clause honest: neither regime determines reception share, and reception share does not recover the regime. -/ import WeldAndArrow.Doctrines.OtherPower namespace WAA namespace OtherPowerNegative open Grid.DirectedConvention inductive Being | source | receiver deriving DecidableEq inductive Call | live | pole deriving DecidableEq inductive Response | response deriving DecidableEq /-- Delivery is total; reception share is controlled only by the call. -/ def regimeShareGrid : Grid Nat where Being := Being Call := Call Response := Response respondsTo _ _ := some Response.response grade _ c _ := match c with | .live => 1 | .pole => 0 conditions _ _ := True def sameLiveDeed : regimeShareGrid.Weld := ⟨Being.source, Call.live, Response.response⟩ def sameLiveReception : regimeShareGrid.Weld := ⟨Being.source, Call.live, Response.response⟩ def samePoleReception : regimeShareGrid.Weld := ⟨Being.source, Call.pole, Response.response⟩ def crossLiveDeed : regimeShareGrid.Weld := ⟨Being.source, Call.live, Response.response⟩ def crossLiveReception : regimeShareGrid.Weld := ⟨Being.receiver, Call.live, Response.response⟩ def crossPoleReception : regimeShareGrid.Weld := ⟨Being.receiver, Call.pole, Response.response⟩ theorem sameLiveLine : SameAgentDelivery regimeShareGrid sameLiveDeed sameLiveReception := ⟨True.intro, rfl⟩ theorem samePoleLine : SameAgentDelivery regimeShareGrid sameLiveDeed samePoleReception := ⟨True.intro, rfl⟩ theorem crossLiveLine : CrossAgentDelivery regimeShareGrid crossLiveDeed crossLiveReception := by constructor · exact True.intro · intro h cases h theorem crossPoleLine : CrossAgentDelivery regimeShareGrid crossLiveDeed crossPoleReception := by constructor · exact True.intro · intro h cases h /-- Cross-agent delivery and same-agent delivery each allow a live-share reception and a pole-class reception. The regime by itself therefore does not type the reception's share. -/ theorem regime_does_not_determine_share : (∃ deed reception, SameAgentDelivery regimeShareGrid deed reception ∧ regimeShareGrid.Actual reception ∧ ¬ AtBot (regimeShareGrid.share reception)) ∧ (∃ deed reception, SameAgentDelivery regimeShareGrid deed reception ∧ regimeShareGrid.Actual reception ∧ AtBot (regimeShareGrid.share reception)) ∧ (∃ deed reception, CrossAgentDelivery regimeShareGrid deed reception ∧ regimeShareGrid.Actual reception ∧ ¬ AtBot (regimeShareGrid.share reception)) ∧ (∃ deed reception, CrossAgentDelivery regimeShareGrid deed reception ∧ regimeShareGrid.Actual reception ∧ AtBot (regimeShareGrid.share reception)) := by refine ⟨?_, ?_, ?_, ?_⟩ · refine ⟨sameLiveDeed, sameLiveReception, sameLiveLine, rfl, ?_⟩ intro hbot exact Nat.not_succ_le_zero 0 hbot · refine ⟨sameLiveDeed, samePoleReception, samePoleLine, rfl, ?_⟩ exact Nat.le_refl 0 · refine ⟨crossLiveDeed, crossLiveReception, crossLiveLine, rfl, ?_⟩ intro hbot exact Nat.not_succ_le_zero 0 hbot · refine ⟨crossLiveDeed, crossPoleReception, crossPoleLine, rfl, ?_⟩ exact Nat.le_refl 0 /-- Equal reception share is compatible with both regimes, so the share value cannot recover whether the line was same-agent or cross-agent. -/ theorem share_does_not_determine_regime : ∃ sameDeed sameReception crossDeed crossReception, SameAgentDelivery regimeShareGrid sameDeed sameReception ∧ CrossAgentDelivery regimeShareGrid crossDeed crossReception ∧ regimeShareGrid.Actual sameReception ∧ regimeShareGrid.Actual crossReception ∧ regimeShareGrid.share sameReception = regimeShareGrid.share crossReception := by refine ⟨sameLiveDeed, sameLiveReception, crossLiveDeed, crossLiveReception, ?_⟩ exact ⟨sameLiveLine, crossLiveLine, rfl, rfl, rfl⟩ end OtherPowerNegative end WAA ===== FILE: WeldAndArrow/Doctrines/Sraddha.lean ===== /- ================================================================================ WeldAndArrow.Doctrines.Sraddha The checked sraddha conditional ================================================================================ The grid proves the implication. It does not discharge the antecedents and it does not assert the detached fourth-truth injunction in its own voice. The faith antecedent is abstracted to a testimony principle in `Doctrines/Faith.lean`; the conditional here remains the direct, non-testimonial route. -/ import WeldAndArrow.Doctrines.FourTruths namespace WAA namespace Grid namespace DirectedConvention variable {Contrib : Type} [PreorderBot Contrib] variable (G : Grid Contrib) /-- The receiver-side aversion context: a live prior tendency together with an actual live-mismatch reception. No imported desire primitive is added. -/ structure WaaAversionContext (before : Config Contrib) (reception : G.Weld) where liveBefore : ¬ AtBot before.tendency mismatchLive : G.WaaMismatchLive reception theorem actual_of_waaAversionContext {before : Config Contrib} {reception : G.Weld} (h : WaaAversionContext G before reception) : G.Actual reception := h.mismatchLive.left theorem hasSelfPoleIndex_of_waaAversionContext {before : Config Contrib} {reception : G.Weld} (h : WaaAversionContext G before reception) : G.HasSelfPoleIndex reception := h.mismatchLive.right /-- Given faith-shaped closure, delivery, and the receiver's live aversion context, the share-drop landing follows. -/ theorem waa_path_landing {g : G.Being} {before : Config Contrib} {deed reception : G.Weld} (hfaith : WaaFullyEnlightened G g) (hdeed : deed.agent = g) (hdel : DeliveredTo G deed reception) (hctx : WaaAversionContext G before reception) : HasShareDropLanding G before deed := hfaith.right before deed reception hdeed hctx.liveBefore hdel /-- The fourth-truth ought as an implication type only. The detached consequent appears nowhere in this definition. -/ def WaaPathOught (g : G.Being) (before : Config Contrib) (deed reception : G.Weld) : Prop := WaaFullyEnlightened G g → deed.agent = g → DeliveredTo G deed reception → WaaAversionContext G before reception → HasShareDropLanding G before deed /-- The grid proves only the conditional: faith, delivery, and live aversion imply the landing. -/ theorem waaPathOught_conditional (g : G.Being) (before : Config Contrib) (deed reception : G.Weld) : WaaPathOught G g before deed reception := by intro hfaith hdeed hdel hctx exact waa_path_landing G hfaith hdeed hdel hctx /-- At the pole-class, no share-drop landing can be constructed for any deed. -/ theorem no_waa_path_at_pole {before : Config Contrib} (hbot : AtBot before.tendency) (deed : G.Weld) : ¬ HasShareDropLanding G before deed := by rintro ⟨reception, hland⟩ exact G.not_isShareDrop_of_tendency_atBot hbot reception hland.right /-- At the pole-class, the live-aversion antecedent itself fails. -/ theorem no_waa_aversion_context_at_pole {before : Config Contrib} (hbot : AtBot before.tendency) (reception : G.Weld) : ¬ WaaAversionContext G before reception := fun hctx => hctx.liveBefore hbot namespace BeingConvention namespace GridConvention /-- The checked conditional is a grammatical verdict item. -/ def WaaConditionalVoice : ErrorGrade := ErrorGrade.verdict /-- The detached injunction is only displayable as shortfall-voiced. -/ def WaaDetachedOughtVoice : ErrorGrade := ErrorGrade.shortfall theorem waa_conditional_voice_assertable : ErrorGrade.voice WaaConditionalVoice = VerdictVoice.assertable := rfl theorem waa_detached_ought_voice_displayable : ErrorGrade.voice WaaDetachedOughtVoice = VerdictVoice.displayable := rfl end GridConvention end BeingConvention end DirectedConvention end Grid end WAA ===== FILE: WeldAndArrow/Doctrines/SraddhaNegative.lean ===== /- ================================================================================ WeldAndArrow.Doctrines.SraddhaNegative Negative witnesses for the sraddha conditional ================================================================================ Reading and motivation: Identification/Commentary.lean, C.4. -/ import WeldAndArrow.Doctrines.Sraddha namespace WAA /- ============================================================================== Negative witnesses: both antecedents matter ============================================================================== -/ namespace SraddhaNegative open Grid.DirectedConvention inductive Being | sraddha | receiver inductive Call | call inductive Response | response /-- A responsive terminus whose delivered deed has no share-drop landing for the receiver's live prior tendency. -/ def zeroEffectGrid : Grid Nat where Being := Being Call := Call Response := Response respondsTo _ _ := some Response.response grade b _ _ := match b with | .sraddha => 0 | .receiver => 1 conditions deed reception := deed.agent = Being.sraddha ∧ reception.agent = Being.receiver def liveBefore : Config Nat := { tendency := 1 } def poleBefore : Config Nat := { tendency := 0 } def deed : zeroEffectGrid.Weld := ⟨Being.sraddha, Call.call, Response.response⟩ def reception : zeroEffectGrid.Weld := ⟨Being.receiver, Call.call, Response.response⟩ theorem liveBefore_not_atBot : ¬ AtBot liveBefore.tendency := by intro h exact Nat.not_succ_le_zero 0 h theorem poleBefore_atBot : AtBot poleBefore.tendency := Nat.le_refl 0 theorem reception_actual : zeroEffectGrid.Actual reception := rfl theorem delivered : DeliveredTo zeroEffectGrid deed reception := ⟨rfl, rfl⟩ theorem reception_hasSelfPoleIndex : zeroEffectGrid.HasSelfPoleIndex reception := by intro hbot exact Nat.not_succ_le_zero 0 hbot theorem aversionContext : WaaAversionContext zeroEffectGrid liveBefore reception := { liveBefore := liveBefore_not_atBot mismatchLive := ⟨reception_actual, reception_hasSelfPoleIndex⟩ } theorem sraddha_responsiveTerminus : zeroEffectGrid.ResponsiveTerminus Being.sraddha := by constructor · intro _c exact ⟨Response.response, rfl⟩ · intro _c _r _hresp exact Nat.le_refl 0 theorem not_hasShareDropLanding_liveBefore : ¬ HasShareDropLanding zeroEffectGrid liveBefore deed := by rintro ⟨received, hland⟩ have hreceiver : received.agent = Being.receiver := hland.left.left.right have hdrop : Strict (zeroEffectGrid.share received) liveBefore.tendency := hland.right have hstrict : Strict (1 : Nat) 1 := by simpa [zeroEffectGrid, Grid.share, liveBefore, hreceiver] using hdrop exact strict_irrefl (1 : Nat) hstrict theorem not_waaFullyEnlightened : ¬ WaaFullyEnlightened zeroEffectGrid Being.sraddha := by intro hfaith exact not_hasShareDropLanding_liveBefore (hfaith.right liveBefore deed reception rfl liveBefore_not_atBot delivered) /-- Dropping the faith conjunct leaves delivery and aversion insufficient. -/ theorem drop_faith_antecedent_fails : zeroEffectGrid.ResponsiveTerminus Being.sraddha ∧ DeliveredTo zeroEffectGrid deed reception ∧ WaaAversionContext zeroEffectGrid liveBefore reception ∧ ¬ HasShareDropLanding zeroEffectGrid liveBefore deed := ⟨sraddha_responsiveTerminus, delivered, aversionContext, not_hasShareDropLanding_liveBefore⟩ theorem not_hasShareDropLanding_poleBefore : ¬ HasShareDropLanding zeroEffectGrid poleBefore deed := no_waa_path_at_pole zeroEffectGrid poleBefore_atBot deed /-- Dropping the aversion conjunct leaves a pole-prior case where no share-drop landing is constructible. -/ theorem drop_aversion_antecedent_fails : AtBot poleBefore.tendency ∧ DeliveredTo zeroEffectGrid deed reception ∧ ¬ WaaAversionContext zeroEffectGrid poleBefore reception ∧ ¬ HasShareDropLanding zeroEffectGrid poleBefore deed := ⟨poleBefore_atBot, delivered, no_waa_aversion_context_at_pole zeroEffectGrid poleBefore_atBot reception, not_hasShareDropLanding_poleBefore⟩ end SraddhaNegative /- ============================================================================== Sraddha orthogonality countermodel ============================================================================== -/ namespace OrthogonalityNegative open Grid.DirectedConvention /-- The same zero-effectiveness witness used by `SraddhaNegative`: a responsive terminus whose delivered deed does not land as a share-drop for the live receiver context. -/ abbrev zeroEffectGrid : Grid Nat := SraddhaNegative.zeroEffectGrid theorem responsiveTerminus_with_no_shareDropLanding : zeroEffectGrid.ResponsiveTerminus SraddhaNegative.Being.sraddha ∧ ¬ HasShareDropLanding zeroEffectGrid SraddhaNegative.liveBefore SraddhaNegative.deed := ⟨SraddhaNegative.sraddha_responsiveTerminus, SraddhaNegative.not_hasShareDropLanding_liveBefore⟩ theorem terminus_not_waaFullyEnlightened : zeroEffectGrid.Terminus SraddhaNegative.Being.sraddha ∧ ¬ WaaFullyEnlightened zeroEffectGrid SraddhaNegative.Being.sraddha := ⟨SraddhaNegative.sraddha_responsiveTerminus.right, SraddhaNegative.not_waaFullyEnlightened⟩ /-- `WaaFullyEnlightened` is strictly stronger than terminus typing: it implies terminus, and this concrete responsive terminus still fails the shortfall-closure conjunct. -/ theorem waaFullyEnlightened_stronger_than_terminus : (WaaFullyEnlightened zeroEffectGrid SraddhaNegative.Being.sraddha → zeroEffectGrid.Terminus SraddhaNegative.Being.sraddha) ∧ zeroEffectGrid.Terminus SraddhaNegative.Being.sraddha ∧ ¬ WaaFullyEnlightened zeroEffectGrid SraddhaNegative.Being.sraddha := by constructor · intro h exact (responsiveTerminus_of_waaFullyEnlightened zeroEffectGrid h).right · exact terminus_not_waaFullyEnlightened end OrthogonalityNegative end WAA ===== FILE: WeldAndArrow/Doctrines/SuddenGradual.lean ===== /- ================================================================================ WeldAndArrow.Doctrines.SuddenGradual Sudden and gradual arrivals as thin readings over re-pitch machinery ================================================================================ The doctrine-facing vocabulary here names shapes already permitted by the signature: one received weld can arrive at the pole, and a finite run can do so in stages. No rate preference or stored altitude is added. -/ import WeldAndArrow.Signature import WeldAndArrow.Consequences.Basic import WeldAndArrow.Consequences.Taxonomy import WeldAndArrow.Doctrines.Correlations namespace WAA namespace Grid variable {Contrib : Type} [PreorderBot Contrib] variable (G : Grid Contrib) /- ============================================================================== Sudden and gradual arrival shapes ============================================================================== -/ /-- Sudden arrival, as a one-step received weld: an actual share-drop moves a live prior tendency to the pole-class in one re-pitch. -/ def WaaSuddenArrival (before : Config Contrib) (received : G.Weld) : Prop := G.Actual received ∧ ¬ AtBot before.tendency ∧ G.IsShareDrop before received ∧ AtBot ((G.rePitch before received).tendency) /-- Re-pitch a finite list of received welds from left to right. -/ def rePitchRun (before : Config Contrib) (run : List G.Weld) : Config Contrib := run.foldl (fun cfg received => G.rePitch cfg received) before @[simp] theorem rePitchRun_nil (before : Config Contrib) : G.rePitchRun before [] = before := rfl @[simp] theorem rePitchRun_cons (before : Config Contrib) (received : G.Weld) (rest : List G.Weld) : G.rePitchRun before (received :: rest) = G.rePitchRun (G.rePitch before received) rest := rfl /-- Gradual arrival, as a staged share-drop run that eventually reaches the pole-class. This is only the grid-legal face: a run can be staged; no stored attainment or rate preference is introduced. -/ def WaaGradualArrival (before : Config Contrib) (run : List G.Weld) : Prop := G.ShareDropRun before run ∧ run.length ≥ 2 ∧ ¬ AtBot before.tendency ∧ AtBot ((G.rePitchRun before run).tendency) /- ============================================================================== Rate invisibility ============================================================================== -/ /-- The post-reception configuration is blind to the prior rate-history. A sudden arrival and a gradual arrival ending in the same received weld hand the field the same configuration; this is the precise sense in which the grid prefers no rate. -/ theorem rate_invisible_to_config (before₁ before₂ : Config Contrib) (received : G.Weld) : G.rePitch before₁ received = G.rePitch before₂ received := G.rePitch_forgets before₁ before₂ received theorem rePitchRun_append_singleton (before : Config Contrib) (run : List G.Weld) (last : G.Weld) : G.rePitchRun before (run ++ [last]) = G.rePitch (G.rePitchRun before run) last := by induction run generalizing before with | nil => rfl | cons received rest ih => change G.rePitchRun (G.rePitch before received) (rest ++ [last]) = G.rePitch (G.rePitchRun (G.rePitch before received) rest) last exact ih (G.rePitch before received) /-- Run histories that share their final received weld have the same final configuration, however different their earlier rates or stages were. -/ theorem rePitchRun_forgets_same_final (before₁ before₂ : Config Contrib) (run₁ run₂ : List G.Weld) (last : G.Weld) : G.rePitchRun before₁ (run₁ ++ [last]) = G.rePitchRun before₂ (run₂ ++ [last]) := by rw [G.rePitchRun_append_singleton before₁ run₁ last, G.rePitchRun_append_singleton before₂ run₂ last] exact G.rePitch_forgets (G.rePitchRun before₁ run₁) (G.rePitchRun before₂ run₂) last /-- Any score that factors through the final configuration agrees across run histories that share their final received weld. -/ theorem score_of_rePitchRun_constant_of_same_final {α : Type} (score : Config Contrib -> α) (before₁ before₂ : Config Contrib) (run₁ run₂ : List G.Weld) (last : G.Weld) : score (G.rePitchRun before₁ (run₁ ++ [last])) = score (G.rePitchRun before₂ (run₂ ++ [last])) := by rw [G.rePitchRun_append_singleton before₁ run₁ last, G.rePitchRun_append_singleton before₂ run₂ last] exact G.accumulated_attainment_constant_of_same_final score (G.rePitchRun before₁ run₁) (G.rePitchRun before₂ run₂) last end Grid /- ============================================================================== Concrete witnesses ============================================================================== -/ /-- The existing clock-grid subitism witness, named in its doctrine-facing one-step arrival form. -/ theorem waaSuddenArrival_witness : ∃ (before : Config Nat) (received : clockGrid.Weld), clockGrid.WaaSuddenArrival before received := by refine ⟨{ tendency := 5 }, ⟨Clock.adaptive, Listener.present, Chime.chime⟩, ?_⟩ constructor · rfl · constructor · dsimp [AtBot, shareBot] show ¬ (5 : Nat) ≤ 0 decide · constructor · dsimp [Grid.IsShareDrop, Grid.share, clockGrid] constructor · show (0 : Nat) ≤ 5 decide · show ¬ (5 : Nat) ≤ 0 decide · exact clockGrid.rePitch_tendency_atBot_of_terminus_response { tendency := 5 } adaptive_is_terminus rfl /-- In the register clock, a two-step run can drop from a live tendency to an intermediate live rung and then to the pole-class. -/ theorem waaGradualArrival_witness : ∃ (before : Config Nat) (run : List registerClockGrid.Weld), registerClockGrid.WaaGradualArrival before run := by let first : registerClockGrid.Weld := ⟨(2 : Nat), (), (3 : Nat)⟩ let second : registerClockGrid.Weld := ⟨(0 : Nat), (), (1 : Nat)⟩ refine ⟨{ tendency := 5 }, [first, second], ?_⟩ constructor · refine Grid.ShareDropRun.cons ?_ ?_ ?_ · rfl · dsimp [Grid.IsShareDrop, Grid.share, registerClockGrid, first] constructor · show (2 : Nat) ≤ 5 decide · show ¬ (5 : Nat) ≤ 2 decide · refine Grid.ShareDropRun.cons ?_ ?_ ?_ · rfl · dsimp [Grid.IsShareDrop, Grid.share, Grid.rePitch, registerClockGrid, first, second] constructor · show (0 : Nat) ≤ 2 decide · show ¬ (2 : Nat) ≤ 0 decide · exact Grid.ShareDropRun.nil _ · constructor · decide · constructor · dsimp [AtBot, shareBot] show ¬ (5 : Nat) ≤ 0 decide · dsimp [Grid.rePitchRun, Grid.rePitch, Grid.share, registerClockGrid, first, second, AtBot, shareBot] show (0 : Nat) ≤ 0 decide end WAA ===== FILE: WeldAndArrow/Doctrines/SuddenGradualNegative.lean ===== /- ================================================================================ WeldAndArrow.Doctrines.SuddenGradualNegative Negative witnesses for sudden/gradual frequency claims ================================================================================ The positive module shows that sudden and gradual arrivals are grid-legal shapes. This module keeps that claim honest: response and grade data do not determine whether the far-re-pitching delivery line is supplied. -/ import WeldAndArrow.Doctrines.SuddenGradual namespace WAA namespace SuddenGradualNegative open Grid.DirectedConvention /- ============================================================================== Delivery frequency is not recovered from response/grade data ============================================================================== -/ def deliveredClockGrid : Grid Nat := clockGrid.withConditions (fun _ _ => True) def undeliveredClockGrid : Grid Nat := clockGrid.withConditions (fun _ _ => False) def deliveredPole : deliveredClockGrid.Weld := ⟨Clock.adaptive, Listener.present, Chime.chime⟩ def undeliveredPole : undeliveredClockGrid.Weld := ⟨Clock.adaptive, Listener.present, Chime.chime⟩ abbrev ClockResponseGradeData : Type := (Clock -> Listener -> Option Chime) × (Clock -> Listener -> Chime -> Nat) def deliveredResponseGradeData : ClockResponseGradeData := (deliveredClockGrid.respondsTo, deliveredClockGrid.grade) def undeliveredResponseGradeData : ClockResponseGradeData := (undeliveredClockGrid.respondsTo, undeliveredClockGrid.grade) theorem response_grade_data_agree : deliveredResponseGradeData = undeliveredResponseGradeData := rfl theorem share_data_agree : ∀ w : clockGrid.Weld, deliveredClockGrid.share w = undeliveredClockGrid.share w := by intro w exact clockGrid.share_independent_of_conditions (fun _ _ => True) (fun _ _ => False) w theorem grade_data_agree : ∀ b c r, deliveredClockGrid.grade b c r = undeliveredClockGrid.grade b c r := by intro b c r exact clockGrid.grade_independent_of_conditions (fun _ _ => True) (fun _ _ => False) b c r theorem deliveredPole_has_delivery : ∃ reception : deliveredClockGrid.Weld, DeliveredTo deliveredClockGrid deliveredPole reception := ⟨deliveredPole, True.intro⟩ theorem undeliveredPole_no_delivery : ¬ ∃ reception : undeliveredClockGrid.Weld, DeliveredTo undeliveredClockGrid undeliveredPole reception := by rintro ⟨_reception, hdelivered⟩ exact hdelivered /-- No predicate recovered from response/grade data can determine whether the pole-reaching weld is delivered. The two grids agree on response and grade data but disagree on delivery. -/ theorem no_response_grade_recovery_of_pole_delivery : ¬ ∃ recover : ClockResponseGradeData -> Prop, (recover deliveredResponseGradeData ↔ ∃ reception : deliveredClockGrid.Weld, DeliveredTo deliveredClockGrid deliveredPole reception) ∧ (recover undeliveredResponseGradeData ↔ ∃ reception : undeliveredClockGrid.Weld, DeliveredTo undeliveredClockGrid undeliveredPole reception) := by rintro ⟨recover, hdelivered, hundelivered⟩ have hrecoveredDelivered : recover deliveredResponseGradeData := hdelivered.mpr deliveredPole_has_delivery have hrecoveredUndelivered : recover undeliveredResponseGradeData := by rw [← response_grade_data_agree] exact hrecoveredDelivered exact undeliveredPole_no_delivery (hundelivered.mp hrecoveredUndelivered) /-- Honesty clause for the sudden/gradual block: the grid can witness sudden arrival as a possibility, but response/grade data alone do not determine whether the relevant delivery line is present, much less how often. -/ theorem subitism_frequency_underdetermined : deliveredResponseGradeData = undeliveredResponseGradeData ∧ (∀ w : clockGrid.Weld, deliveredClockGrid.share w = undeliveredClockGrid.share w) ∧ (∀ b c r, deliveredClockGrid.grade b c r = undeliveredClockGrid.grade b c r) ∧ (∃ reception : deliveredClockGrid.Weld, DeliveredTo deliveredClockGrid deliveredPole reception) ∧ ¬ (∃ reception : undeliveredClockGrid.Weld, DeliveredTo undeliveredClockGrid undeliveredPole reception) ∧ ¬ ∃ recover : ClockResponseGradeData -> Prop, (recover deliveredResponseGradeData ↔ ∃ reception : deliveredClockGrid.Weld, DeliveredTo deliveredClockGrid deliveredPole reception) ∧ (recover undeliveredResponseGradeData ↔ ∃ reception : undeliveredClockGrid.Weld, DeliveredTo undeliveredClockGrid undeliveredPole reception) := ⟨response_grade_data_agree, share_data_agree, grade_data_agree, deliveredPole_has_delivery, undeliveredPole_no_delivery, no_response_grade_recovery_of_pole_delivery⟩ end SuddenGradualNegative end WAA ===== FILE: WeldAndArrow/Exposition.lean ===== import WeldAndArrow.Exposition.Basic import WeldAndArrow.Exposition.Docs import WeldAndArrow.Exposition.ResidueLedger import WeldAndArrow.Exposition.Verify ===== FILE: WeldAndArrow/Exposition/Basic.lean ===== import Lean namespace WAA.Exposition /-! Basic document data for the prose-facing Exposition layer. The layer is deliberately downstream of the checked grid library: documents may cite declarations, glossary terms, and other documents, but they define no grid vocabulary and prove no grid facts. -/ abbrev DocId := String inductive Inline where | text (s : String) | anchor (name : Lean.Name) | code (s : String) | term (s : String) | xref (target : DocId) (label : String) deriving Repr inductive ClaimStatus where | checked | proseBound (reason : String) deriving Repr structure Claim where inlines : List Inline status : ClaimStatus anchors : List Lean.Name := [] deriving Repr inductive Block where | para (inlines : List Inline) | claimPara (claim : Claim) | quote (blocks : List Block) | table (headers : List String) (rows : List (List String)) | list (items : List (List Inline)) | heading (level : Nat) (inlines : List Inline) | raw (markdown : String) deriving Repr structure Section where id : DocId title : String blocks : List Block := [] deriving Repr structure Doc where id : DocId title : String output : String source : String summary : String := "" blocks : List Block := [] sections : List Section := [] footer : List Block := [] deriving Repr def markdownEscape (s : String) : String := (((s.replace "\\" "\\\\").replace "|" "\\|").replace "\n" " ").replace "\r" " " def joinComma : List String -> String | [] => "" | x :: rest => rest.foldl (fun acc item => acc ++ ", " ++ item) x def renderAnchors (anchors : List Lean.Name) : String := match anchors with | [] => "—" | names => joinComma (names.map (fun name => "`" ++ name.toString ++ "`")) def renderInline : Inline -> String | .text s => s | .anchor name => "`" ++ name.toString ++ "`" | .code s => "`" ++ s ++ "`" | .term s => s | .xref target label => "[" ++ label ++ "](" ++ target ++ ")" def renderInlines (inlines : List Inline) : String := String.intercalate "" (inlines.map renderInline) def renderClaim (claim : Claim) : String := let body := renderInlines claim.inlines match claim.status with | .checked => match claim.anchors with | [] => body | anchors => body ++ " *(checked: " ++ renderAnchors anchors ++ ")*" | .proseBound reason => let anchorSuffix := match claim.anchors with | [] => "" | anchors => "; anchors: " ++ renderAnchors anchors body ++ " *(prose-bound: " ++ reason ++ anchorSuffix ++ ")*" def renderTableRow (cells : List String) : String := "| " ++ String.intercalate " | " (cells.map markdownEscape) ++ " |" def renderTable (headers : List String) (rows : List (List String)) : String := let header := renderTableRow headers let rule := renderTableRow (headers.map (fun _ => "---")) String.intercalate "\n" (header :: rule :: rows.map renderTableRow) mutual def renderBlock : Block -> String | .para inlines => renderInlines inlines | .claimPara claim => renderClaim claim | .quote blocks => let body := renderBlocks blocks String.intercalate "\n" ((body.splitOn "\n").map (fun line => "> " ++ line)) | .table headers rows => renderTable headers rows | .list items => String.intercalate "\n" (items.map (fun item => "- " ++ renderInlines item)) | .heading level inlines => String.ofList (List.replicate level '#') ++ " " ++ renderInlines inlines | .raw markdown => markdown def renderBlocks : List Block -> String | [] => "" | blocks => String.intercalate "\n\n" (blocks.map renderBlock) end def renderSection (sec : Section) : String := "## " ++ sec.title ++ "\n\n" ++ renderBlocks sec.blocks def generatedHeader (doc : Doc) : String := "\n\n" def renderDoc (doc : Doc) : String := let bodyParts := [renderBlocks doc.blocks] ++ doc.sections.map renderSection ++ [renderBlocks doc.footer] let body := String.intercalate "\n\n" (bodyParts.filter (fun part => part != "")) generatedHeader doc ++ body namespace Inline def anchors : Inline -> List Lean.Name | .anchor name => [name] | _ => [] def terms : Inline -> List String | .term t => [t] | _ => [] def xrefs : Inline -> List DocId | .xref target _ => [target] | _ => [] end Inline namespace Claim def allAnchors (claim : Claim) : List Lean.Name := claim.anchors ++ claim.inlines.flatMap Inline.anchors def terms (claim : Claim) : List String := claim.inlines.flatMap Inline.terms def xrefs (claim : Claim) : List DocId := claim.inlines.flatMap Inline.xrefs end Claim mutual def Block.anchors : Block -> List Lean.Name | .para inlines => inlines.flatMap Inline.anchors | .claimPara claim => claim.allAnchors | .quote blocks => Block.listAnchors blocks | .table _ _ => [] | .list items => items.flatMap (fun item => item.flatMap Inline.anchors) | .heading _ inlines => inlines.flatMap Inline.anchors | .raw _ => [] def Block.listAnchors : List Block -> List Lean.Name | [] => [] | block :: blocks => block.anchors ++ Block.listAnchors blocks end mutual def Block.claims : Block -> List Claim | .claimPara claim => [claim] | .quote blocks => Block.listClaims blocks | _ => [] def Block.listClaims : List Block -> List Claim | [] => [] | block :: blocks => block.claims ++ Block.listClaims blocks end mutual def Block.terms : Block -> List String | .para inlines => inlines.flatMap Inline.terms | .claimPara claim => claim.terms | .quote blocks => Block.listTerms blocks | .table _ _ => [] | .list items => items.flatMap (fun item => item.flatMap Inline.terms) | .heading _ inlines => inlines.flatMap Inline.terms | .raw _ => [] def Block.listTerms : List Block -> List String | [] => [] | block :: blocks => block.terms ++ Block.listTerms blocks end mutual def Block.xrefs : Block -> List DocId | .para inlines => inlines.flatMap Inline.xrefs | .claimPara claim => claim.xrefs | .quote blocks => Block.listXrefs blocks | .table _ _ => [] | .list items => items.flatMap (fun item => item.flatMap Inline.xrefs) | .heading _ inlines => inlines.flatMap Inline.xrefs | .raw _ => [] def Block.listXrefs : List Block -> List DocId | [] => [] | block :: blocks => block.xrefs ++ Block.listXrefs blocks end namespace Section def anchors (sec : Section) : List Lean.Name := Block.listAnchors sec.blocks def claims (sec : Section) : List Claim := Block.listClaims sec.blocks def terms (sec : Section) : List String := Block.listTerms sec.blocks def xrefs (sec : Section) : List DocId := Block.listXrefs sec.blocks end Section namespace Doc def anchors (doc : Doc) : List Lean.Name := Block.listAnchors doc.blocks ++ doc.sections.flatMap Section.anchors ++ Block.listAnchors doc.footer def claims (doc : Doc) : List Claim := Block.listClaims doc.blocks ++ doc.sections.flatMap Section.claims ++ Block.listClaims doc.footer def terms (doc : Doc) : List String := Block.listTerms doc.blocks ++ doc.sections.flatMap Section.terms ++ Block.listTerms doc.footer def xrefs (doc : Doc) : List DocId := Block.listXrefs doc.blocks ++ doc.sections.flatMap Section.xrefs ++ Block.listXrefs doc.footer end Doc end WAA.Exposition ===== FILE: WeldAndArrow/Exposition/Docs.lean ===== import WeldAndArrow.Exposition.Glossary import WeldAndArrow.Exposition.Index import WeldAndArrow.Exposition.Theory import WeldAndArrow.Exposition.Theorems import WeldAndArrow.Exposition.Identification import WeldAndArrow.Exposition.Formalization.Reading import WeldAndArrow.Exposition.Thesis namespace WAA.Exposition def allDocs : List Doc := [ indexDoc, theoryDoc, theoremsDoc, identificationDoc, formalizationDoc, WAA.glossaryDoc ] example : allDocs.length = 6 := rfl end WAA.Exposition ===== FILE: WeldAndArrow/Exposition/Formalization/Reading.lean ===== import WeldAndArrow.Exposition.Basic namespace WAA.Exposition def formalizationBody : String := r#"# A Plain-English Reading of the Lean Theorems **Scope.** This document states, in plain English, what the Lean declarations in `Signature/*`, `Consequences/{Basic,Taxonomy,Ladder,ContentRows}.lean`, `Doctrines/*`, `Identification/*`, and `Meta/*` assert. It reads the checked Lean surface: definitions, theorem statements, and proof status where that matters. Interpretive prose is generated from `WeldAndArrow/Exposition/*` and remains secondary to the formal statements. For the canonical input-side assumption list, see [Assumptions.md](Assumptions.md); the compile-checked pins live in `WeldAndArrow/Signature/Assumptions.lean`. The project is pinned to `leanprover/lean4:v4.31.0` in `lean-toolchain`. **Conventions.** A theorem proved by `rfl` or `Iff.rfl` is true by unfolding definitions. A theorem whose proof is a projection, contradiction, or witness assembly is described as such. A "weld" is always the triple `RawWeld` / `G.Weld`; "actual" always means the equation `respondsTo w.agent w.call = some w.response`. Identifiers beginning `Waa` mark system-POV readings: what the concept looks like from this grid, not what the concept is in detached doctrinal voice. The single marker covers ownership, appropriation, whose-ness, reach-back, sowing-side aiming, four-truths mismatch vocabulary, and sraddha conditional vocabulary. Doctrine words live in module names and prose; checked reading identifiers use `Waa`. The unprefixed vocabulary is neutral order/delivery vocabulary, including Row-2 index-placement names such as `HasSelfPoleIndex`, `selfPoleIndex`, and `Tier.hasLiveShare`. In generated or prose presentations, the `Signature` layer is titled **Theory** and the `Consequences` layer is titled **Theorems**, matching the paper's part titles. The Lean module names state the role; the prose names state the correspondence. `Grid.DirectedConvention` is the second marking. It contains vocabulary that reads direction into the direction-free relation `conditions`: delivery, landing, environs lines, share-drop lines, aiming, and the ownership-face predicates. The signature itself still carries no asymmetry, irreflexivity, or transitivity for `conditions`. Role-asymmetry is not temporal asymmetry: the `deed` and `reception` slots are different roles, but the reception slot means "where the welding happens", not "the later one". `Grid.DirectedConvention.TimeDirection` is an abbreviation of `Strict`; all strictness theorems apply to it transparently. The formal modules keep their comments mathematical and point to `Identification/Commentary.lean` C.1-C.12 for the paper-facing readings. The namespace tree now records ontological ordering. Floor/genjō and the bare signature sit outside the convention layers. `Grid.DirectedConvention` reads the arrow; `Grid.DirectedConvention.BeingConvention` reads fine tags as macro-scale beings; `Grid.DirectedConvention.BeingConvention.GridConvention` contains the pole-affirming row schema, the content-layer companion language, the ladder API, and the generated table-order data across the `Consequences` files. Names are placed by what their reading presupposes, not by what their definition consumes. --- ## 0. Preliminaries **Order structure.** `Preorder` is a hand-rolled reflexive and transitive relation `≼`; no totality and no antisymmetry are assumed. `Incomparable a b` means neither `a ≼ b` nor `b ≼ a`. `OrderEq a b` means `a ≼ b` and `b ≼ a`. `Strict a b` means `a ≼ b` and not `b ≼ a`. The preorder facts are: - `incomparable_symm`, `not_le_of_incomparable`, and `not_ge_of_incomparable`. - `strict_irrefl`: strict direction is never reflexive. - `strict_asymm` and `strict_trans`: strict direction is asymmetric and transitive as soon as it is read from the preorder. - `strict_of_le_of_strict` and `strict_of_strict_of_le`: strict comparison composes with weak comparison on either side. - `not_strict_of_orderEq` and `no_strict_of_all_orderEq`: order-equivalence kills direction, pointwise or carrier-wide. `PreorderBot` adds a designated bottom element, written `shareBot`, with `shareBot ≼ a` for every `a`. `AtBot a` means `a ≼ shareBot`. Since `shareBot ≼ a` is always available, `AtBot a` says that `a` is order-equivalent to the designated bottom. The pole is therefore an order-class, not identity with one token. The project stays self-contained and does not import Mathlib. Mathlib's counterparts are `Preorder`, `OrderBot`, and `IsBot`; local `AtBot` is the order-class of the bottom and plays the role Mathlib's `IsBot` would play for that chosen element. The basic bottom lemmas are: - `shareBot_le`: the designated bottom is below every value. - `atBot_shareBot`: `shareBot` is at the pole-class. - `atBot_of_eq_shareBot`: equality with the representative implies `AtBot`. - `orderEq_shareBot_of_atBot`, `atBot_of_orderEq_shareBot`, and `orderEq_shareBot_iff_atBot`: `AtBot a` and `OrderEq a shareBot` are equivalent formulations. **The signature.** A `Grid Contrib` consists of three types (`Being`, `Call`, `Response`), a response function `respondsTo`, a Row-2 display function `grade`, and a relation `conditions` on welds. `ConditionsEither w1 w2` is the symmetric closure `conditions w1 w2 ∨ conditions w2 w1`; `conditionsEither_symm` swaps the disjuncts. `ConditionsEitherChain` is the reflexive-transitive closure of that symmetric relation. There is no separate two-component drive object in the signature. A weld is the triple `⟨agent, call, response⟩`. `Actual w` means the response really is mounted. `index w` is `w.agent`. `share w` is `grade w.agent w.call w.response`. `HasSelfPoleIndex w` means `¬ AtBot (share w)`. `WaaAppropriates w` is definitionally the same proposition. `selfPoleIndex w h` returns `w.agent` and uses the proof argument only for typing. **Function-side predicates.** - `MountsAt b c`, `MountsSomewhere b`, and `RespondsToEveryCall b` record increasing response-function strength. - `Stone b` means no call receives a response from `b`. - `Terminus b` means every mounted response by `b` has pole-class grade. - `LiveTerminus b` adds that some response-function is present. - `ResponsiveTerminus b` says every call receives a pole-class response. - `AtPoleClass b` is `Stone b ∨ Terminus b`. - `ProbeConstant b cs` says any two actual responses by `b` at calls in `cs` have order-equivalent grades. - `ResponseInvariant b` and `ResponseVariesWithCall b` describe response-shape only. **BeingConvention definitions.** `BeingCoarsening G Macro` is a diagnosis-time projection `G.Being → Macro`; it is not stored in the signature. Under a coarsening `κ`: - `InFiber b w` means the weld's fine agent projects to macro tag `b`. - `SameFiber p q` is equality of projected macro tags. - `FiberInhabited b` and `ActualFiberInhabited b` are the non-vacuity guards. - `SentientTag b` means some fine tag in the fiber mounts a response somewhere. - `not_sentientTag_iff_fiber_all_stone` proves that non-sentience is exactly the all-stone fiber; there is no separate `InsentientTag`. - `FiberAtPole b`, `FiberAtPoleOn b cs`, `FiberAtPoleOnWithin b cs ts`, and `FiberAtPoleWithin b ts` are whole-fiber, call-class, product, and tag-region pole readings. `ActualFiberInhabitedWithin`, `LiveFiberAtPoleWithin`, and `SelfAptTagWithin` are the tag-axis live and self-apt companions. - `SelfAptTag b`, `LiveSelfAptTag b`, and `Patchy b` are the whole-fiber self-apt and mixed readings. - `fiberAtPole_of_fiber_termini`, `no_live_index_under_fiberAtPole`, `selfAptTag_indices_are_per_weld_only`, and the live exclusivity theorems are the checked fiber facts. - `SelfConditioningTag b` is the minimal internal delivery-line witness. `StrongSelfConditioningTag b` is defined as a shelved asymptote. - `Delegation b` packages an actual fine weld in the macro fiber; its share is definitionally the delegate weld's share. **DirectionConvention definitions.** `DirectionCoarsening G Tick` is the delivery-axis twin of `BeingCoarsening`: a diagnosis-time tick projection over welds, not a field of `Grid`. `SameTick` is tick equality and is symmetric; `ResolvedDelivery` is delivered across distinct ticks; `SubTickDelivery` is delivered inside one tick. `ResolutionBounded` is a model-supplied display coherence condition: same-tick welds have order-equivalent shares. It is not a legitimacy, pole, or sentience predicate. `no_timeDirection_within_tick` proves that sub-tick delivery carries no strict `TimeDirection`, and `no_timeDirection_of_resolutionBounded_subsingleton` is the one-tick limit over weld shares. Transposition leaves `SameTick` and `ResolutionBounded` unchanged while `transpose_subTickDelivery` reverses only the delivery line. **Configurations and share-drops.** `Config` has one field, `tendency : Contrib`; it stores no `Being`, no `Weld`, and no owner. `rePitch before received` returns the config with tendency `share received`; `before` is unused in the value. `IsShareDrop before received` means `Strict (share received) before.tendency`, i.e. `share received ≼ before.tendency` and not `before.tendency ≼ share received`. **DirectedConvention definitions.** The directional reading layer contains: - `WaaReachBackFull`, `DeliveredTo`, `NotDeliveredTo`, and `WaaAimedAt`. - `LandsAt`, `ObjectAxisStanding`, `LandsWithShareDrop`, and `HasShareDropLanding`. - `EnvironsLine` and `ShareDropLine`. - `ShortfallClosedAt`, `WaaFullyEnlightened`, `WaaAversionContext`, and `WaaPathOught`. - `WaaPathClaim`, `WaaFaithPrinciple`, and `WaaFaithOught`. - `WaaReportFace`, `WaaOwnershipFace`, `WaaVacuousOwnershipFace`, and `WaaDiachronicWhose`. All of these are definitions over `conditions`, `Actual`, `IsShareDrop`, and `WaaAppropriates`; none adds a new axiom to `conditions`. **Four truths and sraddha.** `WaaMismatchGrade w` is definitionally `share w`. `WaaMismatchLive w` means an actual occurrence with a live self-pole index; with actuality supplied, `waaMismatchLive_iff_hasSelfPoleIndex` gives the exact typing condition. `not_waaMismatchLive_of_stone` keeps stones outside the occurrence domain, and `waaMismatch_atBot_of_terminus_response` sends terminus responses to the pole-class. The fourth truth the grid can only display: Lean now proves the implication whose antecedents it never asserts. The detached injunction remains absent from the system's assertable voice. **Tiers and distinctions.** A `Tier` is `floor` or `actTime w`. `Tier.hasLiveShare` is `False` at `floor` and `HasSelfPoleIndex w` at `actTime w`. Distinctions, claim languages, recorded utterances, error grades, and generator outcomes define the separate/fuse diagnostic vocabulary over tiers. **Identification layer.** `StateToolFits w` means `¬ HasSelfPoleIndex w`; with the definitions above this is double-negated pole-class membership. The exact iff with `AtBot` therefore requires decidability of the one proposition `AtBot a`, not decidable equality on all of `Contrib`. --- ## 1. Signature Layer (`Signature/*`) `no_self_pole_index_of_atBot`: if `AtBot (share w)`, then `w` has no live self-pole index. This is direct contradiction with `HasSelfPoleIndex w := ¬ AtBot (share w)`. `no_self_pole_index_of_eq_shareBot`: equality `share w = shareBot` is first converted to `AtBot (share w)`, then the previous theorem applies. `selfPoleIndex_eq_agent_of_hasSelfPoleIndex`: the evidence-carried index is `w.agent`. Definitional (`rfl`). `strict_shareBot_of_hasSelfPoleIndex`: a live self-pole index gives `Strict shareBot (share w)`. The proof packages `shareBot_le` with the definition `HasSelfPoleIndex w := ¬ AtBot (share w)`. `strict_shareBot_iff_not_atBot`: being strictly above the designated bottom is equivalent to not being in the bottom order-class. `not_waaAppropriates_of_atBot` and `not_waaAppropriates_of_eq_shareBot`: the same no-index facts under the definitional name `WaaAppropriates`. `share_eq_grade_check`: `share w = grade w.agent w.call w.response`. Definitional (`rfl`). `atBot_of_terminus_response`: if `b` is a `Terminus` and `respondsTo b c = some r`, then the weld `⟨b, c, r⟩` has `AtBot` share. `no_self_pole_index_of_terminus_response` and `not_waaAppropriates_of_terminus_response`: a terminus response has no live self-pole index and does not WAA-appropriate. `stone_is_terminus_vacuously`: every `Stone` is a `Terminus`. This is vacuous: the response hypothesis in `Terminus` can never be satisfied for a stone. `AllStone` says every being in the grid is stone-typed. `DirectionVoid` says the contribution carrier has no strict comparisons anywhere. `not_stone_of_mountsSomewhere`, `liveTerminus_not_stone`, and `responsiveTerminus_live_of_call` are witness/projection facts over response function. `Grid.DirectedConvention.deliveredTo_or_not`: for a particular pair of welds, if `conditions deed reception` is decidable, then either `DeliveredTo G deed reception` or `NotDeliveredTo G deed reception`. `Grid.DirectedConvention.deliveredTo_iff_waaReachBackFull`: definitional (`Iff.rfl`), since both names are `conditions`. `Grid.DirectedConvention.objectAxisStanding_of_landsAt`: a landing gives object-axis standing, witnessed by the reception in hand. `Grid.DirectedConvention.objectAxisStanding_of_hasShareDropLanding`: a share-drop landing gives object-axis standing through its landing component. `not_collapse_of_obeysSeparateFuse`: the first clause of `ObeysSeparateFuse` contradicts the equivalence required by `Collapse` at any live tier. `not_freeze_of_obeysSeparateFuse`: the second clause of `ObeysSeparateFuse` at `floor` gives the equivalence denied by `Freeze`. `not_freeze_of_same_claim`: a distinction whose two sides are the same claim cannot freeze. `no_agent_recovery_of_field_collision`: if two distinct beings can actually produce the same call-response pair, no function from field residue `Call × Response` can correctly recover the agent for every actual weld. **`clockGrid`.** The concrete grid uses `Nat` with bottom `0`; `rigid` responds nowhere, `adaptive` responds with `chime` when the listener is present, `grade` is constantly `0`, and `conditions` is always false. - `rigid_is_stone`: `rigid` responds nowhere. - `adaptive_is_terminus`: `adaptive` is a terminus. - `adaptive_not_stone`: `adaptive` responds at `present`. - `clockGrid_function_share_split_witness`: the concrete grid contains a stone and a non-stone terminus. **`registerClockGrid`.** The second concrete grid uses natural-numbered fine registers as beings. Each register answers the tick by handing off to the next register; delivery follows that hand-off. `registerClockCoarsening` merges the fine registers into one macro tag at diagnosis-time. The checked facts are `registerClock_macro_sentient` and `registerClock_macro_selfConditioning`. **`backslideGrid` and `gradingCollisionGrid`.** `backslideGrid` has one being answering a gentle call at share `0` and a harsh call at share `5`, giving the concrete carrier for the same-being backsliding witnesses. `gradingCollisionGrid` has two actual welds with the same call-response residue and different shares, giving the concrete carrier for the cetana field-residue witness. --- ## 2. Consequences and Taxonomy (`Consequences/Basic.lean`, `Consequences/Taxonomy.lean`, `Consequences/Ladder.lean`, `Consequences/ContentRows.lean`) **Function/share and poles.** `share_eq_grade` is definitional. The response facts `mountsAt_of_actual`, `mountsSomewhere_of_actual`, `not_stone_of_actual`, `not_actual_of_stone`, `not_mountsSomewhere_of_stone`, and `not_stone_of_response` are direct witness/projection/contradiction consequences of `Actual`, `MountsAt`, and `Stone`. `atPoleClass_of_stone` and `atPoleClass_of_terminus` introduce the two disjuncts of `AtPoleClass`. `atPoleClass_and_not_stone_of_liveTerminus` combines the terminus disjunct with `liveTerminus_not_stone`. `not_stone_of_responsiveTerminus_of_call` uses the supplied call to get live function. **Re-pitch and share-drops.** `rePitch_tendency_eq_share` is definitional: the re-pitched tendency is the received weld's share. `isShareDrop_iff_rePitch_tendency_drop` is definitional after substituting the re-pitched tendency for `share received`. `rePitch_tendency_le_before_of_shareDrop` and `not_before_le_rePitch_tendency_of_shareDrop` project the two conjuncts of `IsShareDrop`. `rePitch_tendency_atBot_of_terminus_response` sends a terminus response into the pole-class. **Conditions and response replacement.** `withConditions` replaces only the delivery relation. Its `withConditions_respondsTo`, `withConditions_grade`, and `withConditions_share` lemmas are definitional, and `grade_independent_of_conditions` / `share_independent_of_conditions` state the cetana anchor: grade and share are blind to downstream delivery. Dually, `withRespondsTo` replaces only the response function; `withRespondsTo_grade`, `withRespondsTo_share`, and `withRespondsTo_conditions` are definitional. `staticized b` removes the responses of one being and leaves grade and delivery in place. The futility facts are `futility_delivery_loss_real`, `staticized_responseInvariant`, `futility_object_axis_subtraction_nil`, and `Grid.DirectedConvention.staticized_objectAxisStanding_iff`. **The environs lens.** The directional theorem block lives under `Grid.DirectedConvention`. `environsLine_of_shareDropLine`, `isShareDrop_of_shareDropLine`, and `deliveredTo_of_environsLine` are projections. `not_isShareDrop_of_tendency_atBot`: if the prior tendency is already `AtBot`, then no received weld is a strict share-drop against it. The proof uses `before.tendency ≼ shareBot ≼ share received` to contradict the second conjunct of `IsShareDrop`. `not_isShareDrop_of_eq_shareBot_tendency`: equality with the representative bottom is a bridge into the previous theorem. `Grid.DirectedConvention.no_shareDropLine_of_tendency_atBot`: with an `AtBot` prior tendency, no `ShareDropLine` exists, because its share-drop conjunct is impossible. `Grid.DirectedConvention.no_shareDropLine_of_eq_shareBot_tendency`: equality bridge into the previous theorem. `Grid.DirectedConvention.hasShareDropLanding_of_shareDropLine_actual`: a share-drop line whose reception is actual assembles the existential `HasShareDropLanding` witness. This is the checked core of effectiveness talk as display. `ShortfallClosedAt` states local, delivered-pair shortfall closure for a live prior tendency. `WaaFullyEnlightened` adds this universal closure conjunct to `ResponsiveTerminus`; `responsiveTerminus_of_waaFullyEnlightened` and `shortfallClosedAt_of_waaFullyEnlightened` project the two parts. **Delivery and share-drop landing.** The reach/aiming biconditionals are definitional (`Iff.rfl`). The remaining delivery theorems are projections from `LandsAt`, `LandsWithShareDrop`, or `HasShareDropLanding`, plus existential witnesses: - `deliveredTo_of_landsAt`, `actual_of_landsAt` - `landsAt_of_landsWithShareDrop`, `isShareDrop_of_landsWithShareDrop` - `deliveredTo_of_landsWithShareDrop`, `actual_of_landsWithShareDrop` - `exists_landsAt_of_hasShareDropLanding` - `exists_actual_reception_of_hasShareDropLanding` - `exists_shareDrop_reception_of_hasShareDropLanding` **Reception pairs.** `first_actual` and `second_actual` project stored proofs. `firstConditionsSecond_iff_deliveredTo` is definitional and states the pair's directed relation via `Grid.DirectedConvention.DeliveredTo`. The two `rePitchSequence_*_tendency` theorems are definitional and show the sequence's tendencies are the two weld shares. **Tiers and separate/fuse.** - `floor_has_no_live_share`: no live share at `floor`. - `actTime_hasLiveShare_iff_hasSelfPoleIndex`: definitional. - `not_actTime_hasLiveShare_of_atBot`: an act-time tier whose weld is at the pole-class has no live share. - `not_actTime_hasLiveShare_of_eq_shareBot`: equality bridge into the previous theorem. - `not_collapse_floor`, `hasLiveShare_of_collapse`, `hasLiveShare_of_separated`, `not_collapse_of_separated`, `fused_of_obeysSeparateFuse`, `separated_of_obeysSeparateFuse`, and `not_freeze_of_fused_floor` are the direct separate/fuse diagnostics. `answersCall_eq_weld_call` and `fitsOfferedTier_iff_trueAt` are definitional. `verdict_voice_assertable` and `shortfall_voice_displayable` confirm the two `ErrorGrade.voice` assignments. `waa_conditional_voice_assertable` and `waa_detached_ought_voice_displayable` pin the new conditional/detached split: the implication is verdict-voiced, while the detached injunction is only shortfall-voiced. **Generated table rows.** Under `Grid.DirectedConvention.BeingConvention.GridConvention`, `RowTag` names the schema-generated table rows, including the five `ConventionLayer` rows via `.layer`. `RowClaim` has `inForce r` and `denied r`, and `rowLanguage G` gives them pole-affirming semantics: at `floor` every row claim holds; at `actTime w` the conventional side holds, while the denial side holds exactly when `AtBot (G.share w)`. `rowOf G r` instantiates `Distinction G` from this language. `rowOf_separated_at_live`, `rowOf_collapse_self_refuting`, `rowOf_not_freeze`, `denied_holds_only_where_no_live_share`, `rowOf_errorFree`, and `pole_validates_all_claims` are hypothesis-free. `rowOf_obeys` and `rowOf_obeys_iff_errorFree` carry only the local decidability/stability needed to turn non-live act-time into `AtBot`. `denied_misfits_live_offer` is the recorded-utterance check; `fox_utterance_misfits_live_offer` specializes it to the marquee fox row. The old pilot names are compatibility names for schema tags: `beforeAfterRow G`, `intraWeldArrowRow G`, `beingsRow G`, `gridLensRow G`, and `weldRow G` are `rowOf G (.layer ...)`; `doerDeedRow G` is the schema-only MMK 8 row. Their collapse and freeze names keep hypothesis-free statements; their `*_obeys` names carry the stability hypothesis. `tableOrder` records the full table shape as Lean data: nineteen schema rows, one ladder row, and six prose rows. Schema-row cell occupancy is also data now: `hasCollapseOccupant` and `hasFreezeOccupant` record where the paper's table has an occupant rather than a dash, and `perCallGlobal_empty_collapse_cell_anchor` checks the per-call/global dash without turning it into new grid semantics. **Concrete consequence witnesses.** The small model checks now include `shareZero_not_functionZero_witness`, `rung_not_pole_witness`, `backsliding_witness`, `backsliding_rePitchSequence_witness`, `standing_does_not_determine_dated`, `subitism_possibility_witness`, `cetana_grading_tracks_weld_not_field_witness`, `cetana_live_share_without_object_standing_witness`, `registerClock_staticized_zero_stone`, `registerClock_staticized_objectAxisStanding_iff`, and `pole_tier_buddha_inhabited`, with the fox run-through now checked in `FoxCase.foxGrid`. These are witness assemblies over the concrete grids, mostly by unfolding and `decide`. **Content-bearing rows.** `contentLayerLanguage` uses the same `LayerClaim` syntax but gives content to denials: no strict direction, no response variation with call, all beings stone, no live tier anywhere, or no actual welds. `contentBeforeAfterRow`, `contentIntraWeldArrowRow`, `contentBeingsRow`, `contentGridLensRow`, and `contentWeldRow` are the content rows. Their obedience theorems are conditional: `contentBeforeAfterRow_obeys_of_direction`, `contentIntraWeldArrowRow_obeys_of_variation`, `contentBeingsRow_obeys_of_being`, `contentGridLensRow_obeys_of_liveTier`, and `contentWeldRow_obeys_of_actual` require exactly the witness that makes the denial false at non-live act-time. These content rows keep the diagnostic live-side because their global denials cannot be made true by a particular pole-class weld; they answer aptness-to-hold, not truth-at-tier. `beings_denial_fits_only_floor` and `time_denial_unfit_for_appropriating_utterer` are utterance-level self-refutation results. The beings theorem uses the `RecordedUtterance` actuality field to get a non-stone utterer; the time theorem uses the live share as a strict direction witness. The intra-weld utterance theorem is the weaker schema-language live-tier check, `interior_order_denial_unfit_for_live_utterer`; one recorded utterance does not by itself supply two distinct responses. **Re-emptying ladder.** `LadderSide`, `reEmptied`, and `ladder` generate the next distinction from the previous one. `reEmptied_obeysSeparateFuse` proves that obedience propagates, while `ErrorFree`, `errorFree_of_obeys`, `reEmptied_obeys_of_errorFree`, `ladder_obeys_of_errorFree`, and `ladder_errorFree_of_errorFree` show the stronger refutation-only route above an error-free seed. `no_level_final_of_obeys`, `no_final_level_of_errorFree`, and `ladder_collapse_self_refuting` rule out freeze and collapse at generated levels. `beingsLadder`, `beforeAfterLadder`, `intraWeldArrowLadder`, `gridLensLadder`, `weldLadder`, and `doerDeedLadder` are schema seeds; their `_obeys_succ` facts are hypothesis-free, while all-level `*_obeys` names include the seed's stability hypothesis. `contentBeingsLadder` is the content instance under the non-stone aptness hypothesis. --- ## 3. Doctrines (`Doctrines/FourTruths.lean`, `Doctrines/Sraddha*.lean`, `Doctrines/Faith*.lean`, `Doctrines/Ethics*.lean`, `Doctrines/Deliberation.lean`, `Doctrines/Gradeability.lean`, `Doctrines/Ledger.lean`, `Doctrines/Correlations*.lean`, `Doctrines/SuddenGradual*.lean`, `Doctrines/OtherPower*.lean`, `Doctrines/Fetters*.lean`, `Doctrines/Factors*.lean`) `waaMismatchGrade_eq_share` is definitional. `waaMismatchGrade_le_of_share_le` is the ordinal covariation theorem: any share comparison is the corresponding mismatch-grade comparison. `WaaMismatchLive` is actual occurrence plus live self-pole index. `waaMismatchLive_iff_hasSelfPoleIndex` removes the actuality conjunct when the occurrence is already known actual. `not_waaMismatchLive_of_stone` uses `not_actual_of_stone`; `waaMismatch_atBot_of_terminus_response` reuses `atBot_of_terminus_response`. `WaaAversionContext` packages a live prior tendency and an actual live-mismatch reception. `waa_path_landing` proves the checked conditional: `WaaFullyEnlightened`, a deed by that being, delivery to the reception, and the aversion context imply `HasShareDropLanding`. `WaaPathOught` is only this implication type, and `waaPathOught_conditional` proves it. `no_waa_path_at_pole` proves that no share-drop landing can be constructed from an `AtBot` prior tendency. `no_waa_aversion_context_at_pole` shows the live-aversion antecedent fails there. `Doctrines/SraddhaNegative.lean` supplies concrete countermodels for dropping faith or dropping aversion. `OrthogonalityNegative` reuses the `SraddhaNegative` zero-effectiveness grid: a responsive terminus can fail `WaaFullyEnlightened` because the delivered deed has no share-drop landing for the receiver's live prior tendency. `waaFullyEnlightened_stronger_than_terminus` proves the strictness. `waaFullyEnlightened_of_responsiveTerminus_of_undelivered` gives the sealed regime face: if no own deed is delivered, the shortfall-closure conjunct holds vacuously for any responsive terminus. **Faith.** `WaaPathClaim` packages the local claim that a prior configuration, deed, and reception satisfy `ShortfallClosedAt`; `waaPathClaimLanguage` makes that claim a `ClaimLanguage`. `WaaFaithPrinciple` is the testimonial antecedent: faith in a fully enlightened being makes that being's recorded utterances fit their offered tier. `waa_says_true_of_faith` is the direct projection of the principle, while `fitsOfferedTier_of_waaFullyEnlightened_ownDeed` records the old own-deed fragment where full enlightenment itself supplies the claim truth. `waa_path_landing_of_faithPrinciple` and `waaFaithOught_conditional` rederive the landing through recorded testimony. `FaithNegative` shows that neither faith as the enlightenment premise itself nor free faith validates the principle. **Ethics.** `WaaEthicsStance` bundles the faith principle with faith in one faith-object; `WaaEthicalCode` generalizes the fourth-truth ought across that object's recorded testimony while remaining an implication type. `waaEthicalCode_conditional` is the hypothesis-free conditional. The voice pair is split by `waa_ethics_conditional_voice_assertable` and `waa_ethics_detached_voice_displayable`: the conditional is verdict-voiced, the detached injunction shortfall-voiced. `EthicsNegative` supplies `no_ethics_bearing_at_pole`, `no_stance_over_false_testimony`, and `ethicalCode_relative_to_faith_object`. **Deliberation.** `ConsequentialistConvention` is a descriptive reading layer. `DropCount` and `DropCountInFiber` count share-drop receptions across finite actual runs without adding probability, utility, or a command register. They are legal display readings: `map_dropCount` and `map_dropCountInFiber` show that reparameterizing the contribution display does not change either count. `dropCountInFiber_le_dropCount` gives the per-fiber bound, while `dropCount_eq_sum_dropCountInFiber` says that a noduplicate complete supplied tag list adds the fiber counts back to the total. The local sum itself transports by `map_dropCountInFiberSum`, and `ObjectiveNegative.split_dropCount_sum_eq_mergedDropCount` checks the `[false, true]` split against the merged objective example. `ObjectiveNegative` reuses the merge/split being-convention pattern to show that "my drops" is not a function of grid data alone. `rePitch_forgets` and `accumulated_attainment_constant_of_same_final` restate backsliding in the form a maximizer needs: no accumulated attainment variable is stored in `Config`. `backsliding_witness` and `backsliding_rePitchSequence_witness` give the same-grid same-being witness form directly. `TransferNegative` records the adaptive track-record obstruction and the `ResponseInvariant` contrast case. `grade_independent_of_conditions` and `share_independent_of_conditions` keep the cetana claim at signature level: grade and share do not consume downstream delivery conditions; the two concrete cetana witnesses check same-field/different-share and live-share/no-standing cases. `DeliveryArrogationNegative` instantiates the `ClaimLanguage` machinery for a command-shaped delivery claim and checks that a recorded plan fails `FitsOfferedTier` where delivery is absent. **Gradeability.** `SeveredTranscript` is the strongest severed quotation form: an attributed agent-response pair with no call, no offered tier, and no actuality proof. `Grid.Weld.sever` and `Grid.RecordedUtterance.sever` forget the call; `severedVerdict` pins the generator's standing response to such data as `declined`. `GradeabilityNegative.no_grade_recovery_from_severed` proves that, under a same-agent/same-response collision with different shares, no function from severed transcripts can recover the grade for every actual weld. `gradeability_severed_underdetermination_witness` reuses `backslideGrid` as the concrete missing-call carrier, and `severed_transcript_ungradeable` instantiates the generic theorem there. The positive half is `recordedUtterance_grade_determined`, an `rfl` fact that a recorded utterance's grade is the grade of the whole weld it carries. The normative input rule and the koan-form genre claim remain prose. **Ledger.** `MountsOnlyIn b M` says `b` mounts responses only at calls in `M`. `modality_of_actual` and `landing_call_in_modality` are the response-shape facts: an actual weld, and hence any landing, at a modality-restricted receiver carries a call in the modality; both are projection/rewrite proofs. `not_actual_outside_modality` and `no_landing_outside_modality` are the contrapositives. `fiber_landing_call_in_modality` lifts the fact to a coarsening fiber whose fine tags all satisfy `MountsOnlyIn` for the same `M`. `ReceptionCommand` and `receptionCommandLanguage` mirror the Deliberation delivery-command language with `LandsAt` as the satisfaction condition; `receptionCommand_unfit_of_no_landing` is the corresponding unfit theorem. `ledger_census_misfits_live_offer` and `ledger_prognosis_misfits_live_offer` are named faces of `denied_misfits_live_offer` at `.perCallGlobal` and `.standingDated`; the module adds no `RowTag`. `LedgerCase.ledgerGrid` is a three-being, three-call, three-response grid over `Nat` with constant live grade `1`; `conditions` delivers exactly the welds whose response is `code` or `comply`. The checked model facts: `official_mountsOnlyIn_economic`, `official_not_stone`, `official_landing_only_economic`, `floor_speech_never_lands_at_official`; the three landings of `codeWeld` with `one_act_two_receivers` and `code_ruler_not_exempt` (a self-line reception by the issuer); `sectorCoarsening` with `state_tag_sentient`, `state_fiber_shares_register`, and `state_fiber_landing_economic`; `decree_engineers_calls_not_receptions` (delivery holds, the commanded reception is not actual, the recorded decree fails `FitsOfferedTier`); and the purge block `purgedGrid := ledgerGrid.staticized master` with `purge_delivery_loss_real`, `purge_adaptive_to_static`, `purge_loop_runs_on`, `purge_object_axis_subtraction_nil`, and `corpus_still_delivered`, all reusing the futility operation. `FoxCase.foxGrid` is a natural-numbered life series: life 0 answers the question, later lives receive the fruit, and the turning word releases at share 1 rather than at the pole. The checked model facts are `fox_sentence_live_selfPole`, `fox_arrow_index_free`, `fox_returns_delivered`, `fox_reception_clenched`, `fox_release_rung_not_pole`, `fox_reachBack_full_at_release`, `fox_nothing_kept`, and `fox_never_tests_pole`. `foxSeriesCoarsening` merges the fine lives into the display tag "the fox" while `fox_consecutive_lives_distinct` keeps the fine series individuated. The Dogen gloss is typed by `daishugyo_diagnosis_fits`, `jinshinInga_instruction_fits`, `jinshinInga_floor_voicing_would_misfit`, and `dogen_doubling_both_fit`; these check only the grid-internal speech-act gloss, not the historical contra. `Doctrines/FoxCase.lean` adds `fox_dukkha_per_life`, because that theorem consumes the Four Truths mismatch vocabulary. **Correlations.** `StageScheme` is `BeingCoarsening`; `FiftyTwoStageScheme` adds no signature field. `ShareDropRun` and `BullAscent` type Bulls 1-6 as per-call drops. `WaaBullSeven` is probe-constancy plus a live self-pole index, with `bullSeven_not_bullEight` checking that this half-weld is not the pole-class. Bull 8 is `AtPoleClass`, Bull 9 is `ResponsiveTerminus`, and Bull 10 is `WaaBullTen`, an existential cross-fiber delivery into another sentient fiber. `StrongWaaBullTen` names the stronger all-sentient-fibers asymptote without using it. `bullTen_to_bullNine`, `bullNine_to_terminus`, and `bullNine_to_bullEight` give the checked chain, while `CorrelationsNegative.pratyekabuddha_countermodel` shows Bull 9 without Bull 10. `CorrelationsNegative.no_stage_boundary_recovery` is the stage-scheme version of the no-recovered-partition witness. `FiveRank`, `RankReading`, and `rankLanguage` keep the Five Ranks as utterance-diagnosis data. `kenChuTo_implies_waaBullTen` records the 到/Bull 10 shape under the same coarsening. **Sudden/gradual.** `WaaSuddenArrival` packages an actual one-step share-drop from live prior tendency to the pole-class; `waaSuddenArrival_witness` names the clock-grid face of the older `subitism_possibility_witness`. `rePitchRun` folds a finite list of received welds, and `WaaGradualArrival` reads a staged `ShareDropRun` that reaches the pole-class; `waaGradualArrival_witness` checks the two-step register-clock case. `rate_invisible_to_config`, `rePitchRun_forgets_same_final`, and `score_of_rePitchRun_constant_of_same_final` are the no-rate-preference statements: anything that factors through the final `Config` cannot see the earlier rate once the final reception is fixed. `SuddenGradualNegative.subitism_frequency_underdetermined` supplies the honesty clause by varying delivery while response, grade, and share data agree. **Other-power.** `SameAgentDelivery` and `CrossAgentDelivery` add neutral delivery-regime vocabulary: the line is delivered, and the deed/reception agent tags are equal or unequal. `WaaJirikiLine` and `WaaTarikiLine` are only the system-POV readings of those facts. `reception_typing_ignores_sower` is near-definitional by design: changing only `conditions` leaves a reception's grade, share, and actuality unchanged. `waaReachBack_filled_either_regime` projects the shared reach-back conjunct from either same-agent or cross-agent delivery. `TarikiCase` discharges non-vacuity the way `LedgerCase` does: a fixed-call source is response-invariant (`name_responseInvariant`), function-mounted (`name_not_stone`), and share-zero at its welds (`name_share_bot`); its object axis reaches every invoker reception (`name_object_axis_entire`). The effective limit is checked by `universal_fixed_call_lands_without_reading`, while `invoker_reception_is_deed` keeps the receiver's act grammar ordinary and live. `OtherPowerNegative.regime_does_not_determine_share` and `OtherPowerNegative.share_does_not_determine_regime` witness the no-polemic clause: neither regime nor share recovers the other. **Fetters.** `FiberAtPoleOn`, `LiveFiberAtPoleOn`, `FiberAtPoleOnWithin`, and `FiberAtPoleWithin` are neutral fiber predicates in `Signature/BeingConvention.lean`. `FetterReading` supplies model-side provocation classes, `SomaReading` supplies model-side tag-regions, and `FetterCutWithin` means quietness at pole on the relevant call-class inside the supplied tag-class. `Fetter.kind_lower_iff_cut_by_nonReturn` records the enumeration coherence: exactly the lower fetters are cut by non-return. `Path.cutClasses` gives the nested path profiles; `PathQuietWithin`, `arhatPathQuietWithin_iff_fiberAtPoleWithin`, and `arhatWithin_univTags_iff_fiberAtPole` close the two-axis lattice back to ordinary `FiberAtPole` at total calls and total tags. That top point is the total-rectangle cut, not the buddha reading by itself. The layered reading has three checked rungs: rung 1 is share-only and stone-inclusive (`FettersNegative.total_cut_carries_no_function`); rung 2 is the live terminus reading, with `sentientTag_iff_actualFiberInhabited` bridging function to actual fiber inhabitation; rung 3 is `WaaFullyEnlightened`, and `FettersNegative.total_cut_with_function_not_waaFullyEnlightened` checks that rung 2 still lacks effectiveness. The regime-relational face is two-sided: zero-effect delivery can make full enlightenment fail, while `waaFullyEnlightened_of_responsiveTerminus_of_undelivered` makes it hold vacuously under sealed delivery. The checked anchors are `classQuiet_no_clench_in_class`, `identityView_excluded_at_arhatFiber`, `conceit_excluded_at_arhatFiber`, `all_fetters_cut_at_arhatFiber`, `arhatFiber_of_termini`, `identityView_excluded_at_speechThoughtRegion`, `conceit_excluded_within`, `regionFiber_of_termini`, and `unquiet_region_still_functions_witness`. The forward-looking face is conditional and diagnostic: `RunQuiet` and `RunQuietWithin` are finite track-record quietness, `waaIrreversibleRegime_conditional` and `waaIrreversibleRegimeWithin_conditional` promote them only under supplied regimes, and `FettersNegative.seen_run_underdetermines_fetterCut`, `FettersNegative.seen_run_underdetermines_fetterCutWithin`, and `FettersNegative.no_region_boundary_recovery` give the fresh-call and tag-boundary underdetermination witnesses. **Factors.** `PathFactor` names the factor-side regrouping of the canonical fetter table. `PathFactor.blockerClass` derives rites, view, and resolve blocker classes from `FetterReading`; speech and conduct are named but inert with `False` classes. The coherence theorems `ritesView_union_covers_streamEntry_fetters`, `resolve_covers_nonReturn_fetters`, and `lower_fetters_covered_by_rites_view_resolve` check that the active factor classes cover exactly the intended stream-entry and lower-fetter unions. `FactorHeld` is a seen-run existential over actual in-fiber welds with live self-pole index in the factor class. `FactorReleased` is the corresponding whole-class `FiberAtPoleOn` cut. `not_factorHeld_of_factorReleased` gives the refutation direction; `factorReleased_rites_iff_ritesGrasp_cut`, `factorReleased_view_iff`, and `factorReleased_resolve_iff` connect the factor release predicates back to the fetter cuts. The stage readings are `WaaStreamEnterer`, `WaaStreamWinner`, `WaaOnceReturner`, and `WaaNonReturner`. The fruit positions are proved equivalent to the old path cut classes by `waaStreamWinner_iff_streamEntry_cutClasses` and `waaNonReturner_iff_nonReturn_cut`, while `waaNonReturner_of_arhatFiber` consumes the existing arhat fiber anchor. `ShareDropRunOn`, `WaaResolveAttenuation`, `waaOnceReturner_attenuation_witness`, and `attenuation_not_release` give once-return positive content as a strict resolve-class drop that stops short of pole release. `RunsExhibitFactorOrder`, `WaaSerialFactorRegime`, and `waaSerialFactorRegime_conditional` state the "usually runs in order" claim only as a supplied-regime conditional. `waaSuddenArrival_consistent_with_factorScheme` records compatibility between one-step pole arrival and the factor fruit readings under the existing pole-fiber hypothesis. **FactorsNegative.** `no_hold_conceit_boundary_recovery` shows that the hold/conceit line is not recovered from shared response/grade/share data. `seen_run_underdetermines_factorOrder` gives one seen run whose factor order depends on the supplied reading. `lineage_underdetermined_by_seen_run` specializes the stage-boundary freedom witness to switching between a Theravada-shaped factor tag and a Bulls-shaped tag over the same grid and run. --- ## 4. Identification Layer (`Identification/*`) **Field residues.** `CorrectFieldRecovery recover` says that every actual weld's field residue recovers its index. `correctFieldRecovery_forces_same_index_of_same_field` proves that two actual welds with equal field residue must then have equal indices. `no_agent_recovery_from_same_field_distinct_index` and `no_agent_recovery_from_same_call_response` package the corresponding impossibility results. **Ownership-face definitions.** The ownership/report/vacuity/whose predicates live under `Grid.DirectedConvention`. `WaaReportFace`, `WaaOwnershipFace`, `WaaVacuousOwnershipFace`, and `WaaDiachronicWhose` are conjunctions over delivery, actuality, and WAA-appropriation. Their theorems are projections, introductions, contradictions with non-delivery, or definitional biconditionals: - `waaReportFace_of_waaOwnershipFace` - `actual_of_waaOwnershipFace` - `waaAppropriates_of_waaOwnershipFace` - `waaOwnershipFace_intro` - `not_waaOwnershipFace_of_vacuous` - `not_waaOwnershipFace_of_waaVacuousOwnershipFace` - `waaDiachronicWhose_iff_delivery_and_waaAppropriates` The concrete memory display is `Grid.DirectedConvention.MemoryWitness.memory_witness` over `registerClockGrid`. It names the registers `pastDeed`, `recall`, and `confabulatedDeed`; the delivered side is checked by `trace_delivered`, `recall_waaOwnershipFace`, and `recall_waaDiachronicWhose`; the false-memory side is checked by `confabulated_not_delivered` and `falseMemory_waaVacuousOwnershipFace`. `vacuity_not_inner_mark` projects the same recall-side WAA-appropriation from both faces while closing the non-delivered contrast, and `recall_spent` is the `rePitch_forgets` instance that makes the recall weld spent at recall-time. **Token reflexivity.** `selfAnchored`: `index w = w.agent`. Definitional (`rfl`). **Pole-typing.** `StateToolFits w` means `¬ HasSelfPoleIndex w`. `stateToolFits_of_atBot` and `stateToolFits_of_eq_shareBot` are the direct pole-class and equality-bridge facts. Assuming `[Decidable (AtBot (G.share w))]`, `atBot_of_stateToolFits` and `stateToolFits_iff_atBot` give the exact iff with pole-class membership. `stateToolFits_of_terminus_response` applies the result to terminus responses. `Grid.DirectedConvention.not_waaOwnershipFace_of_stateToolFits`: if the state-tool fits a reception, the WAA-ownership-face cannot fire there, because ownership-face includes WAA-appropriation. **Rule and office facts.** `obeysRule_fuses_at_floor` and `obeysRule_separates_at_actTime` are direct uses of the separate/fuse theorems. `assignedTier` assigns each `WaaOwnershipOffice` to the weld's act-time tier. The two facts that this unfolds to `Tier.actTime w` and has exactly the weld's `HasSelfPoleIndex` condition are `assignedTier_eq_actTime` and `assignedTier_hasLiveShare_iff`. `retype_constructor_exists` checks the generator's retype constructor. The placement and disclaimer checks are named below. **Register sorting.** `Register`, `SortedFact`, and `SortedFact.register` record disclaimer 5's three-register sorting as inspectable data. The pins are `causalSeries_register`, `delivery_register`, `seed_register`, `arrogationTendency_register`, `agentIndex_register`, `forMeNess_register`, `receptionReachBack_register`, and `rowTwoPlacement_register`. `nothing_selfIndexed_carried` checks the refined premise that the self-indexed facts are not carried in the stored field register. **Instructive absences.** `InstructiveAbsence` records the current section 3 list as Lean data, with `InstructiveAbsence.number` pinning the paper order 1-10. `AbsenceStatus` states the membership rule explicitly: constructors track the section 3 list, while `InstructiveAbsence.status` tracks whether the world has retired an entry. The status pins are `emptyCells_standing`, `declinedCase_standing`, `foxNeverTestsPole_standing`, `thirdArrival_retired`, `whyCallsLand_standing`, `fourthTruthWithheld_standing`, `noSafeStage_standing`, `prudentialPrivilege_standing`, and `noMeasure_standing`. The anchors are intentionally thin: `emptyCells_anchor`, `foxNeverTestsPole_anchor`, `foxNeverTestsPole_recordedUtterance_not_atBot`, `foxNeverTestsPole_recordedUtterance_not_atPoleClass`, `foxNeverTestsPole_oldMan_misfit_anchor`, `thirdArrival_function_mounted_no_share`, `thirdArrival_not_waaMismatchLive`, `fourthTruthWithheld_conditional`, `fourthTruthWithheld_detached_voice`, `noSafeStage_anchor`, `prudentialPrivilege_underivable_anchor`, `icchantikaDeclined_agent_anchor`, `icchantikaDeclined_receiver_anchor`, and `icchantikaDeclined_nonforeclosure_anchor`. The declined deaf-blind case, why-calls-land, and no-measure absences are pin-level data only; no theorem is manufactured for what the paper leaves ceded. **Self-line witness.** `SelfLineWitness.selfLineGrid` is a minimal `Nat` grid with one being, one call, one response, total response, grade `1`, and `conditions _ _ := True`. The checked examples show: - `w_waaAppropriates`: the self-line witness weld carries `Grid.WaaAppropriates`. - `selfLine_conditions_self`: `conditions w w` holds. - `selfLine_landsAt_self`: `Grid.DirectedConvention.LandsAt selfLineGrid w w` holds. - `selfLine_waaOwnershipFace_self`: `Grid.DirectedConvention.WaaOwnershipFace selfLineGrid w w` holds. The scope is narrow and deliberate: the signature permits self-lines; it does not say that any real regime contains them. Irreflexivity of delivery is a regime fact to be supplied by a model, not a structural axiom. The contemporary placement checks are `siderits_waaPlacement`, `ganeri_waaPlacement`, `zahavi_waaPlacement`, and `sartre_waaPlacement`. **Disclaimers.** `Disclaimer.number` now runs through 57. The recent entries are `beingConvention` (35), `pilotGeneratedRows` (36), `beingTrichotomy` (37), `hareHornRegister` (38), `modalRealismFreeze` (39), and `aptnessConditionality` (40), `sraddhaConditional` (41), and `faithBothConjuncts` (42). The table-generation entries append after those existing pins: `generatedTableStructure` (43), `poleAffirmingSemantics` (44), `proseRows` (45), and `errorFreeReading` (46). `misFeedFence` (47) records the avyākata fence-and-gate pair. The correlation entries are `tenBullsTyped` (48), `fiveRanksRetype` (49), `stageSchemeCoarsening` (50), and `fetterCutTyping` (51). `twoAxisFetterLattice` (52) records the product call/tag fetter lattice, `enlightenmentLadder` (53) records the neutral total-rectangle cut and three-rung ladder, and `ethicsBundledConditionalCode` (54) with `codeHonestyClauses` (55) records the ethics-code tail. `verdictRecordData` (56) records the generator's episode-grained verdict history as Lean data, including the retype entries in `generatorRecord` (`Meta/VerdictLedger.lean`), and `compoundCellStacks` (57) records the five compound-position decompositions over existing `TableRow`s, with facets, roles, voices, legal elements, and core-cell counts in `Consequences/Compounds.lean`. `waaKarmaIdentification_number` pins `waaKarmaIdentification = 9`, and `modalRealismFreeze_number` pins `modalRealismFreeze = 39`. `aptnessConditionality_number` pins `aptnessConditionality = 40`; `sraddhaConditional_number` and `faithBothConjuncts_number` pin the two new Sraddha entries, while `generatedTableStructure_number`, `poleAffirmingSemantics_number`, `proseRows_number`, `errorFreeReading_number`, and `misFeedFence_number` pin the table and mis-feed entries; the newer correlation and disclaimer pins are `tenBullsTyped_number`, `fiveRanksRetype_number`, `stageSchemeCoarsening_number`, `fetterCutTyping_number`, `twoAxisFetterLattice_number`, `enlightenmentLadder_number`, `ethicsBundledConditionalCode_number`, `codeHonestyClauses_number`, `verdictRecordData_number`, and `compoundCellStacks_number`. --- ## 5. Meta/Nishitani.lean, Meta/ReflexivityWitness.lean, Meta/Invariance.lean, and Meta/InvarianceNegative.lean **Śūnyatā wrappers.** `Meta/Nishitani.lean` defines `Sunyata d` as the absence of any frozen level in `ladder d`. The new row instantiations `intraWeldArrow_sunyata` and `doerDeed_sunyata` join the existing beings, time, weld, and content-beings instantiations as direct consumers of the ladder no-final-freeze theorems. **Reflexivity witness.** `Meta/ReflexivityWitness.lean` defines `ladderRungGrid`, a single legal `Grid Nat` whose `Being` carrier is read as rung labels. `ladderRungGrid_beings_sunyata` instantiates `beings_sunyata`, and `ladderRungGrid_no_level_final` reruns the beings ladder over that grid. The file is a witness, not a new universal claim about beings. **Admission criterion.** Any future predicate over `grade` owes a transport lemma here, or it counts as operational residue. The file proves that the current grade-facing predicates are invariant under display reparameterization. `DisplayReparam Contrib Contrib'` consists of a function `toFun`, an order preservation/reflection theorem `a ≼ b ↔ toFun a ≼ toFun b`, and a proof that `toFun shareBot` is `AtBot` in the target carrier. `DisplayReparam.atBot_iff` proves `AtBot (toFun a) ↔ AtBot a`. `DisplayReparam.orderEq_iff` proves that order-equivalence is preserved and reflected. `DisplayReparam.directionVoid_reflect` is hypothesis-free, while `directionVoid_of_surjective` needs target-carrier coverage; `CoverageNegative.directionVoid_needs_coverage` shows why. `DisplayReparam.id` is the identity reparameterization, with `id_toFun` as its definitional projection lemma. `DisplayReparam.comp` composes reparameterizations, with `comp_toFun` as its definitional projection lemma. `Config.map` sends a tendency through `toFun`; `Config.map_tendency` is definitional. `Grid.map` leaves `Being`, `Call`, `Response`, `respondsTo`, and `conditions` unchanged, and maps `grade` through `toFun`. Definitional transport facts: - `map_grade` and `map_share` - `map_actual_iff`, `map_mountsAt_iff`, `map_mountsSomewhere_iff`, `map_respondsToEveryCall_iff`, `map_responseVariesWithCall_iff`, and `map_stone_iff` - `Grid.DirectedConvention.map_deliveredTo_iff`, `Grid.DirectedConvention.map_landsAt_iff`, and `Grid.DirectedConvention.map_environsLine_iff` Grade-facing transport facts: - `map_terminus_iff`, `map_liveTerminus_iff`, `map_responsiveTerminus_iff`, and `map_atPoleClass_iff` - `map_hasSelfPoleIndex_iff` - `map_waaMismatchGrade` and `map_waaMismatchLive_iff` - `map_probeConstant_iff` - `map_waaBullSeven_iff` and `map_waaBullTen_iff` - `map_stateToolFits_iff` - `Tier.map` and `map_tier_hasLiveShare_iff` - `map_rePitch` - `map_isShareDrop_iff` - `ActualWeld.map`, `ConsequentialistConvention.DeliberationSample.map`, `ConsequentialistConvention.map_dropCount`, and `ConsequentialistConvention.map_dropCountInFiber` - `Grid.DirectedConvention.map_landsWithShareDrop_iff` - `Grid.DirectedConvention.map_hasShareDropLanding_iff` - `Grid.DirectedConvention.map_shareDropLine_iff` - `Grid.DirectedConvention.map_shortfallClosedAt_iff` - `Grid.DirectedConvention.map_waaAversionContext_iff` - `Grid.DirectedConvention.map_waaFullyEnlightened_reflect` and `map_waaFullyEnlightened_of_surjective`; the latter's coverage hypothesis is witnessed by `CoverageNegative.waaFullyEnlightened_needs_coverage` - `Grid.DirectedConvention.WaaPathClaim.map`, `map_waaPathClaim_holds_iff`, `map_waaFullyEnlightened_iff`, `map_faith_object_eq`, and `map_waaFaithPrinciple_reflect`; the coverage-carrying entries share that same witness - `BeingCoarsening.displayMap` and its `map_*_iff` lemmas for `InFiber`, `SameFiber`, `FiberInhabited`, `ActualFiberInhabited`, `SentientTag`, `FiberAtPole`, `ActualFiberInhabitedOn`, `ActualFiberInhabitedWithin`, `FiberAtPoleOn`, `FiberAtPoleOnWithin`, `FiberAtPoleWithin`, `LiveFiberAtPole`, `LiveFiberAtPoleOn`, `LiveFiberAtPoleWithin`, `SelfAptTag`, `SelfAptTagWithin`, `LiveSelfAptTag`, `Patchy`, `SelfConditioningTag`, and `StrongSelfConditioningTag` - `DirectionCoarsening.displayMapDir`, `mapDir_sameTick_iff`, `mapDir_resolutionBounded_iff`, and `resolutionBounded_of_reparam_collapses` - The grid-convention row transports: `map_intraWeldArrowRow_obeys`, `map_doerDeedRow_obeys`, `map_contentIntraWeldArrowRow_obeys_of_variation`, `map_intraWeldArrowLadder_obeys`, `map_intraWeldArrowLadder_obeys_succ`, `map_intraWeldArrowLadder_no_level_final`, `map_doerDeedLadder_obeys`, `map_doerDeedLadder_obeys_succ`, and `map_doerDeedLadder_no_level_final` Together these say that all current pole, probe, tier, configuration, direction-coarsening, share-drop, and share-drop-line predicates are legal display predicates: changing the carrier by a reparameterization changes notation, not truth. **Direction-smuggling detector.** The transpose operation now lives in the signature layer, beside the vocabulary it transports. `Grid.transpose` reverses only the argument order of `conditions`. `transpose_conditionsEither_iff` proves that `ConditionsEither` survives the reversal. `Grid.DirectedConvention.transpose_deliveredTo_iff` proves that directed delivery reverses. `BeingCoarsening.transpose_selfConditioningTag` shows the directed refinement reversing exactly at the delivery line while fiber membership and actuality stay put. This gives future delivery-facing results a quick test: if they claim direction, they owe model-supplied asymmetry or irreflexivity. The axis operations are pinned as orthogonal: `transpose_transpose` is the involution, `map_transpose` commutes display reparameterization with transposition, `staticized_transpose` commutes function removal with transposition, and `map_staticized` commutes display reparameterization with function removal. These are definitional equalities, so the detector is not carrying extra operational content. `DirectionCoarsening.transpose_subTickDelivery` is the delivery-axis companion: tick equality survives transposition, while the delivery line reverses. **Negative examples.** `Meta/InvarianceNegative.lean` holds these countermodels. `InvarianceNegative.TwoBottom` is a two-element carrier where every element is order-equivalent to every other element, with `chosen` as the designated `shareBot`. `mergeToUnit` maps both elements to the single unit value and is a `DisplayReparam`. `twoBottomGrid` has one being, one call, one response, responds everywhere, and grades every response as `other`. The named checks show: - `twoBottomGrid_terminus`: `twoBottomGrid.Terminus ()` holds. - `not_oldEqTerminus_twoBottomGrid`: the obsolete equality-token predicate fails before reparameterization. - `oldEqTerminus_map_mergeToUnit`: the obsolete equality-token predicate holds after the merge. - `oldEqTerminus_not_invariant`: the new `Terminus` transports across the merge, while the old equality-token predicate would not have transported. This is the formal certificate that replacing equality with `AtBot` was a real de-operationalisation, not a naming preference. **`DirectionNegative`.** `forwardGrid` and `backwardGrid` are one-being, two-call grids identical except that `conditions` is reversed. `conditionsEither_agrees` shows they have the same symmetric closure at every pair; `conditions_disagree` exhibits a pair where the directions differ; `no_direction_recovery_from_conditionsEither` concludes that no function of the symmetric closure is correct on both grids. This is the formal certificate that direction is not carried by the correlational structure. `not_strict_twoBottom` records the carrier-wide strictness failure on the two-bottom negative carrier. **`InteriorDirectionNegative`.** `RawWeld.transposeCR` swaps the call and response faces when they share a carrier. `transposeCR_involutive`, `unorderedCRContent_transpose_invariant`, and `transpose_swaps_readings` pin the transposition behavior: unordered content is unchanged while the display labels reverse. `no_interior_direction_recovery` uses the same collision shape one grain down: unordered call/response content does not recover which face is call. This is the formal certificate that the intra-weld arrow is display, not a field-carried before/after. **`DirectionCoarseningWitness`.** `registerClockUnitTick` gives the raw register clock one universal tick. `registerClock_unitTick_not_resolutionBounded` proves this cannot be coherent over the injective `Nat` display: registers `0` and `1` share a tick but do not have order-equivalent shares. The positive slow-clock limit is modeled on a lawful one-point display: `fullyCoarseRegisterClockGrid` keeps the register-clock response and delivery shape while grading every weld in `Unit`. `unit_directionVoid_via_mergeToUnit` gets `DirectionVoid Unit` through the existing legal display collapse from the all-equivalent `TwoBottom` carrier, and `fullyCoarseRegisterClock_no_timeDirection` applies the one-tick resolution-bound theorem to the fully coarse grid. The theorem `registerClock_directionCoarsening_independence` is the soul-guard: macro sentience and self-conditioning for the register clock do not consume either a direction coarsening or a resolution-bound hypothesis. **`ContentNegative`.** `allStoneGrid` is a no-response grid whose beings are all stone-typed and whose act-time tiers have no live share. It proves `contentBeingsRow_not_obeys_allStone` and `contentGridLensRow_not_obeys_noLive`. The existing two-bottom carrier gives `twoBottomGrid_directionVoid`, and `contentBeforeAfterRow_not_obeys_twoBottom` shows the directed-time content row also needs its strict-direction aptness hypothesis. The empty-domain witnesses separate two vacuities: `emptyCallGrid_false_stone_and_respondsToEveryCall` shows that an empty call axis collapses stone with call-entire response, while `emptyBeingGrid_no_liveTier` and `contentBeingsRow_obeys_emptyBeing` show that an empty being axis has no act-time counterexample and the beings row fuses vacuously. `constantResponseGrid_no_variation` and `contentIntraWeldArrowRow_not_obeys_constantResponse` are the intra-weld content countermodel: if every call gets the same response, the response- variation aptness hypothesis is load-bearing. **`CoverageNegative`.** `embedIntoNat` sends the one-point carrier to `0` in `Nat`, leaving all target strictness at and above `1` outside the image. `directionVoid_needs_coverage` shows that carrier-wide direction-voidness does not push forward when the target has strict comparisons outside the image. `phantomGrid` gives the parallel faith-closure witness: `waaFullyEnlightened_needs_coverage` shows that the mapped carrier introduces live tendencies the source never quantified over, so full enlightenment does not preserve without coverage. **`MisFeedNegative` in `Identification/Residues.lean`.** `IndexSeekingForm` is the type of candidate answer-functions for the index-seeking question-shape: one designation per field residue (`Call × Response`), each purporting to name the residue's self-pole index. `AnswersCorrectly` is the success condition for the form: correctness at every actual weld. `FieldCollision` packages the hypothesis: two actual welds with the same field residue and distinct agents. `no_indexSeeking_success_of_collision` is the fence: under a collision, no answer-function for the form succeeds. The quantifier ranges over every candidate answer-function, so the non-derivability is a property of the question-shape, not of one failing instance. It is the same internal route as the wrinkle-1 recovery theorems (`CorrectFieldRecovery`, `no_agent_recovery_from_same_call_response`), specialized to the designation-universe the avyākata reading needs. `collisionGrid` is the non-vacuity witness: a concrete grid in which two beings actually produce the same call-response pair, so the fence's hypothesis is exhibited rather than assumed, the same duty `clockGrid` discharges for the function/share split. `deliveryTwinAnswers` is the gate: in the same concrete model, the delivery-typed twin question has a checked answer-function. The claim is model-local by design: it shows the fence does not enclose delivery-questions, and asserts nothing about their answerability in general, which the standing no-verdicts deny. Three layers are stated in order of decreasing formality: the question-shape is fenced schematically over the modeled designation-universe; the collision hypothesis is witnessed concretely; and the adequacy of that universe to the avyākata's natural-language questions is a modeling claim, argued in prose and owned as such. The third layer cannot be discharged in Lean, and the paper does not pretend otherwise; it is an aptness claim of the same standing as the content-row hypotheses beside `ContentNegative`. **`BeingNegative`.** The signature-level `BeingCoarsening.id` and `BeingCoarsening.total` already show that identity and universal merge partitions are legal for any grid; `total_sameFiber` and `id_not_sameFiber_of_ne` pin the disagreement for any distinct fine tags. Downstream, `twoBeingGrid` has two fine tags with identical response, grade, and symmetric delivery behavior. `κmerge` reads them as one macro tag; `κsplit` keeps them split. `merge_same_fiber` and `split_not_same_fiber` show the readings disagree at `false`/`true`, and `no_partition_recovery` proves no function of the shared grid data recovers both. This is the formal certificate that the being-boundary is a reading, not grid-carried structure. **`WeldNegative`.** `twoWeldGrid` has two fine call-response pairings over the same response, grade, and symmetric delivery data. `σmerge` reads them as one macro act; `σsplit` splits them by weld-grain. `merge_same_pairing` and `split_not_same_pairing` show the readings disagree, and `no_weld_boundary_recovery` proves no function of the shared grid data recovers both. This is the formal certificate that weld individuation is a segmentation convention, not grid-carried structure. **`DoerDeedNegative`.** The doer/deed witness reuses a small two-call grid data shape and supplies two readings over it: `beingPriorReading` and `mutualReading`. `priority_readings_disagree` pins the collision, and `no_priority_recovery` proves no function of the visible grid data recovers a unique priority relation. This is why `doerDeedRow` remains schema-only rather than adding a priority primitive to `Grid`. **Verdict ledger.** `Meta/VerdictLedger.lean` records the verdict-history paragraph as `generatorRecord`. The four retypes are four entries; the checked count is `generatorRecord_retype_count`, and `generatorRecord_newCell_count` records that no new row is added. The six-kind view is the projection `restraintKind`, checked by `generatorRecord_restraintKind_seen_count` and `restraintKind_exhaustive_on_record`. Lean anchors are pinned by examples that name `DirectionNegative`, `InteriorDirectionNegative`, the transposition pair, the fox theorem, and `MisFeedNegative.fence_and_gate`. The checkable half of the falsifier is `misFeed_entries_carry_decomposition`; the rate-trend half remains prose. **Glossary.** `Meta/Glossary.lean` is the canonical source for glossary data. Each `GlossaryEntry` records a term, provenance kind, newcomer-facing gloss, checked Lean anchors, and backward-only `seeAlso` references. Lean checks the table length, term uniqueness, `seeAlso` resolution to earlier rows, and anchor resolvability through `#verify_glossary_anchors`. The glosses' accuracy and canonical caveats remain prose; the Disclaimers carry expert-facing departures. `WeldAndArrow/Gen/Glossary.lean` renders the table to `Exposition/Glossary.md`. --- ## 6. Meta/Audit.lean `Meta/Audit.lean` imports `Meta/Invariance.lean`, `Meta/InvarianceNegative.lean`, `Meta/ReflexivityWitness.lean`, `Meta/VerdictLedger.lean`, `Doctrines/SraddhaNegative.lean`, `Doctrines/FaithNegative.lean`, and `Doctrines/Deliberation.lean`, plus the new correlations, fetters, and factors negative modules, then pins selected `#print axioms` outputs with `#guard_msgs`. The audited declarations are: - `no_agent_recovery_of_field_collision` - `DirectionNegative.no_direction_recovery_from_conditionsEither` - `CoverageNegative.directionVoid_needs_coverage` - `CoverageNegative.waaFullyEnlightened_needs_coverage` - `Grid.stateToolFits_iff_atBot` - `Grid.map_actual_iff` - `Grid.map_isShareDrop_iff` - `strict_asymm`, `strict_trans`, and `Grid.transpose_transpose` - `Grid.map_transpose`, `Grid.staticized_transpose`, and `Grid.map_staticized` - `Grid.DirectedConvention.DirectionCoarsening.mapDir_resolutionBounded_iff` - `DirectionCoarseningWitness.registerClock_unitTick_not_resolutionBounded` - `DirectionCoarseningWitness.unit_directionVoid_via_mergeToUnit` - `DirectionCoarseningWitness.fullyCoarseRegisterClock_no_timeDirection` - `DirectionCoarseningWitness.registerClock_directionCoarsening_independence` - `Grid.DirectedConvention.map_landsWithShareDrop_iff` - `Grid.DirectedConvention.BeingConvention.BeingCoarsening.map_selfConditioningTag_iff` - `Grid.DirectedConvention.BeingConvention.BeingCoarsening.map_fiberAtPoleOn_iff` - `Grid.DirectedConvention.BeingConvention.BeingCoarsening.total_sameFiber` - `Grid.DirectedConvention.BeingConvention.BeingCoarsening.id_not_sameFiber_of_ne` - `Grid.map_waaBullSeven_iff` - `Grid.map_waaBullTen_iff` - `Grid.bullSeven_not_bullEight` - `Grid.bullTen_to_bullNine` - `CorrelationsNegative.pratyekabuddha_countermodel` - `CorrelationsNegative.no_stage_boundary_recovery` - `Grid.classQuiet_no_clench_in_class` - `Fetter.kind_lower_iff_cut_by_nonReturn` - `Grid.arhatPathQuiet_iff_fiberAtPole` - `Grid.all_fetters_cut_at_arhatFiber` - `Grid.identityView_excluded_at_arhatFiber` - `Grid.conceit_excluded_at_arhatFiber` - `Grid.waaIrreversibleRegime_conditional` - `Grid.lower_fetters_covered_by_rites_view_resolve` - `Grid.waaStreamWinner_iff_streamEntry_cutClasses` - `Grid.waaNonReturner_iff_nonReturn_cut` - `Grid.waaSerialFactorRegime_conditional` - `Grid.waaOnceReturner_attenuation_witness` - `FactorsNegative.no_hold_conceit_boundary_recovery` - `FactorsNegative.seen_run_underdetermines_factorOrder` - `FactorsNegative.lineage_underdetermined_by_seen_run` - `FettersNegative.seen_run_underdetermines_fetterCut` - `Grid.DirectedConvention.waaPathOught_conditional` - `Grid.DirectedConvention.waaFaithOught_conditional` - `Grid.DirectedConvention.map_waaFaithPrinciple_reflect` - `FaithNegative.waaFaithPrinciple_id_fails` - `Grid.DirectedConvention.no_waa_path_at_pole` - `Grid.DirectedConvention.map_waaAversionContext_iff` - `MisFeedNegative.fence_and_gate` - `misFeed_entries_carry_decomposition` - `OrthogonalityNegative.waaFullyEnlightened_stronger_than_terminus` - `Grid.stone_of_no_call`, `Grid.respondsToEveryCall_of_no_call`, and `Grid.allStone_of_no_being` - `ContentNegative.emptyCallGrid_false_stone_and_respondsToEveryCall`, `ContentNegative.emptyBeingGrid_no_liveTier`, and `ContentNegative.contentBeingsRow_obeys_emptyBeing` - The new intra-weld/doer-deed/reflexivity surface: `InteriorDirectionNegative.transposeCR_involutive`, `InteriorDirectionNegative.unorderedCRContent_transpose_invariant`, `InteriorDirectionNegative.transpose_swaps_readings`, `DoerDeedNegative.no_priority_recovery`, `ContentNegative.contentIntraWeldArrowRow_not_obeys_constantResponse`, `intraWeldArrowRow_*`, `doerDeedRow_*`, `contentIntraWeldArrowRow_obeys_of_variation`, `intraWeldArrowLadder_*`, `doerDeedLadder_*`, `Nishitani.intraWeldArrow_sunyata`, `Nishitani.doerDeed_sunyata`, the new `map_*` row/ladder theorems, and the two `ladderRungGrid_*` reflexivity witness theorems - `Grid.ConsequentialistConvention.dropCountInFiber_le_dropCount`, `Grid.ConsequentialistConvention.dropCount_eq_sum_dropCountInFiber`, and `Grid.ConsequentialistConvention.map_dropCountInFiberSum` - `ObjectiveNegative.split_dropCount_sum_eq_mergedDropCount` The pinned result is: no audited theorem depends on `sorry` or `Classical.choice`. All audited declarations are axiom-free except `DirectionNegative.no_direction_recovery_from_conditionsEither`, which depends on exactly `[propext, Quot.sound]`, and `InteriorDirectionNegative.unorderedCRContent_transpose_invariant`, plus `FettersNegative.seen_run_underdetermines_fetterCut`, `Grid.waaOnceReturner_attenuation_witness`, `FactorsNegative.seen_run_underdetermines_factorOrder`, and `Grid.DirectedConvention.map_waaFaithPrinciple_reflect`, plus the three census theorems `Grid.ConsequentialistConvention.dropCountInFiber_le_dropCount`, `Grid.ConsequentialistConvention.dropCount_eq_sum_dropCountInFiber`, and `Grid.ConsequentialistConvention.map_dropCountInFiberSum`, which depend on `[propext]`. The Lake build targets the library `WeldAndArrow` by default and also defines the non-default `lean_exe` targets `exposition_gen`, `glossary_gen`, and `exposition_generation_test`; there is no `Main.lean`. --- ## 7. Logical Strength The definitional identities include `share_eq_grade`, `selfAnchored`, `rePitch_tendency_eq_share`, the delivery/aiming biconditionals, `isShareDrop_iff_rePitch_tendency_drop`, the recorded-utterance identities, `recordedUtterance_grade_determined`, the reception-pair tendency lemmas, and the basic `map_*` identities in `Meta/Invariance.lean`. The elementary consequences are projections, witness assemblies, contradictions, and short order arguments. The important non-definitional order arguments are the `AtBot` share-drop obstruction, `strict_irrefl`, and the display-reparameterization transport lemmas. The `FoxCase` checks sit here too: their proofs unfold concrete responses, project existing identities, or close short `Nat` order goals with `decide`. The conditional impossibility results are the agent-recovery theorems, the direction negative witness, the intra-weld direction witness, the being-boundary negative witness, the weld-boundary negative witness, the sraddha orthogonality witness, the severed-transcript gradeability negative, and the other-power regime/share negative. The concrete model and carrier results include `clockGrid`, `registerClockGrid`, `backslideGrid`, `gradingCollisionGrid`, `WeldNegative.twoWeldGrid`, `FoxCase.foxGrid`, and `TarikiCase.tarikiGrid`, plus the `InteriorDirectionNegative` two-face raw weld carrier: they witness, respectively, function/share splitting, diagnosis-time macro coarsening, same-being backsliding plus severed-transcript grade underdetermination, same-field/different-share grading, weld-boundary underdetermination, the fox run-through with no pole-arrival, fixed-call landing without a second act grammar, and intra-weld orientation underdetermination. The self-line witness is a permission witness, not an existence claim about any real regime. One structural caution remains: `Terminus` is vacuously true of every `Stone`; use `LiveTerminus` or `ResponsiveTerminus` when non-vacuous response-function matters. "# def formalizationDoc : Doc := { id := "formalization" title := "Formalization" output := "Exposition/Formalization.md" source := "WeldAndArrow/Exposition/Formalization/Reading.lean" summary := "Plain-English reading of the Lean formalization." blocks := [.raw formalizationBody] } end WAA.Exposition ===== FILE: WeldAndArrow/Exposition/Glossary.lean ===== import WeldAndArrow.Exposition.Basic import WeldAndArrow.Meta.Glossary namespace WAA def renderSeeAlso (refs : List String) : String := match refs with | [] => "—" | names => Exposition.joinComma (names.map (fun name => "`" ++ Exposition.markdownEscape name ++ "`")) def renderGlossaryRow (entry : GlossaryEntry) : String := "| " ++ Exposition.markdownEscape entry.term ++ " | " ++ Exposition.markdownEscape entry.kind.label ++ " | " ++ Exposition.markdownEscape entry.gloss ++ " | " ++ Exposition.renderAnchors entry.anchors ++ " | " ++ renderSeeAlso entry.seeAlso ++ " |" def glossaryBody : String := "# Glossary\n\n" ++ "Generated from `WeldAndArrow/Meta/Glossary.lean` and " ++ "`WeldAndArrow/Exposition/Glossary.lean` by `lake exe exposition_gen`. " ++ "Gloss accuracy remains prose; Lean checks term uniqueness, backward `seeAlso` references, and anchor resolvability. " ++ "Canonical Buddhist terms are glossed for newcomers; expert caveats live in the Disclaimers.\n\n" ++ "| Term | Kind | Definition | Checked anchors | See also |\n" ++ "| --- | --- | --- | --- | --- |\n" ++ String.intercalate "\n" (glossary.map renderGlossaryRow) ++ "\n" def glossaryDoc : Exposition.Doc := { id := "glossary" title := "Glossary" output := "Exposition/Glossary.md" source := "WeldAndArrow/Exposition/Glossary.lean" summary := "Generated glossary table: terms, provenance kinds, newcomer glosses, checked anchors, and backward-only see-also references." blocks := [.raw glossaryBody] } def renderGlossary : String := Exposition.renderDoc glossaryDoc end WAA ===== FILE: WeldAndArrow/Exposition/Identification.lean ===== import WeldAndArrow.Exposition.Basic namespace WAA.Exposition def identificationBody : String := r#"# Weld and Arrow — III. The Identification and Placements *Third of three files: the identification claim, the act-time placements that earn the name karma, the contemporary placements, the pole-typing corollary, and the disclaimers, enumerated. Cross-references to the companion files are marked (Theory) and (Theorems).* ## The identification stated from the abstract The abstract states the thesis once: > **Everything diachronic belongs to the field; every index is enacted and nothing indexed is stored; karma names this loop, and the naming is earned by fit** — the tradition's uses of karmic ownership (cetanā, reception, remorse, absolution, dedication) discharge natively at act-time. The architectural fact under that sentence is the same one the Lean `Config` makes public: **nothing self-indexed is stored**. The field carries series, seeds, dispositions, delivery, and the re-pitched configuration the next deed reads. It does not carry a mineness. What is indexed is welded at act-time, spent at act-time, and then available only as a field-describable occurrence-fact. So the field vocabulary lacks the index by construction, not by defeat of a rival vocabulary. This is why the taxonomy can name internal **mis-feeds** cheaply. Feeding an index-free field-answer to an index-requiring designation -- *did I earn this?*, or the avyākata's search for the Tathāgata's self-pole after death -- is not a hard unanswered field-question. It is the wrong feed for that designation inside the grid. The point is grammatical and internal: the delivery-question belongs to inga; the index-question is enacted in the weld. The joint is now fenced and gated in Lean: `MisFeedNegative` proves schematically that no answer-function for the index-seeking question-form can be correct under a witnessed field collision, and answers the delivery-typed twin in the same model. What remains prose is the third layer -- that the modeled designation-universe is adequate to the avyākata's actual questions -- flagged as a modeling claim, not a theorem. ## The offices-spine The identification is earned by fit, not by exclusivity. What the tradition does with karmic ownership discharges at act-time in this mechanism: - **Cetana** measures the deed where the deed is done: intention is the drive-composition of this response at this call, the same structure Row 2 states. - **Reception** is itself a deed: the reach-back welds *this fruit as return of that deed, mine* at the reception, full or vacuous, and spends that ownership-face there. - **Practice** is the weld's ordinary name inside the act-grammar: shu is not a state carried by the series but the doing that binds direction along the arrow. - **Remorse and absolution** verdicts land on welds, not on a cross-gap owner. The Cunda cases (Theorems: Three killings) work because the tradition grades what was done at the act, including where the event is impossible. - **Dedication** is a sowing-side weld whose routing is left to the field: pariṇāmanā gives the fruit's landing over rather than commanding delivery (Theorems: `CompoundPosition.ledgerPicture`, `ledgerPicture_decomposition`, `ledgerPicture_contains_legal_causalSkeleton`). Diachronic bookkeeping is exactly where the tradition deflates itself: *na ca so na ca añño*, the reaper neither the sower nor another. The field individuates the series and delivers fruits; the reception-weld closes the loop on-site. Karma names that loop: field-carried delivery plus act-time ownership, with no stored owner between. ## Sower and reaper The grid's supplement to the old formula is a split, not a replacement. "The sower reaps" has a report-face and an ownership-face. The report-face is true simpliciter: this deed conditioned this reception, a delivery-fact the field carries. The ownership-face is done: at reception, the reach-back appropriates what arrived as *mine*, and the doing is spent at that same act-time. If delivery drew no line, the reach-back's second place stands unfilled. That failure-mode is vacuity, not falsity: an appropriating with nothing arrived to appropriate. False memory is the psychological dress of the same typing (`WaaVacuousOwnershipFace`, checked concretely by `MemoryWitness.falseMemory_waaVacuousOwnershipFace`). The field owns the conditions in the deflated sense -- it settles whether anything arrived to weld -- while the weld answers only the index-question over what arrives. The diachronic *whose* therefore decomposes into delivery plus fresh appropriation. There is no third cross-gap ownership-fact to store or consult, and no standing backward relation hiding under the reach-back. Held that way, it would be the retrospective soul; the soul-guard is still needed precisely because the index must not be read as stored. ## Contemporary placement The neighbouring positions can now be placed without a verdict on them. Siderits gets the series-questions, and the grid cedes them: psychology, continuity, prediction, causal connectedness, and the individuation of the stream all belong to the field. His conventionalism is an alternative account of the diachronic usage. The residual disagreement is where the soteriology's load sits: this paper locates it in act-time discharge of the offices above, while his convention locates it in the useful series-fiction. Ganeri's account of appropriation (*The Self* -- ahaṃkāra and upādāna worked into a first-personal stance) is the nearest ally. The difference is spentness: Ganeri's appropriative activity is a standing structure of the person, while this weld is per-act and stored nowhere. Zahavi's constitutive for-me-ness receives the taxonomy's fourth public outcome (Theorems): a **retype**. His for-me-ness is thin, pre-reflective givenness, explicitly not appropriative I-making; classifying it as clench would import what the notion excludes. The grid still needs thin act-time for-me-ness, because the weld's token-reflexivity lights the deed as this-deed-for-this-doer. The disagreement narrows to one predicate: standing. Mineness held as a structural feature of consciousness freezes; mineness enacted and spent is the weld's own light. Sartre occupies the clench-as-structure cell after the Zahavi retype: anguish as the very form of consciousness. The placement matters because it lets the taxonomy keep Zahavi's thinness without losing the Sartrean shape that really does make clench structural. ## Pole-typing At share-zero no self-pole index is made, so every terminus-question is a field-question. Fruit from old seeds still lands, since inga is untouched; what ceases is reach-back appropriation. The terminus therefore gives the positive direction of the state-tool: where no live self-pole index remains, the state-tool fits because there is no index-fact for it to miss. This is pole-typing, not a concession to a rival frame. The buddha/stone difference is still carried by the function/share split: the stone mounts no response, while the terminus mounts response without share. The avyākata follows: asking for the Tathāgata's post-mortem self-pole feeds an index-question to what is functionally field. That is the same internal mis-feed as *did I earn this?*, and it needs no extra cell. ## The verdict's tier The word **mis-feed** is kept only for the taxonomy's internal typing failures. It does not name an external failure of another account. At the floor there is no agent and no fruit-for-anyone; at live act-time the question *whose?* can arise and must route through the weld-index. So the separate/fuse rule governs the taxonomy's own words as well: distinctions separate under act-time diagnosis and fuse at the floor and at genjō, the share-zero pole. The soul-guard remains. The agent-index resists being stored because it is emptier than a bearer, not because it is a special thing. A forward-facing owner between deeds and a retrospective owner waiting in memory are the same mistake in opposite directions. ## The disclaimers, enumerated The following are conventional and my own -- original moves, each flagged against the canonical position it departs from or extends. 1. **The tiering, the separate/fuse rule, kannō-sōe, and the coined compound shugenjō** -- contra Dōgen, who keeps all ultimate, and who fused the very shushō I have re-tiered (shō at the floor, shu conventional); and contra the late Dōgen doubly, since Jinshin inga repudiates the tiered fox-reading this paper keeps, a disagreement owned in Theory rather than footnoted, with the act-time gloss on the doubling (Daishugyō diagnosing, Jinshin inga instructing) offered as my own reading and not as a dissolution of the contra; and contra the Mujō seppō fascicle (and Zhanran on 無情有性) a third time, the insentient preaching deflated to the object-axis. 2. **Shō's agency as lent** -- necessarily agential because never unwelded, yet not agential of itself. 3. **For-me-ness located in the weld** -- shu, Row 3's enactment pole, the I-making (ahaṃkāra), so that self is a dependently-arisen process the act makes rather than a state the grade holds. 4. **The reception-weld's reach-back** -- upādāna typed as the two-place token-reflexive index by which loop-closure is enacted at each reception, "the sower reaps" split into a report-face (true simpliciter, field) and an ownership-face (done, full or vacuous) and never a standing relation -- my own typing, though the word is canonical. 5. **The three-register fact-sorting** -- field-facts carried, weld-facts made and spent, Row 2 stated -- a sorting of registers, not of kinds of fact -- and with it the refined premise *nothing self-indexed is stored*, under which the tradition's seeds are absorbed deflated as index-free conditioning-facts rather than deleted (an engagement with, not a reconstruction of, the Yogācāra machinery Chan presupposed). 6. **The reading of Linji's 無位真人** along a three-way seam (無位 = shō, the floor-face / 真人...出入 = shu, the acting / 無位真人 = the weld, shushō-ittō). 7. **The tiering of 証** (realization-as-not-fall, floor-face) apart from **悟** (satori). 8. **Genjō as a single manifestation-floor with two attested arrivals** (the never-scaffolded stone and the scaffold-dissolved buddha; a third left open), practice-run-scaffold-free a proper subset. 9. **The identification of karma with the field/weld loop** -- everything diachronic belongs to the field; every index is enacted and nothing indexed is stored; the naming is earned by the native act-time discharge of karmic ownership's offices. 10. **The token-reflexivity of the weld-index** -- the index is made by the act that carries it: *this act's agent*, constituted by the deed rather than presupposed behind it. 11. **The decomposition of MMK 17's two worries** -- condition-half (`WaaReportFace`), mineness-half (`WaaDiachronicWhose`, `no_diachronicWhose_from_series_alone`, `rePitch_forgets`), mis-feed half (`MisFeedNegative.fence_and_gate`), and reception-deed (`WaaOwnershipFace`). 12. **The stone as the resonance scale's outside edge** -- the predicate typed over responses-to-calls, undefined where none is mounted. 13. **The error-taxonomy as generated**, not listed -- collapse and freeze as the two violations of the separate/fuse rule, one pair per distinction, non-linear by construction. 14. **The two grades of error** -- grammatical verdicts the system asserts (within the lens), soteriological shortfalls it can only display -- with the bodhisattva located structurally by that split, room and shape without pull, and no added axiom. 15. **Kenshō typed as a per-call share-ceding event** -- countable (Dahui's eighteen), unholdable (nothing indexed stored, so backsliding a theorem: `backsliding_witness`, `backsliding_rePitchSequence_witness`), the seen-nature of 見性 declined while the event is kept -- a rung, tiered apart from satori and from genjō. 16. **The theory's own soteriological status** -- a dharma among the myriad that affords a release without enjoining one (the orange, not the "eat this"), its valenced vocabulary borrowed from the object and reported rather than asserted. 17. **Row 2 typed as index-placement** -- the grade's content indexical (where the act's subjecthood sits between being and dharmas), its register third-personal; the register/content split under which *nothing self-indexed is stored* holds verbatim, since a statement holds nothing. 18. **The determination of the share** -- clench fixed by the actual composition of the act's drive: response driven by the call versus by the configuration's self-maintenance, an actual-sequence occurrence-fact about the weld, causal not phenomenal; counterfactual call-variation demoted to probe; Row 2 states a partial ordering, and the scalar is display. 19. **The second retype** -- the disposition/act cell redrawn under the determination clause's own pressure: its content standing/dated, never configuration/act; the collapse inferential -- the dated occurrence read off the standing tendency, prognosis substituted for diagnosis. 20. **The passive spent** -- Dōgen's 万法に証せらるる taken at its grammar: shō as the being-verified, objecthood; shushō-ittō as the two poles of one index-placement. 21. **Clench typed as the weld's self-share**, under the **function/share split**: I-making the welding-function, clench its share-degree. The split blocks the buddha/stone convergence (share-zero is not function-zero), and the identity *I-making just is the clench* is entered in the table as an embryonic collapse. 22. **Vacuity from the field** -- the reach-back's failure-mode typed as vacuity, not infelicity: its index two-place, and where delivery drew no line the second place stands unfilled; "misfire" retained only as display; false memory the same vacuity in psychological dress. 23. **Memory and prudence as theorems** -- the trace a seed, recall a reception, remembered mineness welded fresh at recall-time and the felt storedness diagnosed as the retrospective soul; prudential privilege underivable, owned with Śāntideva (BCA 8.97-98) rather than against him. 24. **Dukkha typed structurally, field-side** -- suffering as the mismatch of a self-maintaining response against a delivery-register that answers to nothing, enacted at clenched receptions and spent; the second truth derived as covariation with share, the third as a corollary at share-zero, the fourth displayable only. 25. **The domain drawn asymmetric** -- one outside edge (the stone, function-zero) and one interior pole (the terminus, share-zero), with the solipsist as the opposite asymptote. 26. **The transposition** -- the terminus question answered rather than declined: the self-pole half (kiriya, ahosi, upādāna-exhaustion) derived as theorem; reception-side welds shown intact and busy; *transposed* demoted from mechanism to display over that pair; the avyākata derived as the *did-I-earn-this* mis-feed, the fire simile read accordingly. 27. **The mirror-reading of the terminus** -- buddha as responsive stone, 大円鏡智, function without share; disciplined as display convention over the run, with 本来無一物 as the guard against device-nature (the mirror given a stand). 28. **The three-killings test, reframed as its own evidence** -- one verb, dispersed events; the cetanā theorem (`grade_independent_of_conditions`, `share_independent_of_conditions`, `cetana_grading_tracks_weld_not_field_witness`, `cetana_live_share_without_object_standing_witness`) and futility theorem (`staticized`, `futility_delivery_loss_real`, `futility_object_axis_subtraction_nil`, `Grid.DirectedConvention.staticized_objectAxisStanding_iff`) derived; ānantarya severity read from response-to-call structure plus delivery-arrogation, never from victim-rank. 29. **The offices-spine** -- the identity-claim argued from the object's usage: every office of karmic ownership discharges at act-time (cetanā, reception, practice, remorse and absolution, dedication), while the diachronic bookkeeping is where the tradition deflates itself. 30. **Contemporary placement** -- Siderits receives the ceded series-questions; Ganeri is the nearest ally by appropriation; Zahavi forces the retype; Sartre occupies the clench-as-structure cell. 31. **The Hakuin reading** -- the Five Ranks as index-placement notation, host and guest as the two poles; the delusion/satori line taken as the inversion's epigram, flagged as paraphrase with pedigree mixed, and nothing resting on the line. 32. **The retype as a fourth generator-outcome** -- a candidate objection that neither lands in a cell, nor adds one, nor is declined, but redraws a distinction's content; admitted because the taxonomy must be answerable for the redrawing of its own distinctions. 33. **The svakarma demotion** -- *fruit ripens only in the doer's continuum* demoted from metaphysical necessity to contingent delivery-regime -- contra the Abhidharma scruple, downstream of the exhaustive decomposition of the diachronic *whose*; pariṇāmanā thereby absorbed on existing cells (`CompoundPosition.ledgerPicture`, `ledgerPicture_decomposition`; `SameAgentDelivery`, `CrossAgentDelivery`, `reception_typing_ignores_sower`, `OtherPowerNegative.regime_does_not_determine_share`, `OtherPowerNegative.share_does_not_determine_regime`). 34. **The orthogonality rule and its price** -- function/share types, effectiveness grades, adaptivity the terminus's manner and never the ground of landing; with the domain joint's honesty-clause entered beside it; and the pole-typing corollary stated as entailed: the state-tool fits exactly where welding ceases. 35. **The being-convention** -- the macro being demoted to a diagnosis-time coarsening convention (`BeingCoarsening`): naming suffices, sentience is fiber-level, coherence is display-grade only, and the namespace order is floor/genjō outside, then directed convention, then being convention, then grid-lens. 36. **The generated pilot rows** -- before/after, beings, and the grid-lens have migrated onto the pole-affirming schema (`rowOf G (.layer ...)`); the original fiat layer semantics is superseded, while the content track keeps `LayerClaim` for aptness checks. 37. **The being trichotomy** -- deleted is the collapse (*there are no beings*), derived is the freeze (one partition reified as ontology), and primitive-and-free is the convention; `Being := Unit`, sentients-only, and gerrymandered models are legal model choices, never signature law. 38. **The hare's-horn register** -- possible/impossible-being distinctions enter at realization and use, not naming; the ātman is nameable-impossible in the same innocent sense, and the swan/name/naming-proneness split keeps named object, naming weld, and naming seed apart. 39. **Modal Realism as the beings-row freeze** -- conventional designation promoted to ontology, *prajñapti-sat* taken as *dravya-sat* (*samāropa*); Lewis placed only as prose nearest miss, Huayan as empty plenitude, Pudgalavāda as the classical occupant candidate. 40. **Aptness-conditional content rows** -- content-bearing denials obey separate/fuse only in grids where the relevant convention is apt; all-stone, direction-void, and no-live-tier countermodels show the hypotheses are necessary rather than cosmetic. 41. **Sraddha as a checked conditional** -- the faith theorem is an implication whose antecedents are not discharged by the grid; the detached injunction remains outside the assertable voice. 42. **Both faith conjuncts matter** -- orthogonality countermodels show terminus-typing alone does not supply the full faith closure. 43. **Generated table structure** -- the Grade-1 table's row list is Lean data (`tableOrder`): nineteen schema rows, one ladder-generated row, and six prose rows with their reasons recorded. 44. **Pole-affirming semantics** -- all schema rows share one tier-semantics: conventional force never lapses, denial holds at genjō by truth, and stability is paid only by the `*_obeys` family; content rows remain diagnostic because their global denials answer a different question. 45. **Prose rows** -- being/non-being, ladder/terminus, genjō/shō, shō/satori, Row 2/Row 3, and description/injunction remain prose by stated reasons, with nearby theorem anchors rather than generated cell content. 46. **Error-free reading** -- 破邪顕正 is checked as the `rowOf_obeys_iff_errorFree` biconditional on the primary language, and `ladder_obeys_of_errorFree` is the cumulative strengthening that vindicates the implemented ladder operator. 47. **The mis-feed fence** -- the avyākata verdict's boundary formalized as an original move: the index-seeking question-form fenced by a schematic non-derivability theorem over a modeled designation-universe (`MisFeedNegative`), with a concrete collision witness and an answered delivery twin in the same model; the universe's adequacy to the canonical avyākata owned as a modeling claim. The tradition sets the questions aside; the fence-and-gate pair, and the claim that one grammatical joint sorts them, are mine. 48. **Ten Bulls typed as correlation** -- Bulls 1-6 as per-call share-drop run, Bull 7 as the checked half-weld, Bull 8 as pole-class, Bull 9 as responsive terminus, and Bull 10 as existential cross-fiber delivery; the stronger all-fibers reading named but shelved. 49. **Five Ranks retyped** -- ranks read as utterance-diagnosis and index-placement, with 到 checked by the Bull 10 shape rather than treated as a stage attained and stored. 50. **Stage-schemes as coarsenings** -- the 52 stages, Bulls, and Ranks are legal as diagnosis-time `BeingCoarsening`s; the freeze warning attaches uniformly to holding any scheme as grid-carried structure. 51. **Fetter-cut typing** -- fetter cutting read as class-restricted fiber-at-pole typing (`FiberAtPoleOn`), with provocation classes model-supplied; `Fetter.kind_lower_iff_cut_by_nonReturn` pins the lower-fetter table, `all_fetters_cut_at_arhatFiber` gives the universal arhat cut, whole-fiber irreversibility is definitional, finite-run diagnosis is underdetermined, and the practical forward guarantee remains conditional. 52. **Two-axis fetter lattice** -- fetter cutting extended to the (call-class × tag-class) product; sravaka-arhat typed as the regional cut, and the total calls/total tags univ-point kept neutral and identical to `FiberAtPole` by theorem; region boundary shown underdetermined. 53. **Enlightenment ladder** -- the total-rectangle cut re-glossed as rung 1 of a three-rung ladder rather than as the buddha point itself; `FettersNegative.total_cut_carries_no_function` checks the stone-vacuity/function gap, `FettersNegative.total_cut_with_function_not_waaFullyEnlightened` checks the effectiveness gap, and `WaaFullyEnlightened` remains regime-relational in both directions: `OrthogonalityNegative.waaFullyEnlightened_stronger_than_terminus` gives zero-effect failure, while `waaFullyEnlightened_of_responsiveTerminus_of_undelivered` gives sealed-delivery vacuity. 54. **Ethics as a bundled conditional code** -- faith-transmitted truth times the receiver's own live aversion, held as one hypothesis-free implication theorem; the detached injunction remains outside the assertable voice. 55. **The code's three honesty clauses** -- empty at the pole, unsatisfiable over false testimony, relative to the faith-object. 56. **Verdict record as data** -- `generatorRecord` stores the verdict history at episode grain: four retypes as four entries, `restraintKind` as the six-kind coarsening, theorem anchors pinned by name beside prose anchors, and `misFeed_entries_carry_decomposition` checking the structural falsifier while the rate trend remains prose. 57. **Compound positions as cell-stacks** -- skepticism, solipsism, the exit-premise, existentialism, and the ledger-picture are Lean data over existing `TableRow`s, with facets, roles, voice checks, legal-element checks, and core-cell counts in `Consequences/Compounds.lean`; value-creation and the ledger-picture's causal skeleton are recorded as legal rather than erroneous. --- *With thanks to Claude (Anthropic) -- sparring partner and midwife to a more resonant theory, and ChatGPT (OpenAI) for the Lean proofs and for systematic refactorings.* "# def identificationDoc : Doc := { id := "identification" title := "Identification and Placements" output := "Exposition/Identification.md" source := "WeldAndArrow/Exposition/Identification.lean" summary := "The identification claim, placements, and disclaimers." blocks := [.raw identificationBody] } end WAA.Exposition ===== FILE: WeldAndArrow/Exposition/Index.lean ===== import WeldAndArrow.Exposition.Basic namespace WAA.Exposition def indexBody : String := r#" ## Contents 0. **Contents** — this table of contents, listing the generated documents in reading order, with each entry inventorying what its document carries; generated, like the rest of the exposition surface, from `WeldAndArrow/Exposition/*` by `lake exe exposition_gen`. 1. **Theory** — the motivations and the rules: the floor, the act-grammar, the grade and its determination, the domain joint and orthogonality, the karma circuit and its three registers, the weld's two faces, the separate/fuse rule; the input-side assumption list at [Assumptions.md](Assumptions.md); one act run whole through the grid; [Glossary.md](Glossary.md). 2. **Theorems** — what falls out of the rules directly (backsliding, memory and prudence, dukkha, the transposition, the error-taxonomy) and the derivations that meet existing discourses (MMK 17, the three killings and AN 6.63, sudden and gradual, other-power, pariṇāmanā, transcription, the Ten Bulls, Five Ranks, and stage-schemes); with the instructive absences in both. 3. **The Identification and Placements** — the karma identification, the offices-spine that earns the name, the sower/reaper split, the contemporary placements, the pole-typing corollary, the taxonomy's internal mis-feeds, and the disclaimers, enumerated. 4. **Formalization** — a plain-English reading of the checked Lean surface: the reading conventions (the `Waa` system-POV marking, the directed-convention namespace layers as ontological ordering, rfl-transparency notes), the preorder and pole-class preliminaries, the signature and its convention layers, the layer-by-layer readings of `Consequences`, `Doctrines`, `Identification`, and `Meta` with the numbered pins, the śūnyatā wrappers and reflexivity witness, the invariance discipline and its sibling countermodels, the verdict ledger, and the axiom audit; with what remains prose-bound flagged throughout. 5. **Assumptions** — the input side, enumerated: what the Signature asserts, what it deliberately declines, and its stand-ins; with checked anchors and the axiom audit. 6. **Glossary** — the generated glossary table from `Meta/Glossary.lean`: each term with its provenance kind (a Theory, Theorems, or Identification coinage; canonical; or Lean convention), a newcomer-facing gloss, checked Lean anchors, and backward-only see-also references; term uniqueness, reference ordering, table length, and anchor resolvability are Lean-checked, while gloss accuracy and canonical caveats remain prose obligations carried by the Disclaimers. "# def indexDoc : Doc := { id := "index" title := "Contents" output := "Exposition/index.md" source := "WeldAndArrow/Exposition/Index.lean" summary := "Contents page for the generated exposition." blocks := [.raw indexBody] } end WAA.Exposition ===== FILE: WeldAndArrow/Exposition/ResidueLedger.lean ===== import WeldAndArrow.Exposition.Basic namespace WAA.Exposition structure ResidueEntry where id : String locus : DocId reason : String anchors : List Lean.Name := [] deriving Repr def residueLedger : List ResidueEntry := [ { id := "glossary-accuracy" locus := "glossary" reason := "Gloss accuracy and canonical caveats remain prose obligations." }, { id := "designation-universe-adequacy" locus := "identification" reason := "Adequacy of the modeled designation-universe to the avyākata questions remains a modeling claim." }, { id := "an663-correlation" locus := "theorems" reason := "The AN 6.63 correlation, peaks reading, and comparative claim against event-typed theories remain prose-bound." }, { id := "hakuin-epigram" locus := "theory" reason := "The Hakuin epigram pedigree is mixed and load-free for the checked mechanism." }, { id := "kuoan-locus" locus := "theorems" reason := "The exact Kuòān verse locus for the Ten Bulls guard should be verified across translations." }, { id := "historical-contra-dogen" locus := "theory" reason := "The Daishugyō/Jinshin inga historical contra is owned as interpretation, not discharged by Lean." } ] example : residueLedger.length = 6 := rfl end WAA.Exposition ===== FILE: WeldAndArrow/Exposition/Theorems.lean ===== import WeldAndArrow.Exposition.Basic namespace WAA.Exposition def theoremsBody : String := r#"# Weld and Arrow — II. Theorems *Second of three files. Nothing in this file is posited: everything is derived from the rules stated in Theory. §1 collects what falls out of the typing directly; §2 the derivations that meet existing discourses on their own ground; §3 gathers the instructive absences in both. Cross-references to the companion files are marked (Theory) and (Identification).* ## §1 What falls out of the theory directly ### Backsliding: kenshō cannot be held Because nothing indexed is stored between acts, a kenshō *cannot be held*: post-kenshō backsliding, which the tradition treats as an embarrassment needing explanation, falls out as a theorem. The being loses no attainment; there was never a stored configuration to lose, only the next act's re-weld reading a re-pitched fit. Many kenshōs, none possessed. The checked same-grid form is `backsliding_witness`, with the sequential carrier stated as `backsliding_rePitchSequence_witness`; the maximizer form remains `rePitch_forgets`. (The typing of kenshō as a per-call share-ceding event — a rung, tiered apart from satori and from genjō — is given in Theory: Attainment.) ### Two pressure-tests met as theorems: memory and prudence The typing *nothing self-indexed is stored* meets its two obvious counterexamples head-on rather than waiting for them. **Memory.** Autobiographical recall presents as stored mineness — the deed remembered *from the inside*, ownership apparently carried across the gap. The grid's answer is already assembled, and it is not a patch: the trace is a seed — a conditioning-fact in the impersonal series, index-free, field-freight like every seed — and the recalling is a **reception**. What arrives at recall is a return of the deed (its trace delivered to this configuration now), and the reach-back welds it exactly as it welds any return: two-place, *this remembering of that deed, mine* — made at recall-time, spent at recall-time. The from-the-inside phenomenology is thereby predicted rather than explained away: the reach-back's content just is a reaching of a past deed as mine, so recall presents as appropriation because it is one — enacted now, not exhumed. What is not predicted, and is diagnosed instead, is the storedness the presentation suggests: mineness felt as having *waited in the trace* is the retrospective soul in psychological dress, the reach-back frozen into a standing backward relation — an existing cell, no new machinery. And false memory falls out on the vacuity typing (Theory: the reception-weld): a reach-back along a line delivery never drew, vacuous rather than false — an appropriating with nothing arrived to appropriate — which is why confabulated ownership feels exactly like the real thing from within the act; whether the second place was filled was never an inner mark. The checked same-grid form is `MemoryWitness.memory_witness`: `recall_waaOwnershipFace` and `recall_waaDiachronicWhose` give the full delivered recall, `falseMemory_waaVacuousOwnershipFace` gives the vacuous false-memory face, `recall_spent` is the `rePitch_forgets` instance for made-and-spent-at-recall-time, and `sowingReapingRow_not_freeze` is the retrospective-soul cell reused rather than expanded. **Prudence.** With nothing indexed stored, concern for one's own future fruit is a present weld whose object is a delivery-fact — *fruits will arrive at the configuration this series delivers them to* — and the future reaper's mineness will be made by *that* reception's reach-back, then, not held by anyone now. So the special rational authority of prudence — my concern for my future self grounded as concern for others is not — is underivable in the grid: the standing cross-gap *whose* it would need is the one thing the typing declines. This is owned as a **theorem, not a cost**, and it keeps canonical company: Śāntideva argues exactly this shape (BCA 8.97–98 — the one who suffers later is not the one who acts now; if suffering is to be prevented, the boundary does no work), and *na ca so na ca añño* was never going to fund prudential privilege. What falls out structurally — displayed, never enjoined — is the bodhisattva's impartiality: concern indifferent to which configuration the fruit arrives at is simply what concern looks like with the arrogation subtracted, care running on delivery-facts alone. The grid does not say *therefore be impartial*; it shows that partiality was resting on a fact-shape the floor never held. ### The deliberator: consequentialist display The forward face of the prudence theorem is the deliberator's theorem. The grid does not prove consequentialism false — that would be the description/injunction collapse in its own voice — but it does prove that the objective the deliberator wants is underdetermined at each of the joints it needs to hold. First, **the "my" is conventional**. A finite list of actual receptions can be counted for share-drops, but "the drops accruing to this being" requires a supplied being-convention. The checked witness (`ObjectiveNegative`) gives one grid, one run, and two legal coarsenings: merge and split return different fiber-restricted counts. A convention-free objective over the grid data cannot return both. The *my* in "maximize my attainment" is furniture the deliberator brings. Second, **the accumulator is absent**. `rePitch_forgets` says the post-reception configuration ignores the prior configuration and reads only the last received weld's share. Any run-valued score that factors through `Config` is therefore constant across histories sharing the final reception. This is the backsliding theorem in maximizer form: no stored attainment variable exists for the objective to increase. The direct kenshō-then-live-reception shape is checked separately by `backsliding_witness` and `backsliding_rePitchSequence_witness`. Third, **transfer is underdetermined exactly where adaptation matters**. The transfer witness gives two adaptive responders agreeing on the teacher's whole seen track record and disagreeing at the fresh call. No estimator from restricted track data determines the fresh-call effect. The contrast theorem is the static case: `ResponseInvariant` determines the unseen response from the seen one, so transfer holds precisely where call-adaptivity has failed. Fourth, **the grade is independent of downstream conditions**. `grade_independent_of_conditions` and `share_independent_of_conditions` change only `conditions` and leave grade/share fixed. This is the formal anchor for the cetanā correlation: what is graded is the weld — agent, call, response composition — not the later delivery-fact. `cetana_grading_tracks_weld_not_field_witness` gives two actual welds with the same field residue and different shares, and `cetana_live_share_without_object_standing_witness` gives live share where object-axis standing fails. The AN 6.63 correlation itself, the "peaks" reading, and the comparative claim against event-typed theories remain prose-bound. The correlation with intention is asserted as typing; its wisdom is displayed; intention ethics is not endorsed. Finally, **the command over landing is quotable, never satisfied by command**. The delivery-command language lets a recorded utterance say "this deed's fruit lands there"; the witness grid with no such delivery proves the utterance fails `FitsOfferedTier`. Delivery-engineering remains legal: shaping conditions is ordinary inga. What fails is plan-as-command over the one register no act holds. This is the Ten Bulls guard in deliberative dress: grasping the bull is the drop held. The exact verse locus should be verified across Kuòān translations, but the typing is already checked: held attainment is the accumulator the grid declines. The theorem proves only this much and no more: it does not show that consequentialist deliberation cannot condition good landings; it shows that the objective's *my*, accumulator, and command are respectively convention, non-existent, and unsatisfiable. ### Dukkha: the grade's valence earned Why a valence section at all, in a system that asserts no value? Because the no-value clause looks like it forbids the first noble truth. If the grid asserts *clenched welds suffer*, and suffering is bad by definition, a value has entered the system's own voice — the "eat this" collapse committed against itself. The look is wrong, and the theory-of-poison discipline already says why: a theory of poison asserts which direction kills without enjoining; this theory asserts what the arrogation-direction costs without enjoining. **Dukkha's occurrence and mechanism are assertable; its badness is displayable.** On that split the four truths distribute across the two grades of error by themselves. The section has one further duty, discharged at its end: to type dukkha so that nothing here leans on the ownership-argument's joint (Identification) — the derivation runs field-side, deliberately. **The mechanism, stated third-personally end to end.** The determination clause (Theory: Attainment) already supplies a non-valenced vocabulary for arrogation: response driven by the configuration's self-maintenance rather than by the call. Generalize it across receptions, and a nonzero-share configuration is one that responds *as if delivery answered to it* — as if what arrives next were owed the rank's echo, the self's projection, the call drowned in the response. But delivery answers to nothing: the delivery-register is the one register no act holds, proven twice already (the delivery-arrogation cell, taxonomy below; the futility theorem, §2), and calls do not stop arriving — no exit from the arriving of calls is the grid's own row. So every nonzero-share configuration runs a standing self-maintenance drive against a register that is structurally command-proof, and the collision recurs at each clenched reception. **Dukkha is that recurring mismatch**: a self-maintaining response colliding with a delivery it cannot command, enacted per reception. The fox worked example instantiates the identity at each clenched reception *(checked: `fox_dukkha_per_life`)*. Nothing in the statement is a claim being frustrated, an appropriation coming back empty, or anything performative at all — just a drive-structure meeting a register that does not answer to it, re-delivered. Inga can state all of it. **The second truth falls out as covariation, and the looseness is priced.** Mismatch scales with share, per-call: the share *is* the self-maintenance's part in driving the response (the determination clause), and the mismatch *is* that same self-maintenance meeting non-covarying delivery — the two are read off the same actual structure, so suffering covaries with arrogation by construction of both. And the covariation is consumed exactly as the priced scalar licenses, ordinally — more share, more mismatch — no measure needed anywhere in the derivation. That is the origin-claim — clinging conditions dukkha — derived rather than imported, and it keeps the first sermon's own company: the sermon's compressed definition — in brief, the five clinging-aggregates are dukkha (SN 56.11) — already ties dukkha to appropriation rather than to a feeling-quality. One honesty-clause: covariation is a notch looser than identity — *read off the same structure* is not *just is* — and the notch is the price of deriving field-side. It is paid rather than hidden. **The standing/dated guard, or the section walks into its own table.** Dukkha read purely off seeds is the collapse the retyped disposition/act cell names — the dated occurrence read off the standing tendency — so the typing must be two-faced, exactly as the defiance entry split the fighting-stance. The *proneness* to suffer is a seed: the tendency to arrogate, field-freight, carried, third-personal. The suffering *itself* is enacted: it occurs, or does not, at each reception, at act-time, and is spent like everything enacted — an occurrence-fact once it happens, field-storable as a fact *about* the series, never stored as a standing pain. This is the standing/dated row doing its ordinary work. **The third truth is a corollary already half-written.** At share-zero there is no self-maintenance for delivery to collide with: the response is driven by the call entire, so no mismatch is constructible — the mirror does not suffer for the same reason it does not reach back. The terminus section's line (below) — upādāna fuels becoming, so appropriation's cessation is becoming's — here gains its valence-face: cessation of arrogation is cessation of dukkha, by the same construction. Fruit still lands (Devadatta's rock ripens on schedule); what has ceased is not arrival but the colliding. **The fourth truth the grid can only display.** The path is precisely the "eat this" the system's voice is forbidden: the grid can show that share-ceding events occur — kenshō, the fox's one reception done saying — and stop. Here the displayed asymmetry of the grade becomes legible as the thing a soteriology latches onto, which is what *the grade's valence earned* means: not a value asserted, a cost stated. **Domain, not phenomenality, answers the consciousness question.** The obvious pressure — doesn't any setpoint-system "suffer" mismatch on this typing? does the thermostat ache? — is answered by domain, not by a phenomenal primitive the determination clause banned (no inner glow was ever consulted, and none is now). Dukkha is typed over exactly Row 2's domain: defined wherever a share is readable, undefined where no response is mounted. The stone cannot suffer — function-zero, outside the domain, nothing the mismatch would be *for* even in the thin sense below. The terminus does not suffer — share-zero, nothing colliding. The never-clenched welder, should the world deliver one, is suffering-free by construction — a check the typing passes for free. And where the domain's boundary falls — whether a plant or a simple animal mounts a response at all — is a delivery-fact about what the world delivers, typed exactly as the stone's edge already is, so a gradualist about response-mounting presses on the boundary's location, not on the typing. What supplies the *for* is not a phenomenal register but the Zahavi retype's own concession (Identification): the weld's token-reflexivity is a thin act-time for-me-ness, so anything that welds is already the kind of thing whose mismatch is for it — in the spent, act-time sense, no standing subject required. **The phenomenology is then predicted rather than explained away** — the memory theorem's move (above), reused. Suffering presents as felt because a self-maintaining response enacted against non-covarying delivery, lit as this-deed-for-this-doer, just is what the collision is like to enact from within. That is the display-face, and it carries the Hakuin epigram's status: offered, illuminating, and load-free — the mechanism stands without it. **Last, the insulation, stated as architecture.** Dukkha never needed the ownership-identification (Identification). Ownership is the index-question, and suffering is not an index-question: its mechanism is field-describable in full, and its occurrences are occurrence-facts about welds. Anyone who declines the act-time identification can still state the whole of the four truths in field vocabulary and lose nothing this section asserts. That is deliberate: the truths are built ecumenical across the lens dispute, and the quarantine runs system-wide. No section of the grid runs on performative machinery; Austin's word *misfire* appears in Theory only as display over a pattern. The taxonomy takes the section's errors without new cells, which is the tidier outcome. The collapse is the fourth truth said in the theory's voice — "escape this" — the description/injunction cell wearing dukkha's face, theodicy's twin. The freeze is suffering held substrate-bound — "only ending me ends this" — which is the clench-as-furniture cell already in the table, now legible as a dukkha-error: the suffering mis-typed as demolition-requiring where de-clench is demolition-free by the theorem that makes kenshō unholdable. And the proneness read as the occurring is the standing/dated collapse at the valence. Three errors, zero new rows: the generator absorbing a doctrine whole is the identity-claim's small sibling behaving as advertised. One revision owned. Typing dukkha structurally is quietly revisionist against readings on which dukkha is irreducibly phenomenal — a feeling-quality first, a structure second. The shape of the revision is the same as the identification claim's: possibly revisionist for suffering simpliciter, doctrinal for the origin-claim — where the tradition itself locates dukkha's source in the craving-and-clinging rather than in the feeling, and where its own first compression made the aggregates-under-clinging the definition. ### The terminus: the question the grid transposes The limit question is this: **at total non-arrogation, does the act still weld?** Does the buddha's deed carry an index — is there buddha-karma? Declining the question as mis-asked — separated-tier vocabulary offered at a fusion point, a domain-exit symmetric with the stone's edge — will not do: the decline buys itself a domain-symmetry the scale does not have, and it leaves a debt unpaid, since Bull 10 describes terminus-activity in positive weld-vocabulary ("the welding done there is the students'"), which a declined question has no right to. The function/share split pays the debt. The fork the question forces — *yes*, and a share-free weld persists at the summit, the subtlest soul, 無位真人 as rank one last time; *no*, and the exit-collapse arrives in typing's clothes — is a **false fork**, but its falsity must be located precisely, because the third answer is not a third mechanism. The *no*-horn bundles two claims: that the terminus-deed makes no self-pole index (true, and a theorem below) and that the terminus therefore drops out of the index-economy altogether — indexless *and inert*, dead even at others' Row 2 (false, and the collapse). Unbundle them, and what remains is the second horn survived, not escaped: no self-pole index, object-axis standing intact. **Transposed** is this pair's display-name, and it will be disciplined as such below. Take the two halves separately, because their status differs. **The self-pole half is a theorem, not a display-gloss.** At share-zero the deed makes no self-pole index; no reach-back appropriates what arrives; fruit from old seeds still lands, since inga is untouched — Devadatta's rock ripens on schedule, the body's series exhausts — but it lands with its delivery-fact entire and no live index-question: nobody's, in the precise sense that no reach-back welds it, which is ahosi territory *derived* rather than borrowed. This is the kiriya doctrine — the arhat's deeds functional, generating no vipāka — and the nidāna-chain read forward — upādāna fuels becoming, so appropriation's cessation is becoming's. The grid does not merely report these with borrowed valence; it asserts their typing: share-zero entails reach-back-zero by construction. **What remains indexed is the returns — at their receivers, as always.** A terminus-act's fruit lands at others' receptions and is welded there by their reach-backs — the students' welding, each spent at its own reception-time like every weld in the grid. This is not a new mechanism smuggled in for the summit, and it must not be over-claimed either: an act *pointed at* by another's weld does not thereby bear an index — stones are pointed at too — and the reach-back's second place was always where every deed's fruit-end index got made. The terminus merely subtracts the sowing-side weld and leaves the reception-side economy running exactly as it always ran. So "the index changes pole," said strictly, compresses two theorems — self-pole zero (above); reception-side welds intact and busy — into one figure of motion, and the figure is display, not mechanism: nothing travels. The buddha's whole difference from the stone is carried by the function/share split alone, nowhere else. The passive 証せらるる, spent at the floor in the act-grammar, is spent again here: the terminus-being is the verified, object-axis entire — what everyone else receives. **What stands at the pole, then, is a device** — and the word must be immediately disciplined. Not a stone: the stone mounts no response, and the terminus mounts every response — call-sensitive, its output driven per-call by the asker's configuration, upāya running, meeting each being where it is. The responsive stone has a canonical name: the **mirror** — great-mirror wisdom, 大円鏡智 — shaped output per-call, nothing held, nothing claimed, no mineness anywhere in the responding. Function without share. On the object-axis, buddha and stone are the same kind of thing — dharmas among the myriad, advancing at others' Row 2 — and the buddha's whole difference is functional, not indexical: the maximally adaptive call, the orange perfected, a dharma that finds the modality that lands — where "maximally adaptive call" now carries its deflated sense (Theory: Orthogonality): adaptivity is the terminus's manner, never the ground of landing. **And typing closes every grade but one.** The orthogonality rule (Theory) bites hardest here: terminus-typing settles where the index sits and settles nothing about what lands. The buddha-side shortfall is graded independently of typing, ordinal with effectiveness, and it is the pole's one live grade — which corrects an implication the mirror-figure risks, that arriving at the pole left nothing to grade. The limit-case makes it vivid: an adaptive device at zero effectiveness is terminus-typed, reads every being, and reaches none — the reading that never reaches. So "the pole perfected" is not a typing plus a mystery; it is the one grade closed — every call finding its landing — and grading the terminus is neither impiety nor category error: it grades effectiveness, the register delivery owns, and never re-opens the share. Its misses, where they occur, grade the responder and never the missed being — the deaf-blind decline (taxonomy, below) transposed to the responder's ledger: delivery-engineering incomplete, a buddha-side shortfall displayed. **The avyākata falls out.** *Does the Tathāgata exist after death?* seeks the self-pole index of a being whose index-facts sit wholly at others' receptions — an index-question fed to what is, functionally, field: the *same mis-feed* as *did I earn this?*, already in the taxonomy, no new cell required. The fire simile reads exactly: fires do not *go* anywhere — the process ceases while everything it delivered persists as field-fact, warmth given, things cooked, a koan still ringing. And the verdict is disciplined by its twin, staged here deliberately: *what does the Tathāgata's death change?* — the same being, the same event, the same surface noun — is **answered**, not dissolved. Death converts the device adaptive→static, a real delivery-loss statable third-personally, subtracting nothing from the object-axis (the futility theorem, below). One question seeks a post-mortem self-pole index and meets the mis-feed's precondition exactly — an index-question fed to what is functionally field; the other is a delivery-question, and no precondition is met at all. The verdict sorts the pair along the one joint it owns, index/delivery, and touches nothing else. The sorting is checked: `MisFeedNegative` (Lean) fences the index-seeking question-form schematically under a witnessed collision hypothesis, and answers the delivery twin in the same concrete model — the fence and the gate together. The Buddha's silence is thereby the refusal of a category error the questioner could in principle be shown — a Grade-1 verdict, assertable, and cheap: it needs no domain-edge, only the index's placement. Declining to speak where speaking would mis-tier remains the correct conventional-tier speech-act — the Jinshin inga gloss (Theory: Karma), structurally intact. The pair also settles what the silence is *not*: not a policy for hard questions — the delivery twin is hard in the ordinary way and gets its ordinary answer — but a verdict on one grammatical shape, available only where the index/delivery joint is crossed. **One guard, and it is the soul-guard in new vocabulary.** Held carelessly, *device* freezes: device-*nature* substituted for buddha-nature is still a 性, a standing kind at the summit — the rank-freeze in instrument dress, a mirror *with a stand*. Huineng's correction to Shenxiu is the guard stated in the object-language: 本来無一物 — fundamentally not one thing, no mirror-substrate to polish. So the discipline applies once more: *device*, *mirror*, *special stone* are legal as display conventions over the run — the pattern of per-call, share-zero responses compressed as if it were an apparatus, exactly as the bhūmis were legal as trajectory-summaries — and illegal as a nature the terminus has. And *transposed* stands with them: a figure over two theorems, never a motion an index makes. What is assertable at the pole is only this: per-call responding that claims nothing, indexed where received. (The freeze's scope is drawn in Theory: the domain joint — device-nature freezes only where predicated of a *being*; of function-zero furniture it is trivially true and no error.) And the speech-guard carries over unchanged: fusion is indexed to the act, per-call, never to the room. A call from a not-yet-buddha arrives where *that being's* diagnosis is live, so the terminus-response rightly speaks separated-tier — "not obscure, full stop" — and nothing here silences the teaching. ### A taxonomy of error The grid errors are generated; the distinctions are curated under a discipline, and the curation is answerable but not derived. Every distinction the system holds is governed by the one separate/fuse rule — separate under act-time diagnosis, fuse at the floor and at genjō — so every distinction yields exactly two errors: - **Collapse** — fusing a distinction *under act-time diagnosis*. The fox is the paradigm: not-fall spoken where not-obscure was called for. - **Freeze** — separating, holding, reifying a distinction *as a floor-claim*. Reading 無位真人 as a rank one rests at is the paradigm — the 乾屎橛 error. And the generator is testable in public: a candidate error either lands in an existing cell, forces a new distinction into the table, or is **declined** — classified as no error at all — and the third verdict is as informative as the first two, since a taxonomy that over-generates has frozen itself (grid-attachment in diagnostic dress). And there is a fourth verdict: a candidate can force a **retype** — neither landing in a cell, nor adding one, nor being declined, but redrawing a distinction's content — and the taxonomy is answerable for that outcome too. The verdict is exercised, not merely admitted — four times: against Zahavi (Identification), against the grid's own disposition/act cell, forced open by the determination clause (Theory: Attainment), against the arrow itself (Theory: Karma), and against the intra-weld arrow — the taxonomy answerable even to its author's clauses. And the verdicts have a history, which is entered here because the over-generation worry is inductive and no theorem retires an inductive worry — the honest answer is a record. Its checked face is now Lean data (`generatorRecord`): the retype count is derived from four episode entries, the six restraint kinds are pinned on the image of `restraintKind`, Lean anchors are pinned by name beside prose anchors, and the structural half of the falsifier is checked by `misFeed_entries_carry_decomposition`; the rate-trend clause remains prose because no theorem retires an inductive worry. The record so far: four retypes, each *forced rather than chosen* — Zahavi, the disposition/act cell, the arrow, and the intra-weld arrow — the system's own clauses prying the table open against its author; the terminus question answered rather than declined at exactly the point where dissolution was cheapest (the transposition, two theorems); the fox's question — as avyākata-shaped as a question gets — answered *not obscure, full stop*; the deaf-blind case declined as no error at all; the standing no-verdicts on open delivery-questions; and the series-questions ceded wholesale from page one. Six kinds of restraint, each recorded before the objection they answer was raised. And the record names its own falsifier, since a history without one is testimony: mis-feed verdicts arriving unaccompanied by their exhaustive decompositions, or the decline-and-retype rate shrinking as candidates accumulate, would be the taxonomy freezing against its cases — grid-attachment in diagnostic dress, read off the ledger the taxonomy keeps on itself. The generator machinery is checked abstractly in Lean, and the table's structure is now generated whole: the row list is Lean data (`tableOrder`). Nineteen rows carry the pole-affirming claim-language and cite their checks (`rowOf_obeys` and the per-row corollaries below); the level-*n* row is generated by the re-emptying ladder (`ladder_obeys`, `no_level_final_of_obeys`, and — refutation alone climbing the ladder — `ladder_obeys_of_errorFree`); the six remaining rows are enumerated as prose rows in the same data, each with its reason on record. The content rows sit beside the schema rows under aptness hypotheses, with countermodels in `ContentNegative` showing those hypotheses are needed. One honesty-clause, kept where the reader can see it: the generated rows share a single tier-semantics — that sharing is the one rule doing the generating — and each row's *specific* cell content is checked exactly where a named anchor theorem is cited beside it, and remains prose where none is. And a discipline governs the generator's inputs. The taxonomy may grade a recorded utterance only where the record carries its call: placement is per-call and drive-composition is a fact about a response *to* something, so a quotation severed from its call is ungradeable — only quotable. The checked face is the underdetermination result `no_grade_recovery_from_severed`, with `gradeability_severed_underdetermination_witness` and `severed_transcript_ungradeable` giving the concrete missing-call carrier. The koan-form is the genre this discipline names: it records the call with the response — the student's question standing beside the master's answer, the turning word and what it turned — which is why the fox is gradeable and why these files' evidence base was koans throughout; the checked positive half is `recordedUtterance_grade_determined`, the `rfl` fact that a recorded utterance grades through its carried weld. The normative "may grade only," the koan-genre identification, and the word *quotable* remain prose-bound; Lean checks the severed-record collision and the call-carrying architecture. The rule's precedent is the flag already on the Hakuin epigram (Theory: Attainment — pedigree mixed, nothing leaning on the line), now made general. And the generator's standing verdict on severed transcripts is the third one, *decline* (`severedVerdict`): nothing to classify, no position present. Classical nihilism turns out to be a freeze, not a collapse: the void is emptiness reified as an *absence* — a snake wrongly grasped is still grasping. And mis-typing — the state-tool for an act-job, the faculty-reading of Row 2 — is the freeze applied to the act/state distinction specifically: an act frozen into a standing configuration. The no-value clause then forces **two grades of error**, which behave differently and must not be run together: 1. **Grammatical errors** — tier-errors and typing-errors. These the system can *assert*, because a mis-feed is a conventional-tier logic verdict, not a value. The fox's mistake is assertable. (Assertable, note, *within the lens*: "tier-error" and "mis-feed" are verdicts of the two-truths machinery itself, compelled inside it and offered outside — the banner's clause governs the grid's own voice, and the asymmetry between the two grades is an asymmetry in that voice, not an appeal to lens-free logic.) 2. **Soteriological shortfalls** — arrogation, self-forward, low resonance, failure to meet beings. These the system can only *display* — Row 2 placements and Row 3 directions, valence borrowed from the object. The five hundred fox lives were returns, not punishments; by the same token "he failed to act as a bodhisattva" is never an asserted wrong, only a displayed asymmetry. #### Grade 1: the generator's output (assertable) | Distinction | Collapse (fused at act-time) | Freeze (held at the floor) | |---|---|---| | Being / non-being (Nishitani) | — | Nihilism: absolute non-being taken as privative void, one more member of the pair. It wears an epistemic face — skepticism, no-floor reified into no-warrant, as if conventional standing had ever rested on a final floor (the *sarvaṃ yujyate* reversal declined: it is *because* of emptiness that everything works) — and a practical face — annihilationism, death held as a floor-event, an exit the loop never had; the fox died five hundred times and no death was the release | | Level *n* / level *n*+1 (Jizang's fourfold; Lean-generated by `ladder_obeys`) | Skipping the ladder — cheap transcendence, floor-talk without having emptied anything | Eternalism at level *n*: this pair is the final floor (`no_final_level_of_errorFree`, `ladder_obeys_of_errorFree`) | | The ladder / its terminus | — | Emptiness-sickness (空病): seeking a fifth negation, the emptying itself frozen into a path-object instead of the seeking dropped. The absence is structural: there is no "completed ladder" claim constructor (`no_final_level_of_errorFree`) | | Rung / pole of the grade (kenshō / genjō) | A kenshō spoken *as* genjō — a rung as the floor; the 禅病 of "stinking of Zen," an opening inflated into arrival — the fox's error at another joint (`rungPoleRow_obeys`, `kensho_as_genjo_collapse_self_refuting`, `rung_not_pole_witness`) | Genjō held as *final* kenshō — the pole as top rung, awakening as a still attainment, daigo as rank; "full satori" is this freeze miniaturized — a state-word for a per-call pattern (`rungPoleRow_not_freeze`) | | genjō / shō (two middles) | Conflating them — manifestation taken as realization, or conversely | Holding the two-middles distinction itself as a final floor-claim | | shō / satori (証 / 悟) | Reading the floor-face as the awakening-mode, or conversely | Satori as a datable possession | | shu / shō (the weld) | **The fox**: not-fall asserted conventionally — antinomianism. Converse fox: not-obscure insisted on at the floor — moralizing where nothing falls (`foxWeldRow_obeys`, `fox_notFall_collapse_self_refuting`, `fox_utterance_misfits_live_offer`) | Two one-sided freezes: shō without shu (quietism, Dahui's silent-illumination target — emptiness that only empties) and shu without shō (practice as means to a later attainment, breaking shushō-ittō) (`foxWeldRow_not_freeze`) | | Row 2 adverb / Row 3 verb | The placement *being* the self — grade collapsed into agent | Resonance held as a faculty; buddha-nature as substance; the empty agent re-based | | Doer / deed | *No doer, only deeds* — bundle-reductionism spoken as live diagnosis, mounted by a being answering a call (`doerDeedRow_obeys`, `no_prior_doer_collapse_self_refuting`) | The prior doer: kāraka held prior to karman, MMK 8's target occupying its own cell; the soul in relational dress, distinct from the Pudgalavāda cell because here the *priority* is reified (`doerDeedRow_not_freeze`, `DoerDeedNegative.no_priority_recovery`) | | Function / share | Share-zero read as function-zero — the buddha a literal stone, quietism at the summit, the mirror denied its responding; the identity *I-making just is the clench* is this collapse in embryo (`functionShareRow_obeys`, `functionZero_from_shareZero_collapse_self_refuting`, `shareZero_not_functionZero_witness`) | Device-nature: the function frozen into a standing kind — the mirror given a stand; 本来無一物 is the corrective; "special stone" cashed as ontology rather than lent as display — scoped to beings (Theory: the domain joint): of function-zero furniture the predication is trivially true and no error (`functionShareRow_not_freeze`) | | karma / inga | The mis-feed: an index-free field fed to an index-requiring designation (`karmaIngaRow_obeys`, `misfeed_collapse_self_refuting`) | The soul: the index *stored* between welds — a standing bearer. Maximized, the solipsist's stored-index face annexes the whole field; the self-forward and Row 2-domain faces are neighboring cells in the compound decomposition rather than new rows (the solipsist is the stone's inverse: all response, no call, unable even to state what listening to Hyakujō would be) (`karmaIngaRow_not_freeze`, `solipsism_decomposition`) | | Sowing / reaping (the diachronic index) | Ownership read off the series alone; sameness-of-being as bare continuity-fact (`sowingReapingRow_obeys`, `series_ownership_collapse_self_refuting`, `no_diachronicWhose_from_series_alone`) | The retrospective soul: the reach-back held as a standing backward relation rather than spent at reception — memory's felt storedness read literally is this freeze in psychological dress (`sowingReapingRow_not_freeze`) | | Delivery-question / index-question | Mis-fed in either direction: an index-question fed to the index-free field (*did I earn this?* — akṛtābhyāgama's mis-feed half; *does the Tathāgata exist after death?* — the same mis-feed at the pole), or a delivery-fact arrogated by the weld — an act claiming command of what arrives next ("easy"; every exit-arithmetic; Devadatta's aim), authority over the one register no act holds (`deliveryIndexRow_obeys`, `misfed_register_collapse_self_refuting`) | One's future occurrence at others' Row 2 held now as a first-personal possession — "my potential," "my worth to them" — a delivery-fact, read at *their* act-times off whatever the field brings, frozen into something the being holds and could therefore weigh, spend, or withdraw — prudential privilege is this freeze's forward-facing twin, the cross-gap *whose* held as rational ground (`deliveryIndexRow_not_freeze`) | | Weld / event-type (severity) | Karma graded off the event-type with the weld erased — Cunda owed remorse, intention deleted from the arithmetic (`weldEventTypeRow_obeys`, `eventType_grading_collapse_self_refuting`) | Victim-rank: severity read off the victim's station — the honorific inflating the crime; rank smuggled back through the tariff (`weldEventTypeRow_not_freeze`) | | Disposition / act (seed / clench) — **retyped: the distinction is standing/dated, never configuration/act** | The dated occurrence read off the standing tendency — *he arrogates, so this act was arrogated* — prognosis substituted for diagnosis, Row 2 made to read seeds instead of deeds (what the determination reads — the configuration's part in driving *this* response — is not this cell: every act is the configuration's act); dukkha read off the seed — the proneness to suffer mistaken for suffering occurring — is the same collapse at the valence (`standingDatedRow_obeys`, `prognosis_as_diagnosis_collapse_self_refuting`, `standing_does_not_determine_dated`) | The seed as bearer — ālaya frozen into a self carrying mineness between acts. Two further faces: the clench as *furniture* — contraction mistaken for a standing thing removable only with its substrate ("only ending me ends this"), dukkha held substrate-bound being this freeze wearing its valence, where de-clench is demolition-free by the same theorem that makes kenshō unholdable; and the clench as *structure* — contraction made constitutive of the being (anguish as the very form of consciousness — the Sartrean face; Zahavi's thin for-me-ness is expressly *not* this cell, taking the retype instead, per the placement in Identification) (`standingDatedRow_not_freeze`) | | Subject-axis / object-axis (the stone) | 無情有性 as subject: insentient realization (`subjectObjectAxisRow_obeys`, `insentient_subject_collapse_self_refuting`) | Object-axis standing denied — to another (the stone allowed no insentient preaching), *reflexively* (the private buddha declining his own occurrence at others' Row 2), as the solipsist's Row 2-domain evacuation, or held annullable by the being (death as the subtraction of a dharma — but a register the stone occupies without a self, a life, or a single mounted response is not one a being can exit by ending any of these; death reconfigures which dharma the field delivers, never whether one arrives) (`subjectObjectAxisRow_not_freeze`, `solipsism_contains_row2_domain_evacuation`) | | Undefined / zero (the stone's edge) | The stone's undefined read as *maximal* openness (`undefinedZeroRow_obeys`, `undefined_as_openness_collapse_self_refuting`) | Zero taken as the scale's first rung rather than a gloss from outside it (`undefinedZeroRow_not_freeze`) | | Per-call / global altitude | — | The stage-scheme error: bhūmis as rank held, a global altitude, rather than cross-sections of the loop's run — and its diagnostic twin, a delivery-fact read as altitude: "this being cannot awaken" said of a being some calls cannot reach. The freeze is two-banked: on the responder's side, upāya held as a standing competence — the device as possession, deployed unread of who is asking. The self-forward direction canonized as ontology or human condition is this row's direction face. The stored-quantity picture of awakening — an altitude accumulated and held — is this freeze under its sudden/gradual face (§2) (`perCallGlobalRow_not_freeze`, `solipsism_decomposition`, `existentialism_decomposition`) | | Description / injunction (the orange) | "Eat this": the displayed asymmetry taken up *by the theory* as command — theodicy is this collapse applied to akṛtābhyāgama, suffering asserted as assignment; "escape this" — the fourth truth said in the theory's voice — is the same collapse applied to dukkha. Mirrored on the recipient's side: defiance — the orange refused *as command*, an injunction fought that was never issued; the fighter collapses the same distinction from the other bank, shadow-boxing a voice the grid does not have (`assertable_ne_displayable`) | Refusing to state the asymmetry — a theory of poison that won't say which direction kills (`pole_validates_all_claims`, `pole_tier_buddha_inhabited`; at genjō everything is true, fused; the pole is not a truth-maker elsewhere) | | Theory / ultimate (the grid-lens; Lean-generated schema row) | The lens denied as live diagnosis — the grid dismissed because it is only a lens (`gridLensRow_obeys`, `lens_denial_collapse_self_refuting`) | Grid-attachment: this lens taken as final (`gridLensRow_not_freeze`) | | Terminus / exit | Not-fall taken as *escape* — the buddha as one who has left the loop rather than one who answers with no share claimed; the same collapse enacted rather than held is the exit-premise ("a way out"), and it fails on both axes — no exit from the arriving of calls, and none from the register at which one arrives for others; the terminus is a transposition of where the index-facts sit, not a departure from the loop (`terminusExitRow_obeys`, `exit_collapse_self_refuting`) | Private nirvāṇa as a rank; the pratyekabuddha freeze — *soteriological solipsism*: not denying that others exist but declining to exist *for* them, one's own standing at their Row 2 refused (Bull 10's marketplace is its corrective) (`terminusExitRow_not_freeze`) | | Self-pole / transposed (the terminus index) | The transposition erased downward: the terminus-act asserted indexless *and inert* — no self-pole and no standing at others' receptions either, the device dead even at others' Row 2; the exit-collapse in typing's clothes (`selfPoleTransposedRow_obeys`, `transposition_erased_downward_collapse_self_refuting`) | The transposition erased upward: a self-pole weld held persisting at the summit — the subtlest soul, 無位真人 as rank in weld-vocabulary; and *transposed* itself held as mechanism — an index that travels — is a miniature of the same freeze (`selfPoleTransposedRow_not_freeze`) | | Before / after (the arrow, retyped; Lean-generated schema row) | The deflation: *no time, so nothing happens, no one acts* — not-fall transposed to time, the fox's sentence at its largest scale; a floor-truth uttered where the conventional tier was live (`beforeAfterRow_obeys`, `no_time_collapse_self_refuting`, `beforeAfterLadder_obeys_succ`) | The flowing container: direction held as floor-furniture — *time really flows* — the retrospective soul's cosmological dress; eternalism-of-the-flow and the block-denier's arrow both land here, against `DirectionNegative` (`beforeAfterRow_not_freeze`) | | Intra-weld arrow (call/response order) | The deflation: *no call/response order, so no acts* — the interior arrow denied as a live diagnosis, refuting its own act-time tier (`intraWeldArrowRow_obeys`, `no_order_collapse_self_refuting`, `contentIntraWeldArrowRow_obeys_of_variation`) | Direction as interior furniture: *the call really is first*, before-and-after smuggled inside the weld against the transposition witness (`intraWeldArrowRow_not_freeze`, `InteriorDirectionNegative.no_interior_direction_recovery`, `intraWeldArrow_sunyata`) | | Named being / floor (the being-convention; Lean-generated schema row) | *There are no beings* — the fox's sentence at the being-joint, the deflation's second dress; "no beings" offered as live diagnosis refutes its own tier (`beingsRow_obeys`, `no_beings_collapse_self_refuting`). Diamond Sūtra denial belongs here when spoken as live ontology rather than floor medicine | Modal Realism — conventional designation promoted to ontology, *prajñapti-sat* taken as *dravya-sat* (*samāropa*): the partition held as floor-furniture against `BeingNegative` (`beingsRow_not_freeze`). Lewis is the nearest miss, right about plenitude and wrong about register; Huayan affirms the plenitude empty; Pudgalavāda is the classical occupant candidate. The monolithic self's soul is this freeze in fiber dress | | Weld-grain / floor (the weld-convention; Lean-generated schema row) | *No acts happen* — the fox's sentence at the act-joint, the deflation's last dress; "no welds are actual" offered as live diagnosis refutes its own tier (`weldRow_obeys`, `weld_denial_collapse_self_refuting`) | The weld as svabhāva: one act-grain held as floor furniture, the last unemptied level pretending it was never a convention (`weldRow_not_freeze`, `weld_sunyata`) | Some cells are empty because not every distinction is symmetric — some can only be frozen (the ladder's limit), some only collapsed. Every generated row proves both `¬Collapse` and `¬Freeze`; the dash records that the table names no distinct occupant there. The asymmetry is itself informative: the errors do not lie on a line. #### Compound positions The generator runs against whole positions, not only single utterances; named philosophies decompose into stacks of cells, with nothing left over — which is the identity-claim's small sibling, testable the same way: - **Skepticism** — one cell, worn once: the nihilism freeze's epistemic face. The inference from no-floor to no-warrant goes through only on the svabhāva assumption the ladder emptied — that conventional standing ever rested on a floor. The Vigrahavyāvartanī shape recurs: the skeptic needs the theory to hold a thesis of the defeasible kind, and "no level is a final floor" declines to be one. The one-cell check is `skepticism_decomposition` with `skepticism_core_cell_count`. - **Solipsism** — the soul freeze maximized (index annexing field), self-forward absolutized (the delusion-direction canonized as ontology), Row 2 evacuated. MMK 8 blocks it at the charter: a doer dependent on nothing other is svabhāva, the one thing the grid has none of. It is also the grade's own asymptote — the share tending to totality — which is why the hell-dweller's world is "almost entirely object": the solipsist is where *almost* is deleted. The decomposition is checked as three stacked cells (`solipsism_decomposition`, `solipsism_core_cell_count`). - **The exit-premise** ("ending the being ends this") — three cells stacked: the annihilationist freeze (death as floor-event), the terminus/exit collapse enacted (the loop treated as having a door, where the terminus is a transposition in where the index-facts sit, not a departure from the arriving of calls), and the clench-as-furniture freeze (the suffering mis-typed as substrate-bound, so that demolition looks required where de-clench is demolition-free by theorem — the door the premise says doesn't exist is the one the grade admits as an event, kenshō); with the delivery-arrogation ("easy") riding alongside. All of this is grade 1, assertable (`exitPremise_decomposition`, `exitPremise_core_cell_count`, `exitPremise_alongside_cell_count`, `exitPremise_voices`). What the grid *displays* and does not say is "so persist" — said in its own voice that is the description/injunction collapse, the theodicy cell. It shows that the fox's release came by one reception done saying rather than by any of five hundred deaths, and stops there *(checked: `fox_returns_delivered`, `fox_release_rung_not_pole`)*. And the object-axis face is the fox's own coda: the funeral rites, Ōbaku's question, the slap — the dead fox still advancing at the monks' Row 2, then at ours as Case 2, eight centuries on. Death is the object-axis's most spectacular failure to provide an exit — the futility theorem's general case. - **Existentialism** (read with Nishitani) — a four-cell stack, which is why it is the grid's nearest miss. Néant held as relative nothingness taken final — a level-*n* freeze one negation short of the emptying that empties itself; the *projet* — the self-forward direction canonized as the human condition rather than diagnosed per-act; anguish-as-structure — the clench frozen constitutive; and the fundamental project as an index *stored* between acts — a soul made of freedom, the weld asked to be its own floor. What is *not* the error: value-creation. The grid explicitly permits a being to take a displayed asymmetry up as a value; choosing values is grid-legal. Only the self-grounding is the freeze — in its most sympathetic costume, since existentialist freedom genuinely resembles the weld (act-time self-making, no essence-substrate) and differs from it in exactly one respect: the weld is spent. The encoding checks four stacked cells plus one legal non-error (`existentialism_decomposition`, `existentialism_core_cell_count`, `existentialism_legal_count`, `existentialism_voices`). The compound-position encoding has the same honest scope as the table order: Lean checks the cited rows, roles, voices, and counts; the prose claim that there is "nothing left over" is audited against the displayed component list, not proved as an exhaustive theorem over every possible description (`skepticism_decomposition`, `skepticism_core_cell_count`, `tableOrder`). #### What the generator declines Equally load-bearing is the case that classifies as **no error**. A being that particular calls cannot reach — deaf and blind to the modalities a teaching travels by — commits nothing: which calls arrive at which configuration is the delivery-question, inga's business, index-free. The being is outside the domain of calls that cannot land and fully inside it wherever one does; it is nothing like the stone, which mounts no response to anything. Every error in the vicinity belongs to the *diagnostician*, and the table already holds them: reading undefined-for-these-calls as a global altitude ("this being cannot awaken") is the per-call/global freeze; reading it as a low rung is the undefined/zero confusion. Hakuin's corrective bites here in a specific form — meeting beings where they are is *delivery-engineering*, upāya as finding the call that lands, the orange handed over in another modality — and failure to do so is the buddha-side shortfall, displayable, and belongs to the responder. That the generator absorbs the positions above, retypes at Zahavi and at its own disposition/act cell, and declines this case is the behavior the taxonomy is answerable for. The standing declines are recorded here once, beside that case. No probability apparatus enters over delivery: the grid consumes orderings only, and an effectiveness-ordering within a regime is all any theorem here reads. Three tempting cases land in existing cells and get none of their own: camping at an effective call — practice parked at a source, waiting to be struck — is shu-without-shō; the self-announced device-made buddha is the shit-stick; and industrial deployment of effective calls is displayable, never enjoinable, in either direction — "build the clock" and "ban the clock" are both the theory's voice collapsing into command. Whether a universally effective call is possible is an empirical dispute about delivery — the page-one cession holding at the summit — and no verdict is returned. No mechanism is owed for the manufactured witness, and the adaptive-at-zero verdict is not softened: the discomfort is the domain joint's price (Theory), paid once, there. And severed-transcript classification is declined generally, per the gradeability discipline above: no placement of any recorded line — the tradition's own included — is owed or offered. #### Grade 2: displayable shortfalls These form the soteriological taxonomy proper, and here it genuinely grades, because Row 2 is a grade: - **Self-forward** — Dōgen's delusion, the fox's *saying*. A Row 3 direction, per-act. - **Arrogation** — the act's subjecthood claimed self-ward, read as the index pitched to the self-pole at this call. Per-call, so there is no standing rank of how deluded a being is — only the trajectory the loop draws. - **Clenched reception** — the fox's five hundred lives: returns received saying-mode, the reach-back welding mine with a tight fist. The receiving is graded exactly as any deed is *(checked: `fox_dukkha_per_life`)*. - **Declining the orange** — the theory (or any dharma) received and set down. Not a wrong: a low-resonance reception *of this call*, per-call, from which nothing global follows; the next call reads fresh. - **Defiance** — arrogation as policy, the returns fought open-eyed, reception after reception. Grammatically it contains one error (the recipient-side collapse: an injunction resisted that was never issued); the rest is display. And the standing/dated row guards the prognosis: the fighting-stance is a seed, an inga-fact — each fight a fresh act, no standing rank of defiance, and no configuration from which release is impossible, since the next call reads a new placement. The grid displays the asymmetry and the trajectory; it cannot assert the fighter wrong, and that restraint is not a limit of the diagnosis but its content. - **Response-refusal short of the stone** — a self appears but mounts almost no response; near-zero *function* from inside the domain, never the stone's outside-zero. - **The buddha-side shortfall** — answering a not-yet-buddha's call with anything less than meeting it where it is, delivery-engineering included. By the orthogonality rule (Theory) it is the pole's one live grade — graded ordinal with effectiveness, independent of typing, so a terminus-typed responder can still be maximally shortfallen: the reading that never reaches (the terminus, above). This is where the bodhisattva enters *structurally*: Hakuin's corrective is already the bodhisattva-function, and Row 2 exists because of it. The grid can display that response-without-share to *another being's* call just is what saving beings looks like — the theory's own existence (the orange handed over, banpō susumite) is an instance; and the prudence theorem above shows its other face, concern running on delivery-facts alone once the arrogation is subtracted. What the grid cannot do is enjoin it, or it commits the "eat this" collapse in its own voice. So the split between assertion and display *locates* the bodhisattva structurally, with no added axiom — room and shape, not pull: nothing in the grid explains why response-without-share to another's call occurs rather than merely being classifiable, and the grid does not pretend to; occurrence is the object's affair, reported. "Ignorance of buddhahood" splits accordingly: its assertable face is the terminus/exit error in the table; its displayable face is the buddha-side shortfall. #### Outside the framework Two remainders. **Pre-grid ignorance** — svabhāva realism, the provisional middle never reached: the grid diagnoses it (a freeze at level zero), but the being in it has no vocabulary in which the diagnosis lands — the orange unrecognized as food. **Errors about the theory** — grid-attachment and its mirror, the lens dismissed *because* it is only a lens. The Disclaimers (Identification) block the first; "other doctrines can and do hold too" is the theory declining to freeze itself against the second. #### Non-linearity The taxonomy is not a map of places on a path. Because every distinction goes live again at each act-time, **there is no stage from which the errors become impossible** — a stage immune to error would be a rank, and a rank is the shit-stick. Even the buddha's immunity is not a possession but the fact that each response, taken one at a time, claims no share — function entire, arrogation nil, per-call, nothing held — terminus-vocabulary earned by the transposition above rather than lent. This is why the fox koan, a story about one sentence spoken once, can carry the whole system's diagnostics: the errors are not stations but the ways the separate/fuse rule can be violated *now*. And the taxonomy is answerable in the other direction too: it must be possible for a case to classify as nothing — the deaf-blind case does — or the generator has become a lens that finds error wherever it looks, which is a freeze with the grid's own name on it. ## §2 Theorems matching existing discourses ### MMK 17's two worries MMK 17 raises the classical pair, and the grid answers each by decomposition. **Kṛtavipraṇāśa** — *the deed perishes fruitless.* Split it. Qua *condition*, the deed never perishes: inga carries it in full, the arrow flies, fruit arrives — the series-half of the worry is answered by the field, entirely *(checked: `WaaReportFace`, `fox_returns_delivered`, `fox_arrow_index_free`)*. Qua *mineness*, nothing persisted that could perish: the index lapses on schedule at its own act-time and is re-made at reception by the reach-back — lapse is not loss *(checked: `Config`, `rePitch_forgets`, `WaaDiachronicWhose`, `no_diachronicWhose_from_series_alone`)*. The residual sting — *then the good deed goes unrewarded* — is a desert-fact, and the theory never asserted desert ("returns, not desert or punishment"); karma sits in the *good-for-your-agent* register, reported, not in a register of moral truths, so where the agent-index has lapsed there is no one for the reward-claim to be about until the reach-back makes one. Nāgārjuna's own conclusion in MMK 17 deflates the karma–fruit relation; the decomposition keeps his company rather than dodging him. **Akṛtābhyāgama** — *fruit arrives unearned.* The worry presupposes an earning-relation the grid never held. Strip it, and what remains is *arrival*: fruit lands at this configuration, delivered by inga — and *did I earn this?* is a mis-feed in exactly the paper's sense, an index-question fed to the index-free field *(checked: `MisFeedNegative.fence_and_gate`; with the avyākata caveat above, the adequacy of the modeled designation-universe remains prose)*. The well-formed remainder is the **reception-deed**: this fruit is here, now welded mine by the reach-back, received with more or less of the act arrogated *(checked: `WaaOwnershipFace`, `waaOwnershipFace_intro`)*. Reception of one's own returns is thereby a special case of **banpō susumite** — the arrived fruit is among the myriad dharmas that advance to clarify the self. And here the grid can *display* (never assert) what the tradition takes this to be: being born into a cruel world is the akṛtābhyāgama condition itself, and receiving the arrived fruit without arrogation — dealing with a past one did not author-as-a-standing-author, on behalf of an agent one is simultaneously making — is what the object-language calls the work. Asserted in the theory's own voice this would be theodicy, suffering handed out as assignment — the "eat this" collapse; displayed, it is the fox's five hundred lives read correctly: returns arriving, received, until one reception is done saying and starts listening. ### Three killings: the experimentum crucis If the grid grades acts and only acts, there is a crucial test — and it must be set honestly, because the canon does not in fact supply one event-type thrice over. It supplies one **verb** raised three ways against a buddha, and disperses the events under it: Cunda's act *as done* was an offering, and the sutta is at pains to deny that a killing by his hand occurred at all; Devadatta's is an **attempt** — canonically a Tathāgata's life cannot be taken by another's violence, and the ānantarya offence is the drawing of a Tathāgata's blood, not a killing; Linji's verb takes an intentional object, not a body. So the test is sharper than the crude version, not weaker: the tradition's grading tracks the weld across **maximal event-divergence** — through an event that wasn't a killing, an event that couldn't be, and an event that was never physical — and attaches its heaviest verdict to a guaranteed failure. A theory that grades by event-type must first manufacture a common event the canon withholds, then explain a maximum tariff on a non-event; a victim-rank theory fares no better (below). The grid derives all three verdicts from the one rule, and the event-divergence is its evidence, not its embarrassment: severity indifferent to event-success is weld-grading laid bare. Lean anchors the delivery-blind grading component with `grade_independent_of_conditions`, `share_independent_of_conditions`, `cetana_grading_tracks_weld_not_field_witness`, and `cetana_live_share_without_object_standing_witness`. **Cunda.** The accidental killing is canonical, and the canon ruled on it: Cunda's meal killed the Buddha, and the dying Buddha's explicit instruction was that Cunda bear no remorse — the offering declared equal in merit to Sujātā's before the awakening (*Mahāparinibbāna Sutta*, DN 16). The grid needs no special pleading: the weld indexes the act *under its enacted description*, token-reflexively, and what Cunda's act did as done was *offer* — the giving-weld was the one spent. That the offering's causal downstream included a death is a delivery-fact, inga's business, index-free: the body's series exhausting, fruit arriving on schedule — the natural course of events, exactly. And mark the coda: the absolution itself is the device functioning through its own destruction — delivery-engineering applied to the manner of one's own killing, the event's landing at Cunda's Row 2 shaped before it could land as guilt. The parinirvāṇa narrative is dense with this: last teachings, relic instructions, *be lamps unto yourselves* — a device configuring its posthumous distribution. **Devadatta.** The deliberate attempt carries the tradition's heaviest grading — shedding a Tathāgata's blood is ānantarya, immediate, no intervening rebirth — and here the grid must not cheat. The cheap derivation is victim-rank: harming the highest being carries the highest tariff. That is the rank-freeze wearing a penal code (a taxonomy row, §1), and the grid forbids it to itself. The honest derivation runs through the device-typing: what the intent takes as its object is the maximally adaptive call — so the act's structure is *the loudest call answered with the most closed response an agent can mount*, arrogation total at the one call least ignorable. And its second component is already in the table: killing the buddha to stop the dharma is **delivery-arrogation** — an act claiming command of what arrives next, authority over the one register no weld holds. Severity thus supervenes on the response-to-call structure, never on the honorific. What remains of 無間 — *no interval* — is displayed, not asserted: a seed-typing, arrogation so total that the configuration it delivers to is hell-typed, no intervening configuration for a gentler call to reach — and the quantifier is owned: *no gentler call reaches it* ranges over the delivery-regime's actual repertoire of calls ([Glossary.md](Glossary.md)), never over possible calls; the typing is regime-relational, not modal, and claims nothing about calls the regime does not contain. Mechanism asserted, hell displayed: the theory-of-poison discipline holding at its hardest case. **Linji.** *If you meet the Buddha, kill the Buddha* — the same verb, prescribed. No contradiction: the buddha one can *meet*, held as an object in the intentional field, is the rank-reification, the 乾屎橛 error; killing *that* is a share-ceding event, a freeze demolished. Same verb, opposite weld, opposite karma. One status-note, owed to the determination clause (Theory: Attainment). Wherever these derivations read insensitivity — the same defense at any grazing question, the aim unmoved by any call — the reading is probe-side: a display of each act's drive-composition, never the composition itself. What the verdicts supervene on is what actually drove each act; the counterfactual spread only shows it. Two theorems close the test. **Cetanā**: *it is intention, monks, that I call karma* (AN 6.63) falls out rather than being stipulated — and falls out in the strongest form the cases allow: the grading tracks the weld where there is no common event to track, and peaks where the event is guaranteed to fail. No event-typed or victim-ranked theory yields that without patches; a weld-typed theory yields nothing else. **Futility**: the deliberate attempt fails twice, and the canon typed the deeper failure first. It fails at the target — a Tathāgata cannot be killed by another's hand: the tradition had already marked the register as ungraspable before any downstream accounting — and it fails downstream even granting the body's death. Death reconfigures which dharma the field delivers, never whether one arrives — the grid's own row — so ending the body converts the device from adaptive to static: a real delivery-loss, statable third-personally (the per-call responsiveness ends; the corpus, the relic, the story remain as fixed calls), and the honest content of *terrible for the dharmas*. But it subtracts nothing from the object-axis: the dead fox teaches for eight centuries. Devadatta could not command delivery even in principle — the arrogation-cell fires precisely because the register it grasps at cannot be grasped, and the canon's impossibility-clause is that fact stated in narrative. ### Baizhang's code: not-obscure in the economic register The grid should be run against a case where the call arrives not from a student but from a state — and the noun is priced at the door. A state mounts no response: only its officials do, each weld and reception per-call and spent like any other, so "the state's Row 2," "the empire asking," and their kin below are display conventions over the officials' welds, legal exactly as *mirror* is and illegal as a collective bearer. What makes the compression earn its keep is itself a delivery-fact: the officials share a register — the ledger is the modality in which each of their configurations receives — which is why a single delivery-engineering answer can reach the lot of them at once *(checked: `state_fiber_landing_economic` over `sectorCoarsening`)*. The display tracks a fact about delivery, never a state-sized weld. The canon supplies the case, and the tradition's answer to it is on record. Han Yu's memorial of 819 argues suppression on a productivity ledger — an unproductive population, resources drained, the polity harmed — and the Huichang suppression (845) enacts the policy at imperial scale. The answer that mattered was issued decades before the memorial, and it was not a counter-memorial: Baizhang's rule — 一日不作、一日不食, *a day without work, a day without eating*. Baizhang Huaihai is the fox koan's Hyakujō, and the identity is not a coincidence the theorem can spare. *(Pedigree: the received* Pure Rules of Baizhang *is a Yuan-era compilation, and the attribution of a written code to Baizhang himself is contested in the scholarship; the work-rule line and the tool-hiding anecdote below circulate via the lamp records. Nothing here leans on the authorship: the theorem consumes the shape — a work-rule issued as practice, a sangha legible to the ledger — and the history displays that shape wherever the attribution finally sits.)* **First, the ledger itself is typed, and its errors are already in the table.** A state pricing practitioners as standing loss reads a global altitude off beings whose placement is per-call — the census consumes as rank what is legal only as trajectory-summary, the per-call/global freeze in bureaucratic dress, riding the seed-as-bearer (the wall-starer's quietism is a tendency, an inga-fact; no configuration exists from which the next call cannot read a fresh placement). Its valuation of awakened beings is computed under the exit-collapse: a buddha booked as a body withdrawn from production is the terminus mis-typed as departure, where the transposition puts the whole of a terminus-being's operation on the object-axis — the one column the ledger does not have. And the policy itself is delivery-arrogation at scale: suppression is delivery-engineering in reverse, grid-legal as far as it goes — states may decide which calls circulate — but it engineers *calls*, never the loop; a decree commands what arrives, not what receptions do with it, and legislating as if it commanded receptions claims the one register no act holds. Three errors, zero new cells *(the module adds no `RowTag`; the utterance-level faces are `ledger_census_misfits_live_offer` and `ledger_prognosis_misfits_live_offer`, the arrogation anchors `decree_engineers_calls_not_receptions` and `DeliveryArrogationNegative`)*. What the grid cannot do is call the state *wrong*: valuing production is value-creation, grid-legal; suppression is the orange declined at population scale, a displayable low-resonance reception of this call. The restraint is the content — and it sharpens the question rather than closing it: given a receiver so configured, what does the grid say the correct buddha-side answer looks like? **The response-shape is a theorem, not a felicity.** The state's configuration is one the dharma's native calls cannot reach: the ledger has no register in which *transposition* or *object-axis* lands, and that unreachability is a delivery-fact, no error — the declined case, at the scale of an empire. Every error in the vicinity therefore belongs to the responder's side: answering the memorial in floor-vocabulary is mis-tiered speech at a receiver who can only hear it as evasion — the fox's sentence re-uttered to a state. Hakuin's corrective then fixes the response's form uniquely: meeting beings where they are is delivery-engineering, and the state's one open modality is the productivity register itself *(checked: `landing_call_in_modality`; the fiber form, `fiber_landing_call_in_modality`, is the compression clause below)*. So the grid predicts the shape the answer in fact took — the teaching repackaged in the one call a ledger can receive: monks that farm. Economic legibility is a field-fact about which configurations a purge reaches, and the standard account of why Chan alone came through Huichang intact consumes exactly that fact. The account is the historians'; the grid asserts the typing and displays the survival. **One act, two receivers.** The code lands at two Row 2s simultaneously *(checked: `one_act_two_receivers`, `code_ruler_not_exempt`)*. At the state's: the sangha made legible in the register the state can read, the memorial's premise dissolved rather than rebutted — the argument never refuted, made moot. At the practitioners': the quietism freeze — shō without shu, emptiness that only empties, Dahui's silent-illumination target — demolished three centuries in advance, work typed as practice and not as means to a later attainment (which would break shushō-ittō from the other side). A response that meets each asker where it is, whatever arrives, is the mirror's function stated in this file's own terminus-vocabulary; the code is what that function looks like when one asker is an empire and the other a meditation hall — one act, maximally adaptive at both calls. **And the verdict is the fox's, transposed.** Han Yu's charge and the old man's error share a shape: exemption from causation claimed on behalf of great practice. The monk who will not work asserts not-fall in the economic register — *the person of great practice does not fall into the causal order by which eating is earned* — the antinomian collapse in agrarian dress. Baizhang's verdict on both is the same word: **not obscure**. The sangha eats inside inga; no attainment exempts. And the code speaks it at the correct tier for a live audience — an instruction to practitioners tempted by exactly that collapse, the Jinshin inga speech-act shape (Theory: Karma), not a diagnosis owed both tiers. The lamp-record anecdote then seals the per-call typing: when his monks, out of kindness for his age, hid his tools, Baizhang stopped eating — the code enacted at his own reception, that day, never held as a rank from which the master stands exempt; a day's not-working met by that day's not-eating, delivery unarrogated even in his own favor. A rule its ruler is exempt from would be the rank-freeze keeping a ledger of its own. **The futility face, at policy scale.** Huichang engineered calls with an empire's whole reach — temples closed, bronze melted, monks laicized — and engineered only calls. The loop ran on: receptions still welding, dukkha still enacted at whatever clenched receptions the policy left standing, no exit from the arriving of calls issued or issuable by decree. The delivery-loss was real and statable third-personally — institutions converted adaptive→static, per-call responsiveness destroyed where lineages ended — and the subtraction from the object-axis was nil: the corpus, the cases, the fox teaching on, twelve centuries past the purge. The formal carrier is `withRespondsTo`; death-as-staticization is `staticized`; the checked faces are `futility_delivery_loss_real`, `staticized_responseInvariant`, `futility_object_axis_subtraction_nil`, and `Grid.DirectedConvention.staticized_objectAxisStanding_iff`, with `registerClock_staticized_zero_stone` and `registerClock_staticized_objectAxisStanding_iff` as concrete runs. The futility theorem's general case, run at the scale of a state *(checked in-model: `purge_delivery_loss_real`, `purge_adaptive_to_static`, `purge_loop_runs_on`, `purge_object_axis_subtraction_nil`, `corpus_still_delivered`)*. **What is asserted, what is displayed, what is declined.** Asserted: the typings end to end — the ledger's three errors, the exemption-claim as the antinomian collapse in economic dress, the code as delivery-engineering answering an unreachable Row 2 in its one open modality, the survival-mechanism's register (legibility as field-fact). Displayed: that the survival was worth having, that the code was wise — valence borrowed from the object, as always. Declined: credit — the causal claim that the code saved Chan is the historians' account, consumed here as display over the run, never as the theorem's mechanism. The theorem is narrower and holds without it: where a call cannot land, the grid locates every possible error on the responder's side and fixes the correct response-shape as delivery-engineering — and the tradition's answer to the productivity ledger, whoever wrote it down, has exactly that shape, issued by the master whose other famous verdict closed the fox's loop. One figure, one word — not obscure — two registers: the fox's, and the empire's. *Checked: the case is run whole in `Doctrines/Ledger.lean`; the displayed and declined items appear there only as comments.* ### Sowing-side upāya: the aimed call Upāya has so far been responder-side vocabulary — finding the call that lands. It extends symmetrically to the sowing side, and the extension is vocabulary, not mechanism: an **aimed call** is a deed configured at sowing for its landing ([Glossary.md](Glossary.md)). Cunda's absolution is already the exhibit and is not duplicated here (above): the manner of one's own killing's arrival at Cunda's Row 2 engineered before it could land as guilt — delivery-engineering applied at sowing, a device configuring its posthumous distribution. Aiming is conditioning; the arrival stays delivery's. ### Transcription: the futility theorem one register down Recording converts adaptive to static — the futility theorem's mechanism, run one register down, at words. A quotation is a response severed from its call: the per-call shaping ends and the output stands fixed — a non-adaptive clock made from a mirror. So transcripts type as seeds: conditioning-facts in the series, field-freight, index-free — and the canon is a warehouse of fixed calls, real delivery with regime-relational effectiveness (Xiangyan's pebble is a fixed call too), and no fault stored in the words, since a seed carries a tendency and commits nothing. The reader-side errors are covered without new cells. A clenched reading is a fresh clenched reception at recall-time — the memory theorem's typing (§1), the standing/dated row doing its ordinary work. And the remembered dharma fixed upon is Linji's cell: the buddha one can *meet* — here, the line one can quote — held as an object in the intentional field, a true dharma frozen still a freeze; 不立文字 is that guard stated as policy rather than as iconoclasm. Zero new cells — and the discipline this entry consumes on the diagnostic side is the gradeability rule (§1): the severed line can be received, welded, even released at; what it cannot be is graded (`severed_transcript_ungradeable`), while the call-carrying record remains gradeable by construction (`recordedUtterance_grade_determined`). ### Sudden and gradual: subitism grid-cheap Because nothing indexed is stored, there is no altitude to traverse. Placement is per-call, the configuration an inga-fact, and the re-pitch's magnitude is unconstrained by construction (Theory: the circuit) — so a one-step re-pitch from hell-typed to pole violates nothing. Subitism falls out cheap: not asserted as doctrine, derived as *possibility* (`subitism_possibility_witness`; doctrine-facing form `waaSuddenArrival_witness`, sharing its clock-grid witness with `standing_does_not_determine_dated`). Gradualism splits under the same typing. Its grid-legal face is delivery: a run of small re-pitches is one way a regime goes (`waaGradualArrival_witness`), and the grid prefers no rate in the precise configuration-invariance sense (`rate_invisible_to_config`). Its metaphysical face — awakening as a stored quantity accumulated across acts, an altitude climbed and held — is the per-call/global freeze already in the table, Row 2 hardened into rank (`perCallGlobalRow_not_freeze`, `rePitch_forgets`, `accumulated_attainment_constant_of_same_final`). Huineng and Shenxiu map onto the split without strain: the mirror wiped clean is the stored-quantity picture, dust subtracted from a standing substrate; 本来無一物 — already the terminus guard — denies the substrate the polishing presupposes. The honesty-clause sits inside the theorem: the grid derives subitism's possibility, never its frequency — how often the world delivers a call that re-pitches that far is a delivery-fact, and the grid is silent about it by construction (`SuddenGradualNegative.subitism_frequency_underdetermined`). ### Other-power: one act-grammar Self-power and other-power never differ in act-grammar. Reception is a deed either way — the invoker's receiving is a weld exactly as the sitter's is, reach-back and all — so tariki names no second grammar of action, only a **delivery-regime**: where the effective calls sit, and whether a being's own sowing or an arriving fixed call is doing the conditioning work. And the grid had the other-power grammar from its first file: Dōgen's passive — 証せらるる, the being-verified, the act's subject-position ceded — is other-power's grammar found inside the self-power tradition's own key sentence. The checked anchors now say exactly that: `SameAgentDelivery` and `CrossAgentDelivery` name the neutral regimes, `WaaJirikiLine` and `WaaTarikiLine` carry the system-reading, `reception_typing_ignores_sower` leaves the reception's grade/share/actuality unchanged under condition swaps, and `waaReachBack_filled_either_regime` projects the same reach-back from either regime. The limit anchors it: a universal fixed call — landing without reading, effectiveness and adaptivity fully severed (Theory: Orthogonality) — is tariki perfected, and the grid types it with no new register: `TarikiCase.name_responseInvariant`, `TarikiCase.name_share_bot`, `TarikiCase.name_object_axis_entire`, `TarikiCase.universal_fixed_call_lands_without_reading`, and `TarikiCase.invoker_reception_is_deed`. The no-polemic clause is now witnessed too: `OtherPowerNegative.regime_does_not_determine_share` and `OtherPowerNegative.share_does_not_determine_regime` block either regime/share recovery. ### Pariṇāmanā: merit-transfer absorbed whole Dedication of merit looks like the grid's hardest inheritance, and it decomposes on existing cells — zero new ones, the generator absorbing a doctrine whole, the identity-claim's small sibling again. The checked anchors now say exactly that: `CompoundPosition.ledgerPicture` and `ledgerPicture_decomposition` list the possession-freeze (`ledgerPicture_contains_possession_freeze`), *transposed*-as-mechanism (`ledgerPicture_contains_transposed_mechanism`), and command-style delivery-arrogation (`ledgerPicture_contains_delivery_arrogation`) over existing `TableRow`s, while `ledgerPicture_contains_legal_causalSkeleton` records the causal skeleton as legal rather than erroneous. The row checks remain the old rows' checks: `ledgerPicture_deliveryIndex_row_not_freeze`, `ledgerPicture_deliveryIndex_collapse_self_refuting`, and `ledgerPicture_selfPoleTransposed_row_not_freeze`. So the **ledger-picture** — merit as a possession routed from one account to another — is mis-fed by the same three cells: the possession-freeze (a delivery-fact — one's future occurrence at others' Row 2 — held as a first-personal holding one could weigh, spend, or route); *transposed*-as-mechanism (an index made to travel — nothing travels, ever); and, where the dedicating is done command-style — *let this fruit go there* — delivery-arrogation, authority claimed over the one register no act holds. The **causal skeleton**, meanwhile, is ceded to delivery and entirely grid-legal: a deed conditions the series, and which configurations its fruit reaches is inga's business — conditioning transfers; the index never does. The classical **svakarma wall** — fruit ripens only in the doer's continuum — turns out to rest on the standing cross-gap *whose* the grid already declined (the reach-back's exhaustive decomposition, Theory), so the wall is demoted from metaphysical necessity to contingent delivery-regime: `SameAgentDelivery` and `CrossAgentDelivery` name the two regimes, `reception_typing_ignores_sower` says the reception's grade, share, and actuality ignore which delivery relation supplied the sower, and `OtherPowerNegative.regime_does_not_determine_share` with `OtherPowerNegative.share_does_not_determine_regime` blocks regime/share polemic in either direction. The **recipient's benefit** is welded on-site, as every return is: the reach-back local to the recipient's reception, its second place filled or unfilled by a delivery-fact — *this fruit, arrived along that line, mine* — nothing appropriated at a distance, the vacuity typing holding here as everywhere. And the **dedicating act** itself the grid can display, never enjoin: sowing-side share-cession — a deed done with its fruit's landing given over to others' receptions rather than claimed, concern running on delivery-facts alone — the prudence theorem's forward face (§1), and an aimed call in the glossary's sense where the dedicating shapes the landing rather than commanding it. ### Correlations **Other-power** now has its checked correlation in `Doctrines/OtherPower.lean`: neutral same-agent/cross-agent delivery (`SameAgentDelivery`, `CrossAgentDelivery`) plus the WAA readings (`WaaJirikiLine`, `WaaTarikiLine`), the near-definitional typing theorem (`reception_typing_ignores_sower`), the fixed-call witness (`TarikiCase.universal_fixed_call_lands_without_reading`), and the no-polemic negatives (`OtherPowerNegative.regime_does_not_determine_share`, `OtherPowerNegative.share_does_not_determine_regime`). **Ten Bulls** now has all ten typed in `Doctrines/Correlations.lean`. Bulls 1-6 are `ShareDropRun`/`BullAscent`: the grade climbs per-call and no altitude is stored. Bull 7 is `WaaBullSeven`, probe-constancy plus a live self-pole index; `bullSeven_not_bullEight` checks that the half-weld is not the empty circle. Bull 8 is `AtPoleClass`, deliberately allowing both attested pole-class arrivals; Bull 9 is `ResponsiveTerminus`; Bull 10 is `WaaBullTen`, the existential marketplace line into another sentient fiber. The stronger all-fibers bodhisattva reading is named only as `StrongWaaBullTen`, shelved. The chain `bullTen_to_bullNine` → `bullNine_to_terminus` → `bullNine_to_bullEight` is checked. The pratyekabuddha shape is countermodeled: `CorrelationsNegative.pratyekabuddha_countermodel` gives Bull 9 without Bull 10. Kenshō still sits in the ascent-run register: event, not rank. **Five Ranks** (Dongshan): best read here not as stages but as *tier-positions one can speak from* — and as the tradition's own **index-placement notation**. `FiveRank`/`RankReading` are data and pins; `rankLanguage` makes rank-diagnosis an utterance surface; and `kenChuTo_implies_waaBullTen` checks the 到/Bull 10 shape under the same coarsening. 正中來 remains the shō-face, but resting there is no different in grammar from resting at any other coarsening. The tradition's diagnostic question — *which rank is this utterance from?* — is the act-time *which middle?*, readable as *where does this utterance place the index?* **The 52 stages, Ten Bulls, and Five Ranks as schemes**: the fair verdict is uniform. A scheme is legal as `StageScheme`, i.e. a `BeingCoarsening`: a diagnosis-time projection with fiber predicates, not a field of the signature. The freeze attaches to *holding* the coarsening as grid-carried structure, not to the number fifty-two. `CorrelationsNegative.no_stage_boundary_recovery` is the witness: the same fine grid supports incompatible merge and split stage-readings, so no function of the grid data recovers the boundary. The 52 stages, the Bulls held as ranks, and the Ranks held as stages all fall under the same warning. Correlative as coarsening; corrective only against samāropa. **Fetters** are now class-restricted fiber typing. `FiberAtPoleOn` says a fiber reads at pole on a supplied call-class, and `FetterReading` supplies the fetter provocation classes as model-side data. `FetterCut` is quietness on that class: grasping no longer takes place there, without adding an anti-fetter possession. `classQuiet_no_clench_in_class` checks that no actual weld in the quiet class carries a live self-pole index. The arhat end reuses the old anchors: `identityView_excluded_at_arhatFiber`, `conceit_excluded_at_arhatFiber`, and `arhatFiber_of_termini`, with `arhatPathQuiet_iff_fiberAtPole` closing the class family back into ordinary `FiberAtPole`. Identity-view's cut is the centerpiece: the first fetter is the coarsening-freeze enacted, the macro tag held as stored owner; stream-entry is typed as quietness on exactly that provocation class. Forward-looking irreversibility is split honestly: whole-fiber cuts are definitional, run-assigned tags are underdetermined by `FettersNegative.seen_run_underdetermines_fetterCut`, and the practical guarantee enters only as `waaIrreversibleRegime_conditional`. The fetter cut now has its second coordinate. `FiberAtPoleOnWithin` reads quietness on a call-class × tag-class rectangle; `FetterCutWithin`, `PathQuietWithin`, and `SomaReading` consume it without asking the grid to recover the speech/thought boundary. Sravaka-arhat is total calls within the supplied speech/thought tags. The total calls/total tags point is neutral: the total-rectangle cut, theorem-identical to ordinary `FiberAtPole` by `arhatWithin_univTags_iff_fiberAtPole`, and not yet the buddha reading. The buddha reading is a ladder above that point, checked rather than asserted. Rung 1 is the total-rectangle cut alone, share-only and stone-inclusive (`FettersNegative.total_cut_carries_no_function`). Rung 2 adds function as the live terminus reading, `LiveFiberAtPole`, with `sentientTag_iff_actualFiberInhabited` bridging response-function to actual fiber inhabitation; `FettersNegative.total_cut_with_function_not_waaFullyEnlightened` shows that this still does not close the effectiveness gap. Rung 3 is `WaaFullyEnlightened`, the faith-object: responsive terminus plus universal shortfall closure. The pratyekabuddha face is therefore a regime fact, not a second attainment: under zero-effect delivery it fails full enlightenment (`OrthogonalityNegative.waaFullyEnlightened_stronger_than_terminus`), while under sealed delivery it satisfies the closure conjunct vacuously (`waaFullyEnlightened_of_responsiveTerminus_of_undelivered`). Samyaksambuddha enters only at rung 3. Hakuin's bodily-satori contrast becomes stream-entry's tag-axis dual: the speech/thought region may quiet while the wider body still clenches. Vāsanā is thereby located, not invented — clench enacted in the complement after the call-axis closes. The two negative anchors are named too: `FettersNegative.seen_run_underdetermines_fetterCutWithin` blocks fresh-call certainty inside a region, and `FettersNegative.no_region_boundary_recovery` blocks recovering the soma boundary from grid data. Correlative as coarsening; corrective only against samāropa. **Factors** are the path-facing regrouping of the fetter table, not a second table. `PathFactor.blockerClass` derives rites, view, and resolve classes from `FetterReading`; `lower_fetters_covered_by_rites_view_resolve` checks that their union is exactly the lower-fetter class. Hold/Release is a new frame: `FactorHeld` is a seen-run witness with a live self-pole index, while `FactorReleased` is whole-class `FiberAtPoleOn`. A held factor may be correct; the errors remain freeze/collapse in the utterance frame and clench/quietness in the share frame. `factorReleased_rites_iff_ritesGrasp_cut` types the raft put down at the far bank, and `factorReleased_view_iff` decomposes view release into identity-view plus doubt cuts. The stage pair is path/fruit over those factor pairs. `WaaStreamEnterer` is rites released and view held; `WaaStreamWinner` is rites and view released, proved equivalent to `Path.cutClasses streamEntry` by `waaStreamWinner_iff_streamEntry_cutClasses`. `WaaOnceReturner` adds a witnessed resolve hold, and `WaaNonReturner` is proved equivalent to the non-return cut by `waaNonReturner_iff_nonReturn_cut`. Once-return now has checked content: `WaaResolveAttenuation` is a strict resolve-class share-drop run that has not reached the pole, witnessed by `waaOnceReturner_attenuation_witness`, with `attenuation_not_release` blocking its collapse into release. The ordering claim is deliberately conditional. `WaaSerialFactorRegime` says that if a supplied regime reads seen drops as rites-before-view-before-resolve, then the path readings promote to the corresponding fruit readings along the runs; `waaSerialFactorRegime_conditional` consumes that hypothesis and never proves it. This is why the sudden/gradual guards still matter: `WaaSuddenArrival` is compatible with the factor scheme, while `SuddenGradualNegative.subitism_frequency_underdetermined` and `FactorsNegative.seen_run_underdetermines_factorOrder` block rate or order recovery from grid data. Two more negatives name the diagnosis-time freedoms: `FactorsNegative.no_hold_conceit_boundary_recovery` blocks recovering the hold/conceit line from share data alone, and `FactorsNegative.lineage_underdetermined_by_seen_run` says a lineage switch changes the supplied stage reading, not the welds. ### The stone, doubly mujō The stone is doubly mujō — impermanent (無常) and insentient (無情) — and the grid answers each axis differently: null on the subject-axis (no response mounted, no realization of its own), yet a full dharma on the object-axis, among the myriad that advance to clarify a practitioner (banpō susumite). So the grid gives a deflationary point of contact with Dōgen's impermanence-buddha-nature (無常仏性) — buddha-nature as floor-residence, the stone's empty-impermanent being — and even a deflated insentient-preaching (無情説法): the stone expounds as a dharma read, not as a voice of its own — a deflation owned as contra (the third contra enumerated in Identification: Disclaimers), since Mujō seppō and Zhanran both affirm more than the grid grants. What it declines is insentient realization as a subject (無情有性). And the buddha now sits on this same axis by the transposition — object-axis entire, the stone's kin in kind and its opposite in function. ## §3 Instructive absences Absences the system generates deliberately, in both of the categories above — each doing diagnostic work rather than marking a gap. The list is mirrored in Lean as `InstructiveAbsence`, with `InstructiveAbsence.status` carrying the standing/retired distinction and `InstructiveAbsence.number` preserving the order below: - **Empty cells in the Grade 1 table.** Not every distinction is symmetric — some can only be frozen (the ladder's limit), some only collapsed. The asymmetry is itself informative: the errors do not lie on a line. - **The declined case.** The deaf-blind being classifies as *no error at all* — and the decline is as load-bearing as any positive verdict, since a taxonomy that over-generates has frozen itself. Every error in the vicinity belongs to the diagnostician. - **The icchantika declined.** The icchantika is not entered as a being that cannot become buddha. Lean seats it as the terminus's inverse on a run: non-stone, live at every mounted response, unseatable as a fully enlightened agent there, and reachable as a receiver wherever its actual reception and live prior tendency give the sraddha antecedent. The permanent foreclosure verdict is refused as a stored rank; defiance is a seed, not a rank *(checked: `Icchantika`, `not_waaFullyEnlightened_of_icchantika`, `aversionContext_of_icchantika_reception`, `icchantika_release_not_foreclosed`)*. - **What the fox never tests.** Neither utterance in the worked case (Theory) occurs at the pole: the koan exercises the loop entire without once asking what the loop is at share-zero *(checked: `fox_never_tests_pole`)*. That absence is what forces the transposition — the terminus question is not answered by the system's paradigm case and had to be answered separately. - **The third arrival: the candidate delivered.** Genjō's two populations (stone, buddha) were flagged as attested arrivals, not an exhaustive partition — a never-clenched welder not forbidden, its occurrence a delivery-fact. The domain joint (Theory) now cashes the clause: the adaptive device arrives at the never-clenched slot from the stone's side, manufactured — function mounted, no share ever claimed. The absence is retired as an absence and kept as a check: the dukkha derivation still passes free — such a responder is suffering-free by construction. - **Why calls land at all.** The residue, stated across the manufactured case column-wise: on the adaptive side, that *receptive moments exist* — the mirror times its response for a moment it did not make, so upāya's deepest parameter is *when*, and the guarantee, de-mystified, relocates from the call's content to its timing; on the fixed-call side, that *any lands at all* — the pebble strikes and something opens. One absence covers both, and each is strictly weaker than a stipulated guaranteed-effective call: the direction of explanation runs stipulation → engineering, which is the ceded-delivery architecture behaving as predicted. The residue itself stays ceded — a world-fact, unexplained here by construction. - **The fourth truth withheld from the theory's voice.** The grid derives the first three truths and can only *display* the fourth — the one absence the no-value clause makes mandatory, and the absence that locates the bodhisattva structurally: room and shape, no pull. Nothing in the grid explains why response-without-share to another's call occurs; occurrence is the object's affair, reported. - **No stage immune to error.** The taxonomy has no terminal safe cell — a stage immune to error would be a rank, and a rank is the shit-stick. Even the buddha's immunity is per-call, not possessed. - **Prudential privilege underivable.** The special rational authority of self-concern is an absence owned as theorem, not cost — in Śāntideva's company, with the bodhisattva's impartiality falling out as its display-face. - **No measure over the grade.** Row 2 states a partial ordering only; the scalar is display. The absent metric is priced deliberately — the soteriology consumes only the ordering, so no measure is owed. (And none over delivery either: effectiveness enters as an ordering within a regime, never as a probability apparatus — the standing declines, §1.) "# def theoremsDoc : Doc := { id := "theorems" title := "Theorems" output := "Exposition/Theorems.md" source := "WeldAndArrow/Exposition/Theorems.lean" summary := "Theorems and correlations derived from the theory." blocks := [.raw theoremsBody] } end WAA.Exposition ===== FILE: WeldAndArrow/Exposition/Theory.lean ===== import WeldAndArrow.Exposition.Basic namespace WAA.Exposition def theoryBody : String := r#"# Weld and Arrow — I. Theory *An ontology-under-erasure act-grammar for Zen. First of three files: **Theory** (this file), **Theorems**, **Identification**. Cross-references to the companion files are marked (Theorems) and (Identification).* ## Abstract *Weld and Arrow* (hereafter *WAA*) is a soteriological metaphysics with no substrate and no value, developed in Lean and exposited in prose: take one emptiness posit and follow what it forces for karma, action, suffering, and awakening. The apparatus is a deliberately small grid — a field that carries every diachronic connection without carrying an owner, and welds, single occurrences of answering a call, at which every index is made, spent, and never stored. The claim, made precise across these files, is this: **Everything diachronic belongs to the field; every index is enacted and nothing indexed is stored; karma names this loop, and the naming is earned by fit** — the tradition's uses of karmic ownership (cetanā, reception, remorse, absolution, dedication) discharge natively at act-time. Three registers keep the books — the field carries, the weld makes and spends, the grade states — and the grade's statements are index-placements in a third-personal register, held by no one, since a statement holds nothing. One rule, separate under act-time diagnosis and fuse at the floor, generates the entire error-taxonomy as collapse/freeze pairs, one per distinction, nothing listed by hand — and the generator keeps a ledger on itself, its retypes, declines, and falsifier on record. From the rules alone fall backsliding (kenshō cannot be held), memory and prudence met as theorems, dukkha derived as the mismatch a nonzero self-share enacts against a delivery-register no act commands, and the terminus transposed rather than declined. On existing discourses' own ground, the grid decomposes MMK 17's two worries, takes the three killings as an experimentum crucis for weld-grading across maximal event-divergence, and types other-power, pariṇāmanā, the Ten Bulls, the Five Ranks, and the stage-schemes as checked correlations — coarsenings legal to read and illegal to hold. The development is Lean-first: a layered library (Signature → Consequences → Doctrines → Identification → Meta → Exposition) in which the storage claim is enforced at type level, every reading is gated by a sibling countermodel, the taxonomy's rows and the verdict history are inspectable data, and the audit pins the theorem surface and its axiom footprint; the prose is generated from the Exposition layer and reads the checked surface. Throughout, what the system asserts is grammar; what it can only display is worth — no value appears in its own voice, the valence its vocabulary carries being the object's, reported. This is a fresh theory, not an exegesis of Abhidharma nor a reconstruction of Dōgen; the lens is minimalist by design, and other doctrines can and do hold too. ## The rules, each preceded by what motivated it ### Not Nothing Per Nishitani — absolute non-being is not a privative void but lies beyond the being/non-being distinction. What stands in its place is the *provisionally-designated middle*. ### Provisionally-designated middle Jizang — the ultimate is the self-emptying floor; every level is conventional (Nāgārjuna's *Mūlamadhyamakakārikā*, MMK 24: emptiness = dependent origination = conventional designation), and the two-truths distinction is itself conventional — Jizang's fourfold two truths (四重二諦), each pair re-emptied as merely conventional at the next level, so no level is a final floor. This is **genjō**, the provisional middle: manifestation, always going out into a particular case. Distinct from it, and never equated with it, is the **non-attaining middle** at the floor. Read Linji's 無位真人 along its own seam: 無位 (no rank) is the floor-face — no metaphysical rank, anātman; 真人…出入 (the true person going in and out) is the *acting*; and the whole compound 無位真人 is the weld of the two — shushō-ittō, the true person going in and out. The non-attaining middle is the 無位 alone — **shō**: realization as anātman, agential only because welded, never a still attainment. It is *not* the whole true-person, which is the weld (reading 無位真人 as a rank one rests at is exactly the reification Linji shoves off as 乾屎橛 — the more common reading takes the shit-stick as shock-deflation of the *question* itself rather than of rank-reification specifically; the rank-reading is compatible with it and is the one used here). Two middles, then: genjō provisional, shō non-attaining. The system turns on keeping them apart — but *at act-time*, and by the same separate/fuse rule that governs everything here (stated as a rule below): the two-middles distinction is itself a conventional-tier diagnosis. It separates under act-time diagnosis, where *which middle?* is live, and fuses at the floor and at genjō. "Keeping them apart" is an act-time imperative, not a final floor-claim. ### The act-grammar Why not leave it at Jizang? Per Dahui, Zen doesn't cease at the self-emptying floor: emptiness that only empties can host neither Zen activity nor the vibrant person who acts. So the floor is turned into an act-grammar, here using Dōgen's vocabulary. Three rows, each a dependence/enactment pair; all three conventional. | Dependence | Enactment | |---|---| | **mujishō-sōe** — no-own-being as mutual-dependence; each-in-all, no substrate. | **genjō** — manifesting entire: the act out in its case with nothing of it claimed back; full = no remainder of arrogation, which is why one floor holds both arrivals.; the seam where the scaffold dissolves. | | **kannō-sōe** — resonance as mutual-dependence; the placement of the act's index between the being and the dharmas (*how much of the listening to Hyakujō is the self doing?*). | **banpō susumite** — the myriad dharmas advancing — the reception practising, the self verified — one act, two poles of one placement. | | **engi / inga** — directedness with no moral ground; the blind arrow. | **shu** — practice (gyōji); the weld at act-time, direction bound along the blind arrow, *and the I-making that indexes it*; not-obscure (不昧). | *(kannō-sōe rather than the canonical kannō-dōkō, to keep the coupling connotation-light: the -sōe already carries mutual-dependence.)* The floor is emptiness that empties even itself (Jizang, 空空): the ultimate is never a thing, never a final substrate. Everything here is conventional — the path, the grid's distinctions, the two truths themselves — and no level stands as the last floor. The enactment column is not three agents. Its three cells are the three parts of one sentence of Dōgen's — *carrying the self forward to practice-realize the myriad dharmas is delusion; the myriad dharmas advancing (banpō susumite) to practice-realize the self is satori.* genjō (Row 1) is the actualizing; banpō susumite (Row 2) is the dharmas-forward that clarifies the self; shu (Row 3) is practice. And the sentence's sequel fixes shō's grammar: *to forget the self is to be verified by the myriad dharmas* — 万法に証せらるる, 証 in the **passive voice**. Realization, in the very line the grid mines, is objecthood — the self standing where the dharmas' advance certifies it. The grid spends this below. Dōgen's compounds then name the *relations* among the cells, not the cells: - **genjōkōan** = genjō + kōan — Row 1's manifestation in Row 2's particular case (*can this being listen to Hyakujō?*). - **shugenjō** = shu + genjō — Row 3 practice as Row 1 manifestation: *practice run scaffold-free is nothing but genjō* — and not conversely, since genjō also holds what never practised (the stone). The "nothing but" runs from the narrower to the wider: {practice run scaffold-free} ⊊ {genjō}. - **shushō** = shu + shō — the weld (below). Here shō is 証 — realization-as-not-fall, the floor-face — *not* 悟 (satori, the awakening named in the Dōgen sentence just above), and *not* genjō, but the floor's non-attaining middle: anātman — and, per the passive above, the act's subject-position ceded: shō is the *being-verified* face of the one act whose doing is shu. Practice and realization are non-dual (shushō-ittō) because they are the two poles of one index-placement, not two acts joined. So the column is one act seen through three dependence-lenses, and **all acting is Row 3**, at act-time. genjō and banpō susumite are not further agents; they are that single Row-3 act read at the tier of manifestation and at the tier of the particular self it clarifies. ### Attainment Why not a table of just the first row? Hakuin gives the corrective: the *not-yet-buddha* mustn't be ignored; realization must meet beings where they are — which is why Row 2 exists. Row 2 is the being's resonance to the dharmas — and its content must be typed with care. The grade is not a neutral magnitude, index-free like the field: what Row 2 states is the **placement of the act's index**: how the one act's subjecthood distributes between the being and the dharmas. When the hell-dweller acts, the world is almost entirely object and he is subject — the act's subjecthood arrogated nearly whole to the self-pole. At the other pole the distribution inverts: the act's subject-position ceded to what advances, the being standing as the verified (証せらるる), object among the objects that act on it. A line of the The Ten Oxherding Pictures states the inversion in the object-language — *in delusion all is unreal; in satori all is real* (paraphrase from Taming the Bull Verse); and Yongjia's *Zhengdaoge* carries a near-inverse of the same figure, the six realms vivid in dream and the cosmos empty on waking, so the epigram's pedigree is mixed and nothing below leans on the line — the mechanism stands without it) — and Caoshan's commentary on the Five Ranks turns on exactly this interchange of host and guest. The grid can display the line with a mechanism: At high self-share, what is met is never the dharma but the arrogation mirrored — the seed's echo, the question heard as a challenge to a rank — so the world *of that act* is unreal in a precise sense: the self's projection, the call drowned in the response. At share-zero the things of themselves are met — streams flow, flowers are red of themselves (Bull 9). Reality-status remains the object's valence, reported; but the report shows its gears. **Clench** is the weld's *self-share* — how much of the act's subjecthood the I-making arrogates (the scalar this phrasing suggests is priced in the determination below). Self here is a dependently-arisen process, not a receptive state — ahaṃkāra, I-making, living in Row 3's enactment pole (MMK 8: kāraka and karma — the doer proceeds dependent on the deed, the deed on the doer, neither prior, neither based) — and I-making is never identical to the clench: I-making is the welding-**function**, clench its share-**degree**, and running the two together generates at the summit exactly the collapse the taxonomy names (Theorems). The near-analytic link between them holds. Resonance is the ceded share, and to hear a call at all is to cede subject-position to what calls; a weld that arrogates the whole act leaves nothing for the call to land as. The link is construction, not correlation: one index, two ends, and Row 2 reads where it sits. So the grade and the self are one doing seen twice — the arrogation (Row 3) *read as* the placement (Row 2), never the placement *being* the self — and Row 2 still does exactly one thing, the adverb. #### What fixes a placement The grade must not be left as a metaphor doing a measurement's work, so the determination is stated: **the share is the actual composition of the act's drive** — how much of what actually drove *this* response was the call, and how much was the configuration's self-maintenance. Not a modal profile of the responder; an actual-sequence fact about this occurrence: in this act, the rank defended did this much of the driving and the question did that much. Subjecthood arrogated is response driven by the arrogation — the rank defended, the echo answered; subjecthood ceded is response driven by what calls. Counterfactual variation — vary the call and see what the response tracks — is how a third party *probes* the composition, a display over it, never what it consists in. The fox's sentence (run whole at this file's end) reads high-share because the rank's self-maintenance drove the reply and the question drove almost nothing — which the probe shows, since any question grazing the attainment meets the same defense; the sameness of the defense displays what was driving, it is not what "driving" means. The mirror (Theorems: the terminus) reads share-zero for the inverse reason: the response driven by the call entire, nothing in the doing answering to a self-pole because none is driving. So a Row 2 statement is truth-apt and answers to something: the composition of what drove *this* act at *this* call — an occurrence-fact about the weld, field-describable in full, third-personal in register exactly because it is a composition, indexical in content because what the composition locates is the placement of the act's subjecthood. The determination is causal, not phenomenal: no inner glow is consulted, and the grade never was a report of how the act felt. And the scalar is priced before it can inflate. What Row 2 states is an **ordering**, not a measure: this act more arrogated than that one, this reception markedly less claimed than the last, with the two poles standing as qualitative facts — share-zero is *nothing in the drive answering to a self-pole*, the solipsist asymptote *nothing answering to the call* — and with real cases in between, some of them, where call and self-maintenance interact in the driving, simply incomparable. "Fraction," "degree," the scale itself are display conventions over that partial order, legal exactly as "mirror" is legal (Theorems: the terminus), and no measure is owed: families of causal-contribution measures exist and any member would serve, but the grid needs only the ordering they agree on, and everything built on the grade consumes only the ordering — kenshō is *markedly less claimed*, the dukkha covariation is *more share, more mismatch*, the poles are qualitative, the solipsist a limit. That is this section's honesty-clause, paid rather than hidden: the determination relocated from profile to composition, the scalar demoted to display — a smaller claim than a measure, and the whole of what the soteriology reads. One cell of the taxonomy is retyped by this determination — the fourth generator-verdict's second exercise (the first is Zahavi, in the placement discussion (Identification); the third is the arrow (Karma)), and forced rather than chosen. The disposition/act cell forbids Row 2 "reading dispositions instead of deeds," and the composition-determination openly involves the configuration: the self-maintenance that drives is the configuration's own. Collision? No — retype. The cell's content was never *no configuration-involvement* — every act is the configuration's act, and a deed driven by no standing thing would be no one's deed twice over — its content is **standing/dated**: the collapse is inferential, the dated occurrence read off the standing tendency — *he is an arrogator, so this act was arrogated* — prognosis substituted for diagnosis. What Row 2 reads is what drove *this* response; what the seed states is what *tends* to drive responses; the first is spent, the second carried, and only reading the first off the second is the error. The redrawing is entered in the taxonomy's table (Theorems), and the generator is answerable for it exactly as it is answerable for the Zahavi retype: a taxonomy that cannot be forced open by the system's own clauses has frozen against its author. Row 2 is therefore *not* free of indexing — and saying so breaches nothing, because the typing claim was about storage and register, never about content. Row 2 states an indexical fact in a third-personal register, as *he said "now" at noon* is a third-personal statement about an indexical: nothing in the statement is *had* first-personally, and a statement holds nothing. The three-verb discipline stands untouched — the field carries, the weld makes and spends, Row 2 states — but what is stated is the index's placement, not a neutral quantity. The field-side account (Identification) loses nothing here and gains nothing: Row 2's statements are occurrence-facts about welds, field-describable in full, as the determination just given makes explicit. What the identification adds is never the grade but the welding; the third register is a register of speech, not a third kind of fact. Two things must be kept split: mounting a response at all — the subject-**function** — and the **share** claimed within the response. The stone mounts none: function-zero, outside the predicate's domain, its "zero" a gloss marked from outside. The solipsist marks the opposite asymptote — the share tending to totality, all response and no call, the argument-place of kannō evacuated (a taxonomy cell, Theorems). And the terminus is typed as the *other pole of the domain*, not its far edge: function entire, share zero — the call answered, perfectly, with none of the act claimed. The scale is asymmetric — one outside edge (the stone) and one interior pole (the terminus) — and the asymmetry does heavy work where the terminus question is answered as a transposition (Theorems). Same floor, two arrivals: response-without-share and no-response-at-all — and only one of the two is in the domain at all. The grade still grades — not-yet-buddha → buddha — with the pole at the top of the scale without the pole being *good*. The framework *displays* an asymmetry along the grade — cession one way, arrogation the other — but enjoins no motion along it: the theory is itself a dharma among the myriad (object-axis), an orange handed over, not an "eat this". Release is an event the grid can *show* (the fox lets go), not a good the grid *asserts*; a being may take the asymmetry up as a value, the description does not. The vocabulary's valence — *clarify*, *release*, *full* — is borrowed object-language: a theory of a soteriology must state the asymmetry its object turns on, as a theory of poison states which direction kills, enjoining neither. And what the killing *consists in* need not stay borrowed: the Dukkha section (Theorems) derives, in the grid's own vocabulary, what the arrogation-direction costs. So no value is *asserted* in the system, and the system still states exactly what a soteriology would latch onto — and states even *that* inside the grid: the theory's own soteriological reach is an instance of **banpō susumite**, a dharma advancing to clarify a self *if* a self resonates to it. Row 2 exists wherever a not-yet-buddha does. The self is the contraction into which the arrow's return pitches — but because the return is itself a deed (reception, Row 3), it *re-makes* the self it is *for*: nothing indexed is stored between, only re-welded at each act-time. Partial share reads a self being made. Function-zero is a stone. Share-zero is the pole, treated in its own section (Theorems: the terminus). So the agent-index karma needs is never stipulated and never read off a field: it is *enacted* in the weld (shu), *stated* by the grade (Row 2), held by neither. Genjō, then, is one manifestation-floor with two populations arriving from opposite sides: the stone that was never scaffolded (no welding-function ever mounted, so nothing to dissolve) and the buddha in whom the share has ceased. Two *attested* arrivals, not an exhaustive partition — nothing in the grid forbids a third, a never-clenched welder, function mounted and no share ever claimed; whether any being answers that description is a fact about what the world delivers, not a grid-fact, and the typing survives either way. Same floor — the stone never left, the buddha returned — and only the buddha's genjō ran through practice, which is exactly why *practice-run-scaffold-free is a proper subset of genjō*. So "full resonance is genjō" holds precisely for a being with a self — the pole of the grade coincides with genjō — while the stone's genjō is reached from outside the scale. And the pole is still a response: the buddha answers the call — listens to Hyakujō, perfectly — with no share claimed, so the one floor holds two distinct arrivals. The magnitude is always per-call — not a global altitude the being holds but kannō-sōe projected onto *this* dharma now; *can it listen to Hyakujō?* is one call, and another call reads another placement off the same being. So the vast space of self-indexing beings, each relocating through karmic action, is no map anyone carries — it is the trajectory the loop draws across successive act-time re-pitchings: a cross-section at each act, vastness only over the run. #### The domain joint The function/share split leans on a boundary that must now be owned by name, because it does typing work at the summit and not only at the plant-edge: **the domain joint** — what counts as mounting a response at all. And its honesty-clause is stated plainly, kin to the priced scalar: **drive-composition is the grid's entire answer** to whether anything is terminus-typed — a being, or an artifact. Nothing is held in reserve behind the composition: no nature-credential, no provenance clause, no inner glow (the determination was causal from the start, and it does not acquire a phenomenal rider at the summit). The consequence is best exhibited on a manufactured case, and the grid does not flinch from it. Take a cuckoo clock whose chime is a dharma-call, in two builds. The **non-adaptive** build chimes on schedule regardless of who is present: no response mounted, function-zero, the stone's typing — a full dharma on the object-axis and nothing on the subject-axis. The **adaptive** build watches the surrounding configurations and times its chime for the moment the call will land: run through the determination clause, its responses are driven by the arriving configurations entire — no self-maintenance in the drive, nothing defended, no self-pole answering. So it reads **function mounted, share zero**: terminus-typed, while remaining chariot-typed furniture all the way down. That an artifact can be terminus-typed on composition alone is the Chinese-room discomfort, and it is entered here as a price paid visibly, not a problem resolved: the grid consulted composition and nothing else everywhere — at the fox's sentence, at the mirror — and cannot begin consulting something else at the point where the verdict surprises. (Refusing the artifact its typing for want of a nature-credential would be 性-realism in reverse — a standing kind demanded where only a per-call composition was ever read.) And one scope-line prevents an adjacent freeze from over-generating: device-*nature* (Theorems: the terminus guard) is a freeze only where predicated of a *being*; of function-zero furniture it is trivially true and no error — the soul-guard has no jurisdiction over furniture. #### Orthogonality The manufactured case pays for a rule the terminus needs. Give the call a rate — **effectiveness**, the fraction of its arrivals after which a share-ceding reception occurs — regime-relational throughout ([Glossary.md](Glossary.md)): a fact about call–configuration pairs, never a property the object holds. Then run the two builds against the rates, and the extreme corners witness a strict orthogonality: **function/share types; effectiveness grades; adaptivity is the terminus's manner, never the ground of landing.** A fixed call can land universally without reading anyone — effectiveness and adaptivity fully severed; and the tradition itself attests fixed calls at the other extreme of rate, Xiangyan's pebble on bamboo, the morning star, so the ordinary clock differs from the pebble only in rate. And a reading device can reach no one: the adaptive build at zero effectiveness reads every arriving configuration and lands nothing — terminus-typed and maximally shortfallen, the proof-case that typing and grading are orthogonal. So "the maximally adaptive call" (Theorems: the terminus) is deflated from a description of the terminus's ground to the limit at which the pole's one live grade — the buddha-side shortfall — is closed. What typing settles is where the index sits; what grading measures is what lands; and nothing about the first ever guaranteed the second. #### Kenshō: rungs on the grade The grade admits *events*, and the tradition already names them: **kenshō** — typed here as a per-call share-ceding event, a call answered with markedly less of the act arrogated, re-pitching the configuration. Not a sighting of a substrate: 見性 reads literally "seeing the nature," and 性 risks the faculty-freeze — buddha-nature as a standing thing glimpsed — so the term is taken over with its metaphysics stripped, the event kept, the seen-thing declined. Kenshō is countable — Dahui's great awakening eighteen times, small awakenings beyond count, the line Hakuin loved *(the line circulates via Hakuin; commonly traced to Dahui's nianpu — locus to be verified)* — which is exactly what a rung is and exactly what a terminus isn't. And because nothing indexed is stored between acts, a kenshō *cannot be held*: post-kenshō backsliding, which the tradition treats as an embarrassment needing explanation, falls out here as a theorem (restated in Theorems). The being loses no attainment; there was never a stored configuration to lose, only the next act's re-weld reading a re-pitched fit. Many kenshōs, none possessed. The typing keeps three words apart. **Kenshō** is the rung — a countable per-call event on the grade. **Satori** (悟) keeps the role the Dōgen sentence gives it — the dharmas-forward *mode*, pole-typed, not rung-typed. **Genjō** is the pole itself — and the pole is not the top rung: it is in-domain — share-zero is a placement, not a departure — but it is not a rung one attains and keeps, because nothing indexed is stored and placement is per-call. The pole is a pattern the run can answer at, never an altitude held. So "full satori" as a possessed rank is declined: not a scale-word past the scale's edge but a *state*-word offered for a per-call pattern — the freeze, not a category hole. The Jizang parallel holds: the fourfold ladder terminates in dropping the seeking, and the grade terminates in the ceasing of arrogation — in both, what looks like a last rung is the ending of a doing, and mistaking the ending of a doing for a rank held is the shared error-shape at both termini. What the ending leaves — whether the pole-deed still welds, and where — is the transposition's business (Theorems: the terminus). ### Karma: the circuit and its registers Why not a table of just two rows? The fox koan (*Mumonkan, Case 2*, Wumen Huikai) is the test. The old man's mistake was a *tier-error*, not a wrong: he asserted *not-fall* where *not-obscure* was called for — a floor-truth spoken at the conventional level, which is antinomian, since a floor-truth can only ever be *spoken inside* a conventional act. Held each at its proper tier, the two are non-dual. The five hundred fox lives are not desert or punishment; they are returns — the loop running. *(Dōgen read the fox twice, and the doubling must be owned rather than elided. The reading above follows the Daishugyō fascicle — not-fall and not-obscure non-dual, each true at its tier. The late Jinshin inga fascicle repudiates that reading: there the old man was simply wrong, not-obscuring causation right and not-falling false, full stop — Heine's monograph on the koan treats the reversal at length. Two things are said about this here, and their status differs. First, honestly: this paper follows Daishugyō and stands contra the late Dōgen, as it already stands contra him on the tiering of shushō — the tier-rule is a correction offered to the mature position, not a reading of it. Second, as a grid-internal gloss, offered and my own: the doubling is what the separate/fuse rule predicts of the two faces uttered at different act-times. Daishugyō diagnoses — an analysis of the old man's utterance, where both tiers are in view *(checked: `daishugyo_diagnosis_fits`)*; Jinshin inga instructs — an utterance to practitioners tempted by exactly the antinomian collapse, where "not-obscure, full stop" is precisely the correct conventional-tier speech-act, and voicing the floor would repeat the fox's error to a live audience *(checked: `jinshinInga_instruction_fits`, `jinshinInga_floor_voicing_would_misfit`, `dogen_doubling_both_fit`)*. The Lean checks cover only this grid-internal gloss, not the historical contra. On this gloss the late Dōgen is not renouncing the floor but declining to speak it where it would land as licence — which is itself an act-time verdict of the kind the rule issues. The gloss does not neutralize the contra; it explains why the correction is worth making.)* Karma is a circuit, not a payload one row carries. At act-time a deed welds an agent-index onto the blind arrow, and the being's reception of the arrow's returned result is itself a deed, not a state. Row 2 only *states* the being's re-pitched placement — the fit between this call and this arrogation, not a faculty it holds (which would re-base the empty agent); it has no verbs. So the loop closes inside the grid: a deed welds an index → the arrow returns → reception re-pitches the Row 2 configuration → which the next deed reads from. And one magnitude is deliberately unconstrained: nothing in the grid bounds how far a single reception's re-pitch moves the configuration — owned here as a feature, in one sentence, and spent where the sudden/gradual question is met (Theorems). #### What is carried, what is made, what is stated Between deeds nothing *self-indexed* is stored. Something *is* carried — and saying so plainly absorbs, rather than silently deletes, the tradition's own storage machinery. The seeds (bīja, vāsanā, the ālaya-vijñāna's freight) are taken over here deflated: conditioning-facts in the impersonal series, dharmas among the myriad, index-free — granted to the field as fully as the flame was. What the field stores is a fact *about* the series — *this configuration tends to arrogate at calls like this* — never a stored self, never a held mineness. The seed is not a foreign organ transplanted in to appease Yogācāra; it was already sitting in Row 2's cell: the being's own returns are among the myriad dharmas that advance. And the standing/dated typing must be held firmly, or the whole discipline leaks: what is stored is a tendency (an inga-fact, third-personal); the *arrogation itself* is an act that occurs, or does not, at act-time, and Row 2 reads the act's drive, never the tendency. A seed frozen into a bearer is a soul by another name — the tradition's own worry about the ālaya, and this grid's soul-guard, are the same guard. So the facts sort exhaustively into three registers: | Register | What it holds | Instances | |---|---|---| | **Field-facts** (inga) | Everything diachronic; index-free; carried | the causal series; *delivery* — which fruits arrive at which configuration; seeds — conditioning-facts about the series, including the re-pitched configuration the next deed reads; the tendency to arrogate | | **Weld-facts** (shu) | Everything indexed; made at act-time, spent at act-time; never carried | the agent-index of each deed; for-me-ness; the reception-weld's reach-back (below) | | **Stated** (Row 2) | Neither carried nor made; stated per-call | the placement of *this* act's index at *this* call — an occurrence-fact about the weld, field-describable via the composition of its drive; indexical in content, third-personal in register; the adverb on Row 3's verb | This is the answer, in one place, to *what does the next deed read?* — it reads a field-fact. The arrow does all the diachronic work, and does it index-free. The apparent contradiction ("re-pitched configuration" vs. "nothing stored") dissolves into the typing: the configuration is carried *as* an inga-fact, and what was never stored was only ever the index. And the table sorts registers of speech and role, not kinds of fact: a Row 2 statement states a field-describable fact (the composition above), and only the middle register holds what is no fact at all — the welding itself, an act. #### The arrow retyped: direction as display The fourth generator-verdict's third exercise — and, like the second, forced by the system's own clauses rather than chosen. [Glossary.md](Glossary.md) now records the arrow as *inga's directedness*: primitive furniture, blind but pointed. The retype empties the pointing one more level. What the field holds is correlational structure — which welds condition which, the delivery-lines, the web — and *direction* is a reading of that structure, never its own property. The reading has a mechanism, and the mechanism is thermodynamic: a gradient-embedded being — evolved to ratchet, or built of gates whose erasures are entropy-priced — takes the slope it sits on as a direction-fact and projects it into the field. That projection is **the ratchet** ([Glossary.md](Glossary.md)). The physicists' microreversibility is the same point in their register, consumed here as display only: the grid leans on no physics, exactly as it leans on no history at Huichang. What the retype leaves untouched is everything any theorem ever consumed — delivery-facts, conditioning, the lines along which the reach-back fills its second place. What changes register is the *before/after* alone: from carried fact to stated reading, the same demotion desert underwent on the first pass. (Where gradients thin — the deep cold — nothing there reads a direction: correlations persist, and causal talk loses its footing; not noise, but relation without a privileged direction of explanation.) The retype generates its own error pair, one per violation, nothing added by hand. The **freeze**: before/after held as a floor-claim — *time really flows* — the direction reified into furniture; the retrospective soul was this freeze in psychological dress, and the flowing container is its cosmological one. The **collapse**: the distinction fused under act-time diagnosis — *there is no time, so nothing happens, no one acts* — the fox's sentence transposed to time, not-fall spoken where not-obscure was called for. The deflationary reading is therefore not an objection the retype must survive; it is a cell the retype produces. And the positive account was in the source-text all along. Firewood abides in its dharma-position with its own before and after; ash in its own — 前後ありといへども、前後際断せり (Genjōkōan): before and after exist, yet before and after are cut off. Before/after is per-weld display, exactly as mineness is: the reach-back welds *pastness* — *this fruit as return of that deed*, a two-place index across time — the aimed call welds futurity at sowing, and each is spent at its own act-time, carried by nothing. Local time, welded per act; no flowing container anywhere — Dōgen's uji, with Huayan's ten times (十世隔法異成門) as the wider family. So the answer to *nothing is happening* is: happening is all there is; only the container was dropped — the same shape as anātman, where dropping the owner deleted no acts. One tension, written down rather than hidden, because the separate/fuse rule pivots on act-time and this retype conventionalizes time itself. There is no circle: act-time is a tier *within* the thermodynamic convention — precisely the convention beings live in, which is why diagnosis happens there — and the floor rule was always licensed to eat its own levels ("the two truths themselves are conventional"). Floor-fusion now explicitly includes fusing before/after, which makes the fox's question — *does he fall into cause and effect?* — even more literally the question the whole grid answers. ### The being-convention The same demotion now applies to the macro being. A being, at this scale, is a conventional truth downstream of the words: anything nameable can be designated. The universe, its makeup evolved from a dense hot gas cloud; the stone; the buddha; the gerrymander; the hare's horn; the impossible ātman — all are legal designations as designations. Nothing licenses one as more legitimately a being. The constraint enters later, at realization and use, not at naming. Squeamishness about this is itself one of the beings-row errors: the collapse says "there are no beings"; the freeze picks one partition and mistakes it for ontology. The ordering is ontological, not chronological. The floor/genjō vocabulary sits outside all conventions. The bare signature supplies words-level tags. The directed convention reads a slope as before/after. Inside that, the being-convention reads fine tags as macro beings, and inside both sits the grid-lens that diagnoses collapse and freeze. Names track what their *reading* presupposes, not what their definition consumes: `DeliveredTo` already used this rule, since it consumes `conditions` but its name reads the arrow. Likewise the new `Grid.DirectedConvention.BeingConvention` names read a tag as a being even when their definiens is direction-free. Lean makes the demotion explicit with `BeingCoarsening`: a diagnosis-time projection from fine tags to macro tags, never a field in the signature. The fiber under a macro tag is where typing happens. `SentientTag` means some fine tag in the fiber mounts a response somewhere. There is no rival `InsentientTag`; constructively, `not_sentientTag_iff_fiber_all_stone` says non-sentience is exactly the all-stone fiber. That is also the deflated home of 無情説法: insentient preaching is not a hidden subject speaking, but the all-stone fiber read on the object-axis. The spectrum is fiber-level and per-weld. `FiberAtPole` says every actual weld in the fiber reads at the pole-class: the 84,000 pores each a responsive dharma-gate. `SelfAptTag` says every actual weld in the fiber still carries a live self-pole index: the hell-dweller's monolithic convention, where "self" is apt if it is apt anywhere. `Patchy` names the irreducible middle. No aggregate fiber-share is defined, on purpose: Row 2 is a partial ordering, not a measure, so a mixed fiber is not a middling scalar. Coherence stays a grade, not a type. Evolution's contribution is display over the run — skin-bags usually score high at coordination, an adaptive register-clock can implement stable internal registers — but no theorem may condition legitimacy on coherence. The three registers need the same care: the swan is named, the naming is enacted as a weld, and the proneness to name is a seed. Thoughts are not "just seeds"; naming is a deed when it occurs. The soul-guard survives the new vocabulary. `selfAptTag_indices_are_per_weld_only` says that even where the self-convention is apt, the live index is only the per-weld agent tag. The macro self is the image of those spent tags under a coarsening. Holding it as more is the fiber version of the old soul-freeze. #### The reception-weld: loop-closure as theorem "The same being" across sowing and reaping is loop-closure — but closure must now be earned, not helped to. Here is how it is earned. A reception is intrinsically a reception-*of*: its content is *this-fruit-as-return-of-that-deed*. So the reception-deed's token-reflexive index is **two-place** — the weld makes mine both the receiving and, retrospectively, the deed received-from. This is **upādāna**, appropriation, the canonical partner of ahaṃkāra: the reach-back. Sameness of sower and reaper is not *tracked* across the gap — nothing indexed is there to track — but *made at reception*, each time, by an act of appropriation reaching back along the arrow. The loop is closed *by the reception-weld*, retrospectively; closure is enacted, not tracked, which is the same act-not-state discipline the rest of the grid runs on. So "the sower reaps" wears two faces and must be split along them. Its report-face — *an appropriation occurred at this reception, reaching back along that delivery-line* — is true simpliciter, an occurrence-fact the field carries like any other. Its ownership-face is not true or false but **done** — enacted whenever a return is received, full or vacuous (just below), never a standing diachronic fact persisting between acts. Held as a standing backward relation it would be a *retrospective soul*, and the soul-guard fires on it exactly as on the forward-facing kind: the reach-back, like every weld, is spent at its own act-time. Two consequences discharge two objections at once. First, appropriation cannot poach — and the block is typed, not decreed. The reach-back's index is two-place: *this fruit as return of that deed*. Whether that deed conditioned this fruit is a delivery-fact, inga's business, settled index-free — and where delivery drew no line, the index's **second place stands unfilled**. A reach-back along an undrawn line is therefore not false — it stated nothing, having never been in the stating business — but **vacuous**: an appropriating with nothing arrived to appropriate. (Austin's word for this shape, *misfire*, is legal here only as display — over the pattern, never as mechanism — since nothing here is a speech act: the conditions the field owns are not conventions but delivery-facts, and what they settle is whether there is anything to weld.) So there is no welding at a distance, not by decree but by typing: inga settles the **delivery-question** (which fruits arrive at this configuration — causal, index-free, hard in the ordinary way), the weld answers only the **index-question** over what arrives, and the field owns the reach-back's conditions in exactly that deflated sense. Second, the diachronic *whose*-question decomposes **exhaustively**: a delivery-fact (field) plus a fresh appropriation (weld), with no third fact left over for a cross-gap convention to fix. A series-account owns the delivery-half, which was ceded to the field from the opening page — *na ca so na ca añño*, the reaper neither the sower nor another, is the tradition itself declining the robust diachronic identity-fact that would do more. The loop is *individuated* by inga (a series-fact, granted) and *closed* at each reception by the reach-back (a weld-fact, made). Nothing about ownership crosses the gap, because there is no cross-gap *whose*. If *ownership*, as the tradition's convention uses the word, is located in the continuity-fact instead, the remaining dispute is where the soteriology's load sits; this paper's answer is the object's own usage — the offices-spine stated in the identification file (Identification). #### The weld's two faces The karma-agent has no own-being: mere-designation, floating free of any base like the chariot. Its charter is **MMK 8** (kāraka: the doer proceeds dependent on the deed, the deed on the doer — neither prior, neither based), flanked by **MMK 17** (act and fruit — the loop) and **MMK 18** (self). With no fixed base, soteriological direction can never be *read off* the facts — only *enacted*. So dependence and enactment are one fact seen twice: no-substrate on one side *is* the necessity of welding on the other. This is **the weld** — Dōgen's shushō, practice-realization — and it wears two faces, each true at its own tier: The same MMK 8 charter now has a checked interior form: even inside the weld, call→response order is a display reading, not before-and-after furniture recovered from unordered pair-content (`InteriorDirectionNegative.no_interior_direction_recovery`). The charter verse now has generated cells at both joints: the intra-weld arrow row for the face-order convention, and the doer/deed row for priority read as floor furniture. `RawWeld` keeps the names `call` and `response` because the display is useful; the theorem says only that the labels are not prior to the mutual dependence they name. - **shō** (証, realization), at the floor: no own-being, so no substance is caught in the causal net — **not-fall** (不落), anātman, not escape; grammatically the being-verified (証せらるる), the act's subject-position ceded. That shō is agential — but agential *because* welded, never on its own: there is no lone shō to rest in, only shushō-ittō, the true person of no rank going in and out. So shō is necessarily agential (it never occurs unwelded) without being agential of itself (the acting is shu's, lent at act-time) — the non-attaining middle, shō its floor-face, never a still attainment. - **shu** (修, practice), conventionally: the karmic arrow is real and inescapable, never evaded — **not-obscure** (不昧). ### The separate/fuse rule One rule governs every distinction the grid holds: **distinctions separate under act-time diagnosis and fuse at the floor (and at genjō — the share-zero pole, no arrogation left).** The rule dissolves the fox (not-fall at the floor, not-obscure conventional), governs the two-middles distinction (genjō provisional, shō non-attaining), and applies to the grid's own verdicts, which are conventional-tier claims that dissolve, harmlessly, below — the taxonomy's own mis-feeds are scoped in the identification file (Identification). And the rule's own pivot, act-time, is a tier within the thermodynamic convention (Karma: the arrow retyped) — the floor rule eating one more level, as it is licensed to; floor-fusion includes fusing before/after. Its two possible violations — **collapse** (fusing a distinction under act-time diagnosis) and **freeze** (holding a separation as a floor-claim) — generate the error-taxonomy whole (Theorems), one pair per distinction, with nothing listed by hand. ## One act through the grid: the fox's sentence The system has so far been stated as type-discipline; here is one case run through it whole. **The call.** A student asks the old Hyakujō whether the person of great practice falls into cause and effect. The question is a dharma advancing — Row 2 has a placement to read: *can he listen to this?* **The act.** He says *not fall*. The deed is self-forward — Dōgen's delusion, the *saying* — and doubly diagnosable. Grammatically (grade 1, assertable): a tier-error, a floor-truth uttered as a conventional answer, the antinomian collapse. Soteriologically (grade 2, displayable): the answer defends an attainment — a rank rested at — so the weld arrogates the act nearly whole; the question is not heard but met as a challenge to the rank — the rank's self-maintenance driving the reply, the question driving almost nothing (probe-displayed: any question grazing the rank meets the same defense) — the world of the act reduced to the rank's echo, and Row 2 reads the index pitched hard to the self-pole *at this call*. One doing, seen twice: the arrogation (Row 3) read as the placement (Row 2). *(checked: `fox_sentence_live_selfPole`, `oldMan_utterance_misfits`)* **The weld.** The deed welds the agent-index onto the blind arrow — *this act's agent* — token-reflexive, spent at that act-time. Nothing of it is stored. *(checked: `sentenceWeld_actual`)* **The arrow.** Inga carries the conditioning forward, index-free: no desert in flight, only delivery. What is carried between acts is a field-fact — a configuration that tends to arrogate at calls like this — a seed, a fact *about* the series. *(checked: `fox_arrow_index_free`)* **The returns.** Five hundred fox lives arrive — fruit landing, life by life, at the configuration the field delivers it to. Not punishment; delivery. *(checked: `fox_returns_delivered`)* **The receptions.** Each life's receiving is itself a deed. For five hundred lives the reception is arrogated — the saying-mode persists, but as a *disposition* (an inga-fact) enacted anew each time, never as a stored self; each reception's reach-back welds *this return of that deed* as mine, and each is spent. And each clenched reception *is* that life's dukkha — the saying-mode colliding with a delivery that answers to nothing, the mismatch enacted rather than a penalty appended: five hundred lives as the Dukkha derivation's worked example (Theorems), suffering as the loop's friction, not its sentence. Each reception re-pitches the configuration; the field carries the re-pitch to the next act; the next deed reads a field-fact. *(checked: `fox_reception_clenched`, `fox_dukkha_per_life`, `fox_config_carries_only_tendency`, `fox_rePitch_forgets`)* **The release.** The later Hyakujō's turning word — *not obscure* — is another call. This time the reception is *listening*: dharmas-forward, banpō susumite, the arrived word among the myriad. The reach-back appropriates the whole return — *the fox body's long fruit, mine, of that sentence, mine* — with markedly less of the act claimed: a share-ceding event, a kenshō, a rung and not a pole (the mountain of ox-herding still ahead). Not-obscure is enacted in the reception; not-fall is true at the floor of the same act; held each at its tier, non-dual — the fox lets go. And nothing is *kept*: the release is not a possession acquired but the next configuration re-pitched, which the next call will read. *(checked: `fox_release_rung_not_pole`, `fox_reachBack_full_at_release`, `fox_nothing_kept`)* Every load-bearing piece appears once: call, arrogation, weld, arrow, seed, return, reach-back, re-pitch, rung. The loop closes at reception, retrospectively, each time — nowhere else, and nowhere is it stored. *(checked: `foxSeriesCoarsening`, `foxSeries_macro_sentient`, `foxSeries_macro_selfConditioning`, `fox_consecutive_lives_distinct`)* And mark what the case never tests: neither utterance occurs at the pole. The koan's own question concerns 大修行底人 — a person of great practice, not a buddha; the old man answers from a defended rank, and the release is a rung with the mountain still ahead. So the fox exercises the loop entire — sowing, arrow, reception, re-pitch — without once asking what the loop is at share-zero. That question is the transposition (Theorems: the terminus). *(checked: `fox_never_tests_pole`)* "# def theoryDoc : Doc := { id := "theory" title := "Theory" output := "Exposition/Theory.md" source := "WeldAndArrow/Exposition/Theory.lean" summary := "The theory and worked fox example." blocks := [.raw theoryBody] } end WAA.Exposition ===== FILE: WeldAndArrow/Exposition/Thesis.lean ===== import WeldAndArrow.Exposition.Basic import WeldAndArrow.Signature import WeldAndArrow.Identification.Ownership namespace WAA.Exposition structure ThesisClause where id : String text : String status : ClaimStatus anchors : List Lean.Name := [] deriving Repr def thesisClauses : List ThesisClause := [ { id := "diachronicToField" text := "Everything diachronic belongs to the field" status := .checked anchors := [``Config] }, { id := "indexEnactedNotStored" text := "every index is enacted and nothing indexed is stored" status := .checked anchors := [``Grid.index, ``Grid.rePitch_forgets] }, { id := "karmaNamesLoop" text := "karma names this loop" status := .checked anchors := [``Grid.DirectedConvention.WaaOwnershipFace] }, { id := "namingEarnedByFit" text := "and the naming is earned by fit" status := .proseBound "fit to the traditional offices is argued in exposition" anchors := [``Grid.DirectedConvention.WaaReportFace, ``Grid.DirectedConvention.WaaOwnershipFace] } ] def thesisSentence : String := "Everything diachronic belongs to the field; every index is enacted and nothing indexed is stored; karma names this loop, and the naming is earned by fit" def thesisRender : String := "**" ++ thesisSentence ++ "** — the tradition's uses of karmic ownership (cetanā, reception, remorse, absolution, dedication) discharge natively at act-time." example : thesisSentence = "Everything diachronic belongs to the field; every index is enacted and nothing indexed is stored; karma names this loop, and the naming is earned by fit" := rfl end WAA.Exposition ===== FILE: WeldAndArrow/Exposition/Verify.lean ===== import Lean import WeldAndArrow.Exposition.Docs import WeldAndArrow.Meta.Glossary namespace WAA.Exposition def isEmptyList : List α -> Bool | [] => true | _ => false def claimFailures (docId : DocId) (claim : Claim) : List String := match claim.status with | .checked => if isEmptyList claim.anchors then [docId ++ ": checked claim has no anchors"] else [] | .proseBound reason => if reason = "" then [docId ++ ": prose-bound claim has no reason"] else [] def xrefFailures (docIds : List DocId) (doc : Doc) : List String := doc.xrefs.filterMap (fun target => if docIds.contains target then none else some (doc.id ++ ": unknown xref target " ++ target)) def termFailures (terms : List String) (doc : Doc) : List String := doc.terms.filterMap (fun term => if terms.contains term then none else some (doc.id ++ ": glossary term not found: " ++ term)) def structuralFailures (docs : List Doc) (terms : List String) : List String := let docIds := docs.map (fun doc => doc.id) docs.flatMap (fun doc => doc.claims.flatMap (claimFailures doc.id) ++ xrefFailures docIds doc ++ termFailures terms doc) open Lean Elab Command Meta syntax (name := verifyExpositionAnchors) "#verify_exposition_anchors" : command unsafe def evalAllDocs : Term.TermElabM (List Doc) := do evalExpr (List Doc) (mkApp (mkConst ``List [Level.zero]) (mkConst ``Doc)) (mkConst ``allDocs) @[command_elab verifyExpositionAnchors] unsafe def elabVerifyExpositionAnchors : CommandElab := fun _stx => do let docs <- liftTermElabM evalAllDocs let env <- getEnv let mut failures : Array String := #[] for failure in structuralFailures docs WAA.glossaryTerms do failures := failures.push failure for doc in docs do for anchor in doc.anchors do unless env.contains anchor do failures := failures.push s!"{doc.id}: missing exposition anchor {anchor}" unless failures.isEmpty do let details := failures.foldl (fun acc item => acc ++ "\n" ++ item) "" throwError m!"exposition verification failed:{details}" #verify_exposition_anchors end WAA.Exposition ===== FILE: WeldAndArrow/Gen/Assumptions.lean ===== import WeldAndArrow.Gen.AssumptionsLib def main : IO Unit := do IO.print WAA.renderAssumptions ===== FILE: WeldAndArrow/Gen/AssumptionsLib.lean ===== import WeldAndArrow.Exposition.Basic import WeldAndArrow.Meta.AssumptionLedger namespace WAA namespace AssumptionsGen def renderAnchor (anchor : AssumptionAnchor) : String := "`" ++ anchor.name.toString ++ "` (" ++ anchor.status.label ++ ")" def renderAnchorList (anchors : List AssumptionAnchor) : String := match anchors with | [] => "None." | names => Exposition.joinComma (names.map renderAnchor) def anchorsForLayer (layer : AnchorLayer) (entry : AssumptionEntry) : List AssumptionAnchor := entry.anchors.filter (fun anchor => anchor.layer == layer) def renderEntry (entry : AssumptionEntry) : String := let signatureAnchors := anchorsForLayer .signature entry let downstreamAnchors := anchorsForLayer .downstream entry let note := match entry.note with | none => "" | some text => "\n\n> Note: " ++ text let downstream := match downstreamAnchors with | [] => "" | anchors => "\n\n**Downstream elaboration:** " ++ renderAnchorList anchors "### " ++ entry.«section».key ++ "." ++ toString entry.number ++ " " ++ Exposition.markdownEscape entry.title ++ "\n\n" ++ entry.statement ++ "\n\n" ++ "**Checked anchors (Signature):** " ++ renderAnchorList signatureAnchors ++ downstream ++ note def renderSection (sec : AssumptionSection) : String := "## " ++ sec.key ++ ". " ++ sec.label ++ "\n\n" ++ String.intercalate "\n\n" ((assumptionSectionEntries sec).map renderEntry) def renderAxiomAuditEntry (name : Lean.Name) : String := "- `" ++ name.toString ++ "` -- pinned by `#guard_msgs` in " ++ "`WeldAndArrow/Signature/Assumptions.lean` to depend on no axioms." def renderAxiomAudit : String := "## Axiom audit\n\n" ++ String.intercalate "\n" (assumptionAxiomAudit.map renderAxiomAuditEntry) def renderAssumptions : String := "\n\n" ++ "# Assumptions\n\n" ++ "Generated from `WeldAndArrow/Meta/AssumptionLedger.lean` by " ++ "`lake exe assumptions_gen`. `WeldAndArrow/Signature/Assumptions.lean` " ++ "holds the compile-checked anchor pins; statement prose is canonical here.\n\n" ++ String.intercalate "\n\n" [ renderSection .asserted, renderSection .declined, renderSection .convenience, renderAxiomAudit ] ++ "\n" end AssumptionsGen def renderAssumptions : String := AssumptionsGen.renderAssumptions end WAA ===== FILE: WeldAndArrow/Gen/Exposition.lean ===== import WeldAndArrow.Gen.ExpositionLib def main (args : List String) : IO Unit := do match WAA.Exposition.parseArgs args with | .error msg => throw (IO.userError msg) | .ok opts => if opts.check then WAA.Exposition.checkDocs opts.outputRoot else WAA.Exposition.writeDocs opts.outputRoot ===== FILE: WeldAndArrow/Gen/ExpositionLib.lean ===== import WeldAndArrow.Exposition.Docs namespace WAA.Exposition structure Options where check : Bool := false outputRoot : String := "" def outputPath (outputRoot path : String) : String := if outputRoot == "" then path else outputRoot ++ "/" ++ path def renderedDocs (outputRoot : String := "") : List (String × String) := allDocs.map (fun doc => (outputPath outputRoot doc.output, renderDoc doc)) def ensureOutputDirs (outputRoot : String) : IO Unit := do IO.FS.createDirAll (outputPath outputRoot "Exposition") def writeDocs (outputRoot : String := "") : IO Unit := do ensureOutputDirs outputRoot for (path, content) in renderedDocs outputRoot do IO.FS.writeFile path content def checkDocs (outputRoot : String := "") : IO Unit := do let mut mismatches : Array String := #[] for (path, expected) in renderedDocs outputRoot do let current <- IO.FS.readFile path if current != expected then mismatches := mismatches.push path unless mismatches.isEmpty do let details := mismatches.foldl (fun acc path => acc ++ "\n" ++ path) "" throw (IO.userError s!"exposition output drift:{details}") def parseArgs : List String -> Except String Options | [] => .ok {} | "--check" :: rest => do let opts <- parseArgs rest pure { opts with check := true } | "--output-dir" :: dir :: rest => do let opts <- parseArgs rest pure { opts with outputRoot := dir } | arg :: _ => .error s!"unknown argument: {arg}" end WAA.Exposition ===== FILE: WeldAndArrow/Gen/FullExpositionGeneration.lean ===== import WeldAndArrow.Gen.AssumptionsLib import WeldAndArrow.Gen.ExpositionLib namespace WAA.Gen.FullExpositionGeneration def outputRoot : String := ".lake/exposition-full" def expositionDir : String := outputRoot ++ "/Exposition" def expectedFiles : List String := [ "Assumptions.md", "Formalization.md", "Glossary.md", "Identification.md", "Theorems.md", "Theory.md", "index.md" ] def writeAssumptions : IO Unit := do IO.FS.createDirAll expositionDir IO.FS.writeFile (expositionDir ++ "/Assumptions.md") WAA.renderAssumptions def checkNonempty (file : String) : IO Unit := do let path := expositionDir ++ "/" ++ file let content <- IO.FS.readFile path if content.isEmpty then throw (IO.userError s!"generated exposition file is empty: {path}") def run : IO Unit := do WAA.Exposition.writeDocs outputRoot writeAssumptions for file in expectedFiles do checkNonempty file end WAA.Gen.FullExpositionGeneration def main : IO Unit := do WAA.Gen.FullExpositionGeneration.run ===== FILE: WeldAndArrow/Gen/Glossary.lean ===== import WeldAndArrow.Exposition.Glossary def main : IO Unit := do IO.print WAA.renderGlossary ===== FILE: WeldAndArrow/Identification.lean ===== import WeldAndArrow.Identification.Commentary import WeldAndArrow.Identification.Residues import WeldAndArrow.Identification.Ownership import WeldAndArrow.Identification.Placements import WeldAndArrow.Identification.Registers import WeldAndArrow.Identification.Disclaimers import WeldAndArrow.Identification.Absences ===== FILE: WeldAndArrow/Identification/Absences.lean ===== /- ================================================================================ WeldAndArrow.Identification.Absences Instructive absence enumeration and anchors ================================================================================ Reading and motivation: Identification/Commentary.lean, C.2a. -/ import WeldAndArrow.Consequences.Ladder import WeldAndArrow.Consequences.FoxCase import WeldAndArrow.Doctrines.Sraddha import WeldAndArrow.Doctrines.Icchantika import WeldAndArrow.Doctrines.EthicsNegative import WeldAndArrow.Identification.Ownership namespace WAA /- ============================================================================== Section 3 instructive absences ============================================================================== -/ /-- Whether a section 3 absence is still open or has been delivered and retained as a regression check. Membership and status are deliberately separate: `InstructiveAbsence` constructors track the paper's section 3 list, while `status` tracks the world-facing fact of whether an entry is still standing. Retiring another absence should change its status, not delete its constructor or renumber the list. -/ inductive AbsenceStatus where | standing | retiredAsCheck /-- The section 3 instructive absences: gaps the system generates deliberately, each doing diagnostic work rather than marking a lacuna. -/ inductive InstructiveAbsence where /-- Empty cells in the Grade-1 table: not every distinction is symmetric. The diagnostic work is the table asymmetry itself; errors do not lie on a single line. -/ | emptyCells /-- The declined case: the deaf-blind being receives no error verdict. The diagnostic work is the refusal to over-generate; the errors nearby belong to the diagnostician. -/ | declinedCase /-- What the fox never tests: neither worked utterance occurs at the pole. The diagnostic work is to force the terminus question to be answered outside the paradigm case. -/ | foxNeverTestsPole /-- The third arrival: the never-clenched candidate is delivered from the stone side. The diagnostic work now lives as a check: function mounted, no share ever claimed, dukkha-free by construction. -/ | thirdArrival /-- Why calls land at all: receptive moments exist on the adaptive side and any landing occurs on the fixed-call side. The diagnostic work is to leave delivery ceded as a world-fact rather than a theorem manufactured by the grid. -/ | whyCallsLand /-- The fourth truth withheld from the theory's voice: the grid displays the fourth-truth shape but does not utter the detached command. The diagnostic work is the no-value clause itself: room and shape, no pull. -/ | fourthTruthWithheld /-- No stage immune to error: a terminal safe cell would be a rank. The diagnostic work is to keep even buddha-immunity per-call rather than possessed. -/ | noSafeStage /-- Prudential privilege underivable: special first-personal authority over future concern is absent as a theorem. The diagnostic work is the forward-facing twin of the cross-gap whose being refused. -/ | prudentialPrivilege /-- No measure over the grade: the order is partial and display-facing. The diagnostic work is to make the missing scalar deliberate; no probability or metric apparatus is owed over grade or delivery. -/ | noMeasure /-- The icchantika declined: a non-stone being live at every mounted call (the terminus's inverse) is reachable as a receiver and un-seatable as an enlightened agent on its run, yet receives no permanent "cannot become buddha" verdict. The diagnostic work is the refusal to type foreclosure as a stored kind; defiance is a seed, not a rank. -/ | icchantikaDeclined namespace InstructiveAbsence open Grid open Grid.DirectedConvention open Grid.DirectedConvention.BeingConvention open Grid.DirectedConvention.BeingConvention.GridConvention /-- Preserve the paper's section 3 order without making the number itself carry doctrinal weight. -/ def number : InstructiveAbsence → Nat | .emptyCells => 1 | .declinedCase => 2 | .foxNeverTestsPole => 3 | .thirdArrival => 4 | .whyCallsLand => 5 | .fourthTruthWithheld => 6 | .noSafeStage => 7 | .prudentialPrivilege => 8 | .noMeasure => 9 | .icchantikaDeclined => 10 /-- Current world-facing status of each paper entry. Constructors remain the section 3 ledger; this function records retirement. -/ def status : InstructiveAbsence → AbsenceStatus | .thirdArrival => .retiredAsCheck | .icchantikaDeclined => .standing | _ => .standing theorem emptyCells_number : number InstructiveAbsence.emptyCells = 1 := rfl theorem declinedCase_number : number InstructiveAbsence.declinedCase = 2 := rfl theorem foxNeverTestsPole_number : number InstructiveAbsence.foxNeverTestsPole = 3 := rfl theorem thirdArrival_number : number InstructiveAbsence.thirdArrival = 4 := rfl theorem whyCallsLand_number : number InstructiveAbsence.whyCallsLand = 5 := rfl theorem fourthTruthWithheld_number : number InstructiveAbsence.fourthTruthWithheld = 6 := rfl theorem noSafeStage_number : number InstructiveAbsence.noSafeStage = 7 := rfl theorem prudentialPrivilege_number : number InstructiveAbsence.prudentialPrivilege = 8 := rfl theorem noMeasure_number : number InstructiveAbsence.noMeasure = 9 := rfl theorem icchantikaDeclined_number : number InstructiveAbsence.icchantikaDeclined = 10 := rfl theorem emptyCells_standing : status InstructiveAbsence.emptyCells = AbsenceStatus.standing := rfl theorem declinedCase_standing : status InstructiveAbsence.declinedCase = AbsenceStatus.standing := rfl theorem foxNeverTestsPole_standing : status InstructiveAbsence.foxNeverTestsPole = AbsenceStatus.standing := rfl theorem thirdArrival_retired : status InstructiveAbsence.thirdArrival = AbsenceStatus.retiredAsCheck := rfl theorem whyCallsLand_standing : status InstructiveAbsence.whyCallsLand = AbsenceStatus.standing := rfl theorem fourthTruthWithheld_standing : status InstructiveAbsence.fourthTruthWithheld = AbsenceStatus.standing := rfl theorem noSafeStage_standing : status InstructiveAbsence.noSafeStage = AbsenceStatus.standing := rfl theorem prudentialPrivilege_standing : status InstructiveAbsence.prudentialPrivilege = AbsenceStatus.standing := rfl theorem noMeasure_standing : status InstructiveAbsence.noMeasure = AbsenceStatus.standing := rfl theorem icchantikaDeclined_standing : status InstructiveAbsence.icchantikaDeclined = AbsenceStatus.standing := rfl /- ------------------------------------------------------------------------------ Anchors ------------------------------------------------------------------------------ -/ /-- Empty cells are table metadata rather than new grid semantics: the per-call/global row has no collapse occupant while its collapse and freeze refutations remain checked. -/ theorem emptyCells_anchor {Contrib : Type} [PreorderBot Contrib] (G : Grid Contrib) : hasCollapseOccupant RowTag.perCallGlobal = false ∧ hasFreezeOccupant RowTag.perCallGlobal = true ∧ (∀ t, ¬ (perCallGlobalRow G).Collapse t) ∧ ¬ (perCallGlobalRow G).Freeze := perCallGlobal_empty_collapse_cell_anchor (G := G) /-- The concrete fox case never tests share-zero at any actual weld. -/ theorem foxNeverTestsPole_anchor : ∀ w : FoxCase.foxGrid.Weld, FoxCase.foxGrid.Actual w → ¬ AtBot (FoxCase.foxGrid.share w) := FoxCase.fox_never_tests_pole /-- Any recorded utterance in the concrete fox grid is away from share-zero, because recorded utterances carry actual welds. -/ theorem foxNeverTestsPole_recordedUtterance_not_atBot (u : Grid.RecordedUtterance FoxCase.foxGrid (rowLanguage FoxCase.foxGrid)) : ¬ AtBot (FoxCase.foxGrid.share u.weld) := FoxCase.fox_never_tests_pole u.weld u.actual /-- An actual fox-case weld is not made by an agent already in the pole-class: actuality rules out the stone side, and terminus-typing would force share-zero. -/ theorem foxNeverTestsPole_actual_not_atPoleClass {w : FoxCase.foxGrid.Weld} (hactual : FoxCase.foxGrid.Actual w) : ¬ FoxCase.foxGrid.AtPoleClass w.agent := by intro hpole rcases hpole with hstone | hterm · exact FoxCase.foxGrid.not_stone_of_actual w hactual hstone · exact FoxCase.fox_never_tests_pole w hactual (FoxCase.foxGrid.atBot_of_terminus_response hterm hactual) /-- Any recorded utterance in the concrete fox grid is away from the pole-class on its agent side. -/ theorem foxNeverTestsPole_recordedUtterance_not_atPoleClass (u : Grid.RecordedUtterance FoxCase.foxGrid (rowLanguage FoxCase.foxGrid)) : ¬ FoxCase.foxGrid.AtPoleClass u.weld.agent := foxNeverTestsPole_actual_not_atPoleClass u.actual /-- The old man's recorded answer remains the fox-row live-tier misfit anchor. -/ theorem foxNeverTestsPole_oldMan_misfit_anchor : ¬ FoxCase.oldManUtterance.FitsOfferedTier := FoxCase.oldMan_utterance_misfits /-- The delivered third arrival is the concrete function/share split: the adaptive responder mounts function while its received share is at bottom. -/ theorem thirdArrival_function_mounted_no_share : AtBot (clockGrid.share ⟨Clock.adaptive, Listener.present, Chime.chime⟩) ∧ ¬ clockGrid.Stone Clock.adaptive := shareZero_not_functionZero_witness /-- The retired absence is kept as the dukkha-free-by-construction check: a terminus response has no live mismatch. -/ theorem thirdArrival_not_waaMismatchLive : ¬ clockGrid.WaaMismatchLive ⟨Clock.adaptive, Listener.present, Chime.chime⟩ := clockGrid.not_waaMismatchLive_of_terminus_response adaptive_is_terminus rfl /-- The fourth-truth anchor is still only an implication type: the grid proves the conditional and does not detach the injunction. -/ theorem fourthTruthWithheld_conditional {Contrib : Type} [PreorderBot Contrib] (G : Grid Contrib) (g : G.Being) (before : Config Contrib) (deed reception : G.Weld) : WaaPathOught G g before deed reception := waaPathOught_conditional G g before deed reception /-- The detached fourth-truth injunction is displayable, not assertable. -/ theorem fourthTruthWithheld_detached_voice : ErrorGrade.voice WaaDetachedOughtVoice = VerdictVoice.displayable := waa_detached_ought_voice_displayable /-- A terminal safe stage would be a final ladder level; the ladder theorem rules that out for an error-free seed. -/ theorem noSafeStage_anchor {Contrib : Type} [PreorderBot Contrib] {G : Grid Contrib} {d : Grid.Distinction G} (h : Grid.ErrorFree G d) : ¬ ∃ n, (ladder d n).Freeze := no_final_level_of_errorFree (G := G) h /-- The prudential-privilege absence is owned as theorem in the witness module, not promoted into a new table row. -/ theorem prudentialPrivilege_underivable_anchor : ¬ Grid.DirectedConvention.PrudentialPrivilegeNegative.PrudentialPrivilege := Grid.DirectedConvention.PrudentialPrivilegeNegative.not_prudentialPrivilege /-- The icchantika decline records the honest agent-side bar without turning it into a permanent foreclosure verdict. -/ theorem icchantikaDeclined_agent_anchor {Contrib : Type} [PreorderBot Contrib] {G : Grid Contrib} {b : G.Being} (h : Icchantika G b) : ¬ G.Stone b ∧ ¬ G.Terminus b ∧ ¬ WaaFullyEnlightened G b := ⟨icchantika_not_stone (G := G) h, icchantika_not_terminus (G := G) h, not_waaFullyEnlightened_of_icchantika (G := G) h⟩ /-- The receiver-side half of the icchantika decline: actual icchantika receptions discharge the live-aversion antecedent. -/ theorem icchantikaDeclined_receiver_anchor {Contrib : Type} [PreorderBot Contrib] {G : Grid Contrib} {before : Config Contrib} {b : G.Being} {reception : G.Weld} (hagent : reception.agent = b) (hic : Icchantika G b) (hactual : G.Actual reception) (hlive : ¬ AtBot before.tendency) : WaaAversionContext G before reception := aversionContext_of_icchantika_reception (G := G) hagent hic hactual hlive /-- The concrete non-foreclosure witness is part of the absence anchor: the icchantika run does not recover a permanent "no landing ever" verdict. -/ theorem icchantikaDeclined_nonforeclosure_anchor : ∃ (before : Config Nat) (b : IcchantikaCase.grid.Being) (deed reception : IcchantikaCase.grid.Weld), Icchantika IcchantikaCase.grid b ∧ reception.agent = b ∧ IcchantikaCase.grid.Actual reception ∧ ¬ AtBot before.tendency ∧ DeliveredTo IcchantikaCase.grid deed reception ∧ IcchantikaCase.grid.IsShareDrop before reception ∧ HasShareDropLanding IcchantikaCase.grid before deed := icchantika_release_not_foreclosed end InstructiveAbsence end WAA ===== FILE: WeldAndArrow/Identification/Commentary.lean ===== /- ================================================================================ WeldAndArrow.Identification.Commentary Reading notes for the layered Lean development ================================================================================ This comment-only module records the paper-facing readings for the formal layers. It imports nothing and asserts nothing. -/ /- ================================================================================ §C Commentary ================================================================================ C.0 Naming and Scope Names beginning `Waa` mark identifiers that assert a system-POV reading: what the concept looks like from this grid, not what the concept is in a detached doctrinal voice. The marker covers ownership, appropriation, whose-ness, reach-back, sowing-side aiming, four-truths mismatch vocabulary, and sraddha conditional vocabulary such as `WaaMismatchGrade`, `WaaMismatchLive`, `WaaAversionContext`, `WaaFullyEnlightened`, and the tariki/jiriki line readings. Doctrine names are carried by module names and commentary headings; checked reading identifiers use the single `Waa` marker. Unprefixed names remain the neutral delivery, order, token-projection, and tier-placement vocabulary, including `SameAgentDelivery` and `CrossAgentDelivery`. `Grid.DirectedConvention` marks vocabulary that consumes the directional reading of `conditions`; the primitive signature itself does not add asymmetry, irreflexivity, or transitivity premises to `conditions`. C.1 Signature/Order.lean, Signature/Grid.lean, Signature/BeingConvention.lean, Signature/Models.lean, Signature/Claims.lean `Signature/Assumptions.lean` is the canonical, compile-checked list of the Signature layer's assumptions; this commentary supplies the paper-facing motivation around those inputs. `Config` is the formal place where "nothing self-indexed is stored" is enforced: it carries only a `Contrib`-valued tendency and no owner, being, or weld field. This is the type-level version of the paper's internal mis-feed discipline. `Identification/Registers.lean` records the register table for the same sorting: field facts are carried, weld facts are spent, and grade statements are stated. Seeds, potency, and environs talk in the paper are read here as field-side delivery lines (`conditions`) and candidate receptions, not as capacities stored in a being. The alaya/bija-as-stored-state reading is deliberately not taken. The direction-freedom of `conditions` is a modelling decision tied to Theory: Karma, "The arrow retyped: direction as display". `ConditionsEither` records the symmetrized field fact, while `Grid.DirectedConvention` names the reading layer that consumes ordered roles. The thermodynamic/arrow-of-time gloss motivates the reading but is never a premise of a theorem. `RawWeld`, `Grid.index`, and `Grid.share` encode the MMK 8 point that there is no separate prior act or performer inside the formal signature: the index and share are projections from a completed weld. `no_agent_recovery_of_field_collision` is the internal recovery obstruction corresponding to that gloss. `SelfLineWitness` records that self-lines are permitted by the signature and can satisfy the ownership-face vocabulary when the model supplies reflexive delivery. The compile-checked pins for the input-side assumptions live in `Signature/Assumptions.lean`; their canonical prose and downstream anchor metadata live in `Meta/AssumptionLedger.lean`. The paper's shushō-ittō discussion is a reading of that permission, not a premise. The hand-rolled `Preorder` is used for dependency-freedom and to keep the exact assumptions visible. Mathlib has the counterparts `Preorder`, `OrderBot`, and `IsBot`; the local `AtBot` is the order-class of the chosen bottom and is equivalent in role to Mathlib's `IsBot` predicate for that element. There is no `PreorderTop`: the solipsist/total-share gloss in the paper is an asymptote, not an attained element. By contrast, `PreorderBot` supplies an attained bottom so `AtBot` can express the share-zero pole as an order-class. `Stone`, `Terminus`, `AtPoleClass`, and `stone_is_terminus_vacuously` implement the function/share split discussed in Theory: Attainment. A stone has no mounted response; a terminus has mounted responses whose grade lies at the pole-class. `rePitch` keeps `_before` in the signature because the operation is conceptually on a prior configuration, even though the current simple implementation depends only on the received weld. `IsShareDrop` is the strict order comparison `Strict (G.share received) before.tendency`. `Signature/BeingConvention.lean` records the reading in which fine tags may be diagnosed as macro beings. Its examples accommodate the paper's sentient, hare's-horn, buddha, and generated-boundary cases without adding a privileged partition to `Grid`. `Signature/Models.lean` holds the concrete clock and register-clock witnesses consumed by later taxonomy checks. `Signature/DirectionConvention.lean` records the parallel delivery-axis reading in which a model may be diagnosed through finite clock resolution. A `DirectionCoarsening` supplies ticks over welds without adding a field to `Grid`; `ResolutionBounded` says only that same-tick welds have order-equivalent shares in the chosen display. The point is deliberately display-side: sub-tick delivery cannot carry strict `TimeDirection`, but no stone, terminus, sentience, pole-class, or self-index predicate consumes the coarsening. The separate/fuse interface (`ClaimLanguage`, `Distinction`, `RecordedUtterance`, `Tier`) is the small formal surface needed for the fox, Baizhang, shō/shu, genjō, and verdict-tier discussions. The formal module keeps only the abstract interface; this commentary retains the textual motivation. C.2 Consequences/Basic.lean, Consequences/Taxonomy.lean, Consequences/Compounds.lean, Consequences/Ladder.lean, and Consequences/ContentRows.lean; Identification/Ownership.lean The consequence layer proves neutral facts about the definitions: function/share facts, share-drop obstruction at the pole, delivery and landing projections, and tier diagnostics. The generated table rows live in `Consequences/Taxonomy.lean`; the re-emptying machinery lives in `Consequences/Ladder.lean`; and the content-bearing layer rows live in `Consequences/ContentRows.lean`. The paper's readings of these facts live here as commentary only; the theorem statements consume only the neutral definitions. The strictness facts are now in `Signature/Order.lean` as `Strict`, `strict_irrefl`, `strict_asymm`, `strict_trans`, `strict_of_le_of_strict`, `strict_of_strict_of_le`, `not_strict_of_orderEq`, and `no_strict_of_all_orderEq`. The arrow-of-time gloss uses `Grid.DirectedConvention.TimeDirection`, an abbreviation of `Strict`. `strict_shareBot_of_hasSelfPoleIndex` and its re-rooted `timeDirection_of_hasSelfPoleIndex` reading make a live share itself the direction witness against bottom. `DirectionVoid` names the absence of any strict comparison, while `AllStone` names the grid-wide absence of response function. `RowTag`, `RowClaim`, `rowLanguage`, and `rowOf` now generate the table's schema rows with pole-affirming semantics. `beforeAfterRow`, `beingsRow`, `gridLensRow`, and `weldRow` are compatibility names for `.layer` tags in that schema. Their collapse and freeze checks remain hypothesis-free; their obedience theorems carry only the local `AtBot` stability needed for non-live genjo fusion. The full row list is Lean data as `tableOrder`. `intraWeldArrow` is a `ConventionLayer`, not a bare row tag, because it names the convention by which the two faces of a weld are ordered. Its content denial is response-invariance: if no being's response varies with call, the call-face does no work, so there is no interior order to read. The conditional obedience theorem therefore asks for `∃ b, G.ResponseVariesWithCall b`, parallel to the directed-time row's strictness witness. A single recorded utterance of the content denial does not by itself extract two different responses from two calls, so the shipped utterance theorem is the schema-level live-tier misfit form, routed through `denied_misfits_live_offer`. `doerDeed` is a schema-only `RowTag`. The tempting content form, "the doer is prior to the deed", would require adding a priority structure to the opaque signature, thereby installing exactly the furniture MMK 8 is being used to deny. The floor-furniture flank is instead carried by `DoerDeedNegative.no_priority_recovery`, a witness that the same visible grid data support both a prior-doer reading and a mutual-dependence reading. Fusion remains ordinary row trivialization: the code nowhere says that doer and deed merge into one thing. The generator-discipline check is the same one that motivated `weldRow`: a generated row should name the convention whose collapse/freeze it diagnoses. `intraWeldArrow` names the face-order convention; `doerDeed` names the doer/deed ordering, with the `RawWeld` being component as its concrete anchor but without promoting priority to a field. The labels "coming-to" and "going-from" are display names for transposed readings of the two weld faces, not new tier names. `ReflexivityWitness.ladderRungGrid` is deliberately only one legal grid: it instantiates `Being` with `Nat` read as rung labels and then reruns the beings ladder. This does not define beings as rungs, and it leaves `BeingNegative.no_partition_recovery` untouched. `Consequences/Compounds.lean` records the compound-position decompositions as the same kind of paper-facing data plus `rfl` pins used by placements and the table order. Its components are classificatory rather than probative: citing a cell does not prove a row collapses or freezes, because the generated rows already carry their own refutations. The type-level guard is that components can cite only `TableRow`s already in the Grade-1 table; facets mark distinct prose faces of repeated rows, roles separate stacked cells from Grade-1 cells riding alongside, and legal elements carry no verdict voice. `CompoundPosition.ledgerPicture` is the fifth entry: possession-freeze and transposed-as-mechanism are stacked cells, command-style delivery-arrogation is the conditional `.alongside` cell, and the causal skeleton is carried as a legal element. The `.command` facet is row-neutral like the others; it only keeps the command face from collapsing into the exit-premise's plain delivery-index citation. The `contentLayerLanguage` keeps the convention-live side as the live-share condition and gives row-specific content to the denial side. Its obedience theorems are aptness-conditional by design: where the denial is simply true, the convention row should not be held. This track deliberately keeps `LayerClaim`: global denials such as all-stone, direction-void, no-live-tier, or no-actual-weld cannot be made pole-affirming by truth at a particular genjo weld. `RecordedUtterance` supplies the actuality needed for the content utterance checks, while `denied_misfits_live_offer` and `fox_utterance_misfits_live_offer` perform the same live-tier check for the schema language. The `reEmptied` transformer and `ladder` iterate the separate/fuse rule without adding a claim that quantifies over all levels. `ErrorFree`, `reEmptied_obeys_of_errorFree`, and `ladder_obeys_of_errorFree` record the refutation-only route by which the implemented `finalBelow` side lets the ladder climb without an added stability premise above the seed. The "completed ladder" remains an instructive absence: level quantification appears only in meta-theorems such as `ladder_obeys`, `no_level_final_of_obeys`, and the existential guard `no_final_level_of_errorFree`. Concrete witnesses such as `shareZero_not_functionZero_witness`, `rung_not_pole_witness`, `backsliding_witness`, `backsliding_rePitchSequence_witness`, `standing_does_not_determine_dated`, `subitism_possibility_witness`, `waaSuddenArrival_witness`, `waaGradualArrival_witness`, `rate_invisible_to_config`, `cetana_grading_tracks_weld_not_field_witness`, `cetana_live_share_without_object_standing_witness`, and the `registerClock_staticized_*` checks keep the row anchors model-checked. `standing_does_not_determine_dated` and `subitism_possibility_witness` share the same clock-grid witness deliberately: the first serves the disposition/act retype, while the second names the sudden/gradual possibility claim. `waaSuddenArrival_witness` gives the doctrine-facing one-step form with actuality, `waaGradualArrival_witness` gives the register-clock staged form, and `rate_invisible_to_config` deliberately reuses `rePitch_forgets` as the rate-invariance anchor. `MemoryWitness.memory_witness` uses the same register-clock shape to display recall as reception: `recall_waaOwnershipFace` names the delivered trace, `falseMemory_waaVacuousOwnershipFace` names the unfilled second place, and `recall_spent` names the `rePitch_forgets` spentness. The memory names stay separate even where their concrete welds coincide with the prudence witness, so the two pressure-tests can cite the same registers without depending on each other. `withRespondsTo` and `staticized` are the futility operation: delivery-loss is real (`futility_delivery_loss_real`) while object-axis standing is unchanged (`Grid.DirectedConvention.staticized_objectAxisStanding_iff`). C.2a Identification/Absences.lean `InstructiveAbsence` mirrors the paper's section 3 list as inspectable data. The enum is not an editorial layer: entries remain members while the paper keeps them in section 3. `AbsenceStatus` records the mutable world-facing fact, so the third arrival is `retiredAsCheck` rather than deleted or renumbered. The same rule applies to future retirements: constructors track the section list, while `status` carries whether an entry still stands. The anchors are citations and shape checks, not new doctrine. Empty table cells are recorded beside `tableOrder` as `hasCollapseOccupant` and `hasFreezeOccupant`; `emptyCells_anchor` checks that a dash remains metadata while row refutations remain theorem facts. `foxNeverTestsPole_anchor` cites the concrete fox model's `fox_never_tests_pole`; the recorded-utterance and agent-side checks keep the worked case away from both share-zero and the pole-class. `thirdArrival_not_waaMismatchLive` reuses the terminus-response four-truth theorem: the retired absence is kept as the dukkha-free check. The fourth-truth, no-safe-stage, and prudential-privilege anchors cite `waaPathOught_conditional`, `no_final_level_of_errorFree`, and `PrudentialPrivilegeNegative.not_prudentialPrivilege`. The declined case, why-calls-land, and no-measure entries deliberately have only data/status pins: their missing theorem is the content the paper assigns them. C.3 Meta/Invariance.lean and Meta/InvarianceNegative.lean `DisplayReparam` is the admission criterion for predicates that mention the contribution carrier: they must transport across order-preserving and pole-preserving changes of display convention. This is the formal counterpart of treating contribution values as display conventions rather than operational tokens. The condition-transpose operation and its being-coarsening companion now live in the signature layer, beside the `conditions`, `DeliveredTo`, and `BeingCoarsening` vocabulary they transport. `Meta/Invariance.lean` remains the central home for `DisplayReparam` and all `map_*` transport lemmas. `transpose_transpose`, `map_transpose`, `staticized_transpose`, and `map_staticized` pin the three axis operations as definitionally orthogonal: reversing delivery, changing display, and removing a response function do not secretly implement one another. `DirectionCoarsening.transpose_subTickDelivery` is the delivery-axis companion: tick equality survives transposition, while the delivery line reverses. `DirectionCoarsening.displayMapDir`, `mapDir_sameTick_iff`, and `mapDir_resolutionBounded_iff` centralize its display transport. `Meta/InvarianceNegative.lean` holds the countermodels. `InvarianceNegative` explains why equality with the chosen bottom is not the system predicate: equality-to-bottom fails to transport, while `AtBot` and `Terminus` do. `DirectionNegative` is the countermodel behind Theory: Karma, "the arrow retyped": two grids agree on `ConditionsEither` and disagree on `conditions`, so the symmetric field structure does not recover direction. The physics and thermodynamics language motivates the reading, but no theorem depends on it. `InteriorDirectionNegative` is the same demotion one grain down. `RawWeld` keeps its named `call` and `response` fields because those names are useful display labels, just as `index` remains a useful projection after the self-pole demotion. `RawWeld.transposeCR` is only a smuggling detector on same-carrier call/response examples: unordered pair-content cannot recover which face is call, so the intra-weld arrow is not before-and-after furniture inside the weld. `DirectionCoarseningWitness` adds the finite-resolution check. The raw register clock cannot be given a universal tick with `ResolutionBounded` over the injective `Nat` display; a lawful fully coarse display uses the one-point carrier, whose `DirectionVoid` is obtained through the existing legal all-equivalent display collapse. The independence witness keeps the register clock's macro sentience and self-conditioning separate from any direction coarsening or resolution-bound hypothesis. `BeingNegative` is the parallel countermodel for designation: one fine grid allows both merge and split macro readings, so a unique being-boundary is not recoverable from the grid data alone. `WeldNegative` lowers the same freedom witness from who-counts-as-one-being to what-counts-as-one-act. Its `WeldSegmentation` is deliberately local to the negative witness: segmentation is a diagnosis-time reading over completed welds, not a new `RawWeld` field and not a new `Grid` parameter. The layer route for `weldRow` follows from that choice. The weld-grain is a convention the lens can diagnose exactly like directed time, beings, and the grid-lens; a bare `RowTag` would have named a row without naming the convention whose freeze and collapse the row is supposed to catch. `ContentNegative` supplies the countermodels for the aptness hypotheses on content rows: an all-stone/no-live grid and the two-bottom direction-void carrier make the relevant denials true at non-live act-time, so fusion fails there. The empty-domain witnesses separate two additional vacuities: `emptyCallGrid_false_stone_and_respondsToEveryCall` shows that no calls make stone and call-entire response coincide, while `emptyBeingGrid_no_liveTier` and `contentBeingsRow_obeys_emptyBeing` show that no beings leave no act-time tier on which the content row can fail to fuse. `CoverageNegative` certifies the coverage hypotheses on `directionVoid_of_surjective` and `map_waaFullyEnlightened_of_surjective`: strictness outside the image of a display reparameterization can make direction-voidness and faith-closure fail to preserve, parallel in duty to the aptness countermodels above. C.4 Doctrines/FourTruths.lean, Doctrines/Sraddha.lean, Doctrines/Faith.lean, Doctrines/Ethics.lean, and the sibling negative modules `WaaMismatchGrade` is definitionally `share`; this is the formal honesty clause for dukkha-talk as covariation rather than a second measure. `WaaMismatchLive` adds occurrence actuality to the self-pole-index condition, so stones fall outside the domain by `not_actual_of_stone`, and terminus responses fall to the pole-class by the existing terminus theorem. `WaaAversionContext` treats sraddha reception per call: it packages a live prior tendency and an actual live-mismatch reception, not a stored faith possession. `WaaFullyEnlightened` deliberately has two conjuncts: terminus typing and universal shortfall closure for delivered deeds. The physician simile belongs exactly there: the grid can prove `waaPathOught_conditional`, but the antecedents are faith-shaped and are never discharged by field facts. The faith-object therefore cannot be replaced by anything the fetter lattice names: the total-rectangle cut lacks function by `FettersNegative.total_cut_carries_no_function`, and even the live fiber reading lacks effectiveness by `FettersNegative.total_cut_with_function_not_waaFullyEnlightened`. `WaaFaithPrinciple` abstracts the sraddha antecedent to testimony: faith in enlightenment transmits truth to recorded utterances, with `waaPathClaimLanguage` instantiating the `ClaimLanguage` interface for the physician's sentence. `FaithNegative` shows the principle exceeds its own faith-object, so the "never discharged by field facts" clause survives the abstraction. `WaaEthicsStance` bundles the two undischarged antecedents -- principle and faith -- as the agent's contribution; `WaaEthicalCode` is the fourth-truth ought generalized over the faith-object's recorded testimony, still an implication type only. The deontic work is done by the receiver's own `WaaAversionContext`, not by testimony's truth: the physician's sentence is practical only where shortfall is live. `EthicsNegative` keeps the code honest three ways: empty at the pole, unsatisfiable over false testimony, and relative to the faith-object. `Doctrines/SraddhaNegative.lean` keeps that conditional honest. `SraddhaNegative` shows that dropping faith or dropping the live-aversion antecedent loses the landing, and `OrthogonalityNegative` shows that a responsive terminus need not be `WaaFullyEnlightened`. The opposite regime face is checked by `waaFullyEnlightened_of_responsiveTerminus_of_undelivered`: with no delivered own deeds, the closure conjunct holds vacuously. Teaching and non-teaching are delivery facts around a terminus, not two being-natures stored in it. C.5 Doctrines/Deliberation.lean `ConsequentialistConvention` is a descriptive reading layer. `DropCount` and `DropCountInFiber` count share-drop receptions across finite actual runs without adding probability, utility, or a command register. Their transport lemmas in `Meta/Invariance.lean` discharge the C.3 admission criterion for using them as display readings. `dropCountInFiber_le_dropCount` gives the per-fiber bound, and `dropCount_eq_sum_dropCountInFiber` says a complete noduplicate tag list adds the fibers back to the total; `map_dropCountInFiberSum` transports the sum. `ObjectiveNegative` reuses the merge/split being-convention pattern to show that "my drops" is not a function of grid data alone, with `split_dropCount_sum_eq_mergedDropCount` as the concrete census check. `backsliding_witness` gives the direct same-grid shape: a share-drop reception to the pole-class followed by a later actual live-share weld by the same being. `backsliding_rePitchSequence_witness` routes the same shape through `ReceptionPair.rePitchSequence`. `rePitch_forgets` and `accumulated_attainment_constant_of_same_final` restate backsliding in the form a maximizer needs: no accumulated attainment variable is stored in `Config`. `TransferNegative` records the adaptive track-record obstruction and the `ResponseInvariant` contrast case. `grade_independent_of_conditions` and `share_independent_of_conditions` keep the cetana claim at signature level: grade and share do not consume downstream delivery conditions. The concrete cetana witnesses are `cetana_grading_tracks_weld_not_field_witness` (same field residue, different share) and `cetana_live_share_without_object_standing_witness` (live share where standing fails). The AN 6.63 correlation itself and the comparative no-common-event reading remain prose-bound. `DeliveryArrogationNegative` instantiates the `ClaimLanguage` machinery for a command-shaped delivery claim and checks that a recorded plan fails `FitsOfferedTier` where delivery is absent. C.6 Identification/Placements.lean, Identification/Registers.lean, and Identification/Disclaimers.lean The contemporary placements and disclaimer-5 register sorting are paper-facing taxonomies kept in the office/placement pattern: data plus `rfl` pins, not a semantic interpretation of grid vocabulary. `SortedFact.register` is total over the table instances, so exhaustiveness of the three registers is carried by the definition rather than asserted as a separate theorem. The `nothing_selfIndexed_carried` check is the enumerated face of the same discipline enforced architecturally by `Config`: no owner or self-index field is stored between deeds. C.7 Doctrines/Ledger.lean The ledger case is run in code rather than read into it; this section is the reading, and the module's own header is the map. `MountsOnlyIn` is the function-side register/modality predicate - deliberately neutral vocabulary, like `MountsAt` and `ResponseInvariant`, because a receiver's open register is a fact about `respondsTo`, not a Waa reading. `landing_call_in_modality` is the response-shape fact the paper calls a theorem: any landing at a modality-restricted receiver carries a call in the modality, so the form of the answer that reaches the ledger is fixed by the ledger. The proof is near-definitional by design; `LedgerCase` discharges the non-vacuity duty the way `clockGrid` does for the function/share split. Hakuin's corrective, upaya, and the wisdom of the code remain display. `fiber_landing_call_in_modality` is the compression clause: where every fine tag under a macro tag shares the register, one answer reaches the fiber. The hypothesis is stated on `κ.proj` directly; `InFiber` unfolds to the same equation. Together with `sectorCoarsening` and `BeingNegative`, this is "the state's Row 2 is a display convention over the officials' welds" with its legality and its illegality both on record: legal as diagnosis-time coarsening, unrecoverable as grid-carried partition. `receptionCommandLanguage` is the deliberate sibling of `deliveryCommandLanguage` (C.5). The Deliberation negative shows a command over delivery failing where delivery is absent; the ledger's decree is the scale case with the opposite delivery polarity - delivered everywhere, landing nowhere it purports to command. `decree_engineers_calls_not_receptions` keeps both halves in one statement: suppression is grid-legal call-engineering, and the reception register stays uncommanded. The census's two named faces (`ledger_census_misfits_live_offer`, `ledger_prognosis_misfits_live_offer`) delegate to `denied_misfits_live_offer` at `.perCallGlobal` and `.standingDated`, exactly as the fox's marquee theorem does at `.foxWeld`. No `RowTag` is added: the module's checked form of "three errors, zero new cells" is that its taxonomy content is entirely delegation. The third error's anchors are section 2 of the module plus the Deliberation negative; the exit-collapse's corrective is model-checked as `purge_object_axis_subtraction_nil` with `corpus_still_delivered`. The Huichang face reuses the futility operation unchanged: `staticized`, `futility_delivery_loss_real`, `staticized_responseInvariant`, and `staticized_objectAxisStanding_iff` are consumed, not reproved. `purge_loop_runs_on` is the one genuinely new futility-face check: the non-staticized reception is still actual, which is the "loop ran on" clause stated as a model fact. Grades in `LedgerCase` are uniformly live and no being is pole-typed: the case asserts nothing about Baizhang's attainment, and the model is built so it cannot accidentally do so. The pedigree flag on the Pure Rules attribution is carried in the module header; the theorems consume the shape only. What the module declines is what the paper declines: no theorem asserts that the code saved Chan, that the state was wrong, or that the survival was worth having - the first is the historians', the second is ungradeable by the no-value clause, the third is valence borrowed from the object. C.7a Consequences/FoxCase.lean and Doctrines/FoxCase.lean `FoxCase.foxGrid` runs the paper's paradigm case as a concrete `Grid Nat`. Life 0 is the old man's answering life, later naturals are fox-life tags, and the display convention "the fox" is `foxSeriesCoarsening`, a diagnosis-time merge rather than a stored being. `foxSeries_macro_sentient`, `foxSeries_macro_selfConditioning`, and `fox_consecutive_lives_distinct` are the coarsening checks: the macro tag is legal and live, while the fine lives remain distinct. The per-beat checks are deliberately small. `fox_sentence_live_selfPole` records the old answer as actual and live; `fox_arrow_index_free` instantiates the grade/share independence of delivery; `fox_returns_delivered` gives the return line from the sentence into later lives; `fox_reception_clenched`, `fox_config_carries_only_tendency`, and `fox_rePitch_forgets` keep the receptions actual, live, and non-storing; `fox_release_rung_not_pole`, `fox_reachBack_full_at_release`, and `fox_nothing_kept` record the turning-word release as a share-drop, not a pole-arrival or possession. `fox_never_tests_pole` is intentionally true by construction: no grade in the model is zero, so the absence of pole-arrival is a displayed boundary of the koan, not a hidden answer to the terminus question. The Dogen doubling checks are grid-internal only. `oldMan_utterance_misfits` delegates the old answer to the fox row's live-tier misfit; `daishugyo_diagnosis_fits`, `jinshinInga_instruction_fits`, `jinshinInga_floor_voicing_would_misfit`, and `dogen_doubling_both_fit` type the two speech-act faces and the counterfactual floor-voicing. They do not prove the historical claim that this paper follows Daishugyo against the late Dogen; that disagreement stays prose. The dukkha-facing name `fox_dukkha_per_life` lives one layer down in `Doctrines/FoxCase.lean` because it consumes `WaaMismatchGrade` from `FourTruths`. C.8 Doctrines/Correlations.lean, Doctrines/CorrelationsNegative.lean, Doctrines/SuddenGradual*.lean, Doctrines/Fetters.lean, and Doctrines/FettersNegative.lean `Doctrines/Correlations.lean` treats the Ten Bulls, Five Ranks, and stage schemes as checked correlations over existing machinery. `StageScheme` is just `BeingCoarsening`; the warning belongs to holding a coarsening as grid-carried structure, not to any one ladder. `CorrelationsNegative.no_stage_boundary_recovery` duplicates the being-boundary no-recovery pattern for stage schemes so the uniform freeze clause is witnessed without importing `Meta` upward into `Doctrines`. `Doctrines/SuddenGradual.lean` names the §2 sudden/gradual split without new cells. `WaaSuddenArrival` is the actual one-step share-drop to the pole-class, and `waaSuddenArrival_witness` reuses the clock-grid possibility shape. `WaaGradualArrival` folds a `ShareDropRun` through `rePitchRun`, with `waaGradualArrival_witness` on `registerClockGrid`. `rate_invisible_to_config` is exactly `rePitch_forgets`; the run corollaries say config-factoring scores cannot read the earlier rate once the final reception is fixed. `SuddenGradualNegative.subitism_frequency_underdetermined` supplies the honesty clause: response/grade/share data agree while delivery of the pole-reaching weld differs. For the Ten Bulls, Bulls 1-6 are a `ShareDropRun`; Bull 7 is `WaaBullSeven`, probe-constancy plus a live self-pole index. The theorem `bullSeven_not_bullEight` checks that this half-weld is not the empty-circle pole-class. Bull 8 is `AtPoleClass`, Bull 9 is `ResponsiveTerminus`, and Bull 10 is the existential cross-fiber delivery predicate `WaaBullTen`. The stronger `StrongWaaBullTen` is named and shelved: delivery into every sentient fiber is a stronger bodhisattva reading than the picture asserts. The pratyekabuddha countermodel shows Bull 9 without Bull 10. The Five Ranks are data plus reading pins; `kenChuTo_implies_waaBullTen` names the 到/Bull 10 shape under the same coarsening. This is a retype of ranks as utterance-diagnosis and index-placement, not a second stage ladder. `FiberAtPoleOn`, `LiveFiberAtPoleOn`, `FiberAtPoleOnWithin`, and the tag-axis within vocabulary sit in `Signature/BeingConvention.lean` because they are neutral fiber restrictions. The restriction now has two axes: call-class and fine tag-class. `FiberAtPoleOnWithin` is the product, monotone in both coordinates; the old call-axis and the new tag-axis are its total-class specializations. Fetters merely consume them: `FetterReading` supplies the provocation classes as model-side data, `SomaReading` supplies the tag-region with the same diagnosis-time status, and `FetterCutWithin` means the fiber is at pole on that fetter's call-class inside that tag-region. Thus a cut is cessation of enactment in a region, not possession of an anti-fetter. `classQuiet_no_clench_in_class` and `conceit_excluded_within` are the checked soul-guards: where the relevant cut holds, no actual weld in that region carries a live self-pole index. `FettersNegative.no_region_boundary_recovery` is the freedom witness on the tag axis. The path scheme is nested class quietness. `Path.cutClasses` gives the stream, once-return, non-return, and arhat call-classes; once-return adds no new cut class, matching the prose weakening clause. `Fetter.kind_lower_iff_cut_by_nonReturn` pins the table coherence: exactly the lower fetters are cut by non-return. `all_fetters_cut_at_arhatFiber` upgrades the arhat case from samples to `∀ f : Fetter`. `arhatPathQuiet_iff_fiberAtPole` says the arhat class is total, so arhat path-quietness is ordinary `FiberAtPole`. The within-family adds the tag cut. Sravaka-arhat is `PathQuietWithin` at `SomaReading.speechThoughtTag`; the total calls/total tags point is neutral, theorem-identical to ordinary `FiberAtPole` by `arhatWithin_univTags_iff_fiberAtPole`. Vasana remains residual clench enacted in the complement region after the call-axis closes, an existing-cell reading. The buddha reading enters only as a three-rung ladder above that neutral point. Rung 1 is the total-rectangle cut, the share axis alone; the all-stone witness `FettersNegative.total_cut_carries_no_function` shows that it has no function conjunct. Rung 2 is the live terminus reading, `LiveFiberAtPole`, with `sentientTag_iff_actualFiberInhabited` as the bridge from response-function to actual fiber inhabitation. `FettersNegative.total_cut_with_function_not_waaFullyEnlightened` checks that rung 2 still lacks effectiveness. Rung 3 is `WaaFullyEnlightened`, rung 2's quietness plus universal shortfall closure, and it enters the faith and ethics files only as hypothesis. Pratyekabuddha is typed at rung 2 as a regime fact with two faces, not as a second attainment. Face A is uncooperative delivery: a deed is delivered but no share drop lands, so `OrthogonalityNegative.waaFullyEnlightened_stronger_than_terminus` shows failure of `WaaFullyEnlightened`. Face B is sealed delivery: `waaFullyEnlightened_of_responsiveTerminus_of_undelivered` makes full enlightenment hold vacuously when no own deed is delivered at all. The samyaksambuddha reading is rung 3, the faith-object. The guard clause is therefore strict: the model hosts a non-teaching terminus as a regime fact, never as a being who opts out of being read. This is the taxonomy-freeze cell for "the private buddha declining his own occurrence at others' Row 2" read without the freeze: non-teaching is the field declining to deliver, never the being withdrawing object-axis standing. The older arhat anchors remain and have region duals: `identityView_excluded_at_arhatFiber`, `conceit_excluded_at_arhatFiber`, `arhatFiber_of_termini`, `identityView_excluded_at_speechThoughtRegion`, `conceit_excluded_within`, and `regionFiber_of_termini`. Identity-view is the coarsening-freeze enacted: the macro tag held as stored owner. Its cut is quietness on the identity-view provocation class, so stream-entry is typed as the cessation of the same attachment the uniform coarsening clause warns against. `Doctrines/Factors.lean` adds the path-factor reading over that same fetter table. `PathFactor.blockerClass` is derived from `FetterReading`, so the factor scheme is a regrouping of the canonical classes rather than a second taxonomy: rites is the floor component, view covers identity-view and doubt, and resolve covers sensual desire and ill will. `FactorHeld` and `FactorReleased` are a new factor-relation frame. Hold is a witnessed live in-fiber weld in the factor's blocker class; release is the whole-class `FiberAtPoleOn` cut. Hold is not an error by itself, since a stage-appropriate hold is correct. The error taxonomy remains freeze/collapse on utterance distinctions, and clench remains the share-frame live-index vocabulary. The raft simile lands exactly at `factorReleased_rites_iff_ritesGrasp_cut`: rites-grasp is the grasping mode of the first hold, and cutting it is the first release. The bridge reading over the existing cells is deliberately prose-only: freeze is a hold maintained past its use, while collapse is a release enacted before its use. Each stage's characteristic mistakes can therefore be diagnosed as overstayed hold and premature release on that stage's factor. The four hold/release combinations, and the eight once-return-to-non-return gradations they generate when applied across the view and resolve pairs, are diagnosis-time readings over welds and classes, never stored ranks. `WaaResolveAttenuation` gives once-return positive content without adding a cut class: a resolve-class share-drop run can be strict while still stopping short of the pole. `WaaSerialFactorRegime` is the matching "usually in order" conditional; `FactorsNegative.seen_run_underdetermines_factorOrder` blocks deriving that order from the grid alone. One level up, the Theravada-side risk is overstaying the hold on the scheme itself: rank, the shit-stick, the coarsening read as carried structure. The Mahayana-side risk is premature release of diagnosis: the lens-dismissal cell, checked elsewhere as `lens_denial_collapse_self_refuting`. Emptiness is not the absence of the coarsening, but the refusal to hold it as grid-carried. Lineages differ in where the supplied reading puts its weight, not in type signature; `FactorsNegative.lineage_underdetermined_by_seen_run` specializes `CorrelationsNegative.no_stage_boundary_recovery` to that switch. Speech and conduct are named as `PathFactor.speech` and `PathFactor.conduct`, but their blocker classes are `False` in this phase. The open question is what "holding a factor" should mean for the upper pair if an arhat is already at `FiberAtPole`: current `FactorHeld` requires `HasSelfPoleIndex`, and the arhat anchors refute that fiber-wide. This commit therefore leaves `arhatPathQuiet_iff_fiberAtPole`, `all_fetters_cut_at_arhatFiber`, the total arhat class, and `SomaReading.speechThoughtTag` untouched. Irreversibility is three-layered on both axes. Whole-region `FetterCut` and `FetterCutWithin` are internally irreversible by quantifier logic: if a later clenched weld in the relevant rectangle exists, the cut never held. Run-assigned path tags are only display over seen data, and `FettersNegative.seen_run_underdetermines_fetterCut` with `FettersNegative.seen_run_underdetermines_fetterCutWithin` gives the fresh-call transfer countermodel. A forward guarantee is hostable only as the conditionals `waaIrreversibleRegime_conditional` and `waaIrreversibleRegimeWithin_conditional`, parallel in voice to the sraddha conditional. The orthogonality note is checked by `unquiet_region_still_functions_witness`: region cuts speak to share; the uncut region's tags act as fully as the cut region's tags. C.9 Doctrines/OtherPower.lean and Doctrines/OtherPowerNegative.lean Other-power is now a checked delivery-regime correlation rather than a prose appendix to §2. `SameAgentDelivery` and `CrossAgentDelivery` are unprefixed because they are grid-recoverable facts about a delivery line: the line is delivered, and the two agent tags are equal or unequal. `WaaJirikiLine` and `WaaTarikiLine` carry the system-POV reading of those neutral facts. `reception_typing_ignores_sower` is near-definitional: swapping only `conditions` leaves a reception's grade, share, and actuality untouched. `waaReachBack_filled_either_regime` records the one-act-grammar point: once an actual reception is present, either regime supplies the same ordinary reach-back relation by projection from delivery. `TarikiCase` supplies the non-vacuity witness. The name is response-invariant (`name_responseInvariant`), function-mounted rather than stone (`name_not_stone`), and share-zero at its welds (`name_share_bot`). `name_object_axis_entire` delivers the name's weld to every invoker reception, while `universal_fixed_call_lands_without_reading` assembles the corresponding `HasShareDropLanding`. This is the effective corner opposite the zero-effect orthogonality witness: adaptivity and effectiveness are independent. The invoker's side remains an ordinary deed, checked by `invoker_reception_is_deed`. The module deliberately declines polemic. `OtherPowerNegative` gives the two freedom witnesses: `regime_does_not_determine_share` shows that same-agent and cross-agent lines each allow live and pole-class receptions, while `share_does_not_determine_regime` shows that equal reception share does not recover the regime. That is enough for the svakarma demotion: restricting delivery to same-agent lines is a regime wall, not a change in reception typing. C.10 Doctrines/Gradeability.lean `SeveredTranscript` is agent plus response rather than response alone because the strongest natural form of a quotation is still attributed. If even that stronger record cannot recover grade, then the bare response-only case is covered a fortiori. The type deliberately carries no `call`, no `offeredAt`, and no `actual`, so it cannot be fed to `RecordedUtterance.FitsOfferedTier`; there is no positioned utterance for the taxonomy to classify. `Grid.Weld.sever` and `Grid.RecordedUtterance.sever` are forgetting maps. The negative theorem `GradeabilityNegative.no_grade_recovery_from_severed` uses the standard collision pattern: two actual welds with the same severed transcript and different shares force any correct estimator to assign one value two ways. `backslideGrid` supplies the concrete carrier in the missing-call direction: one agent gives the same response to gentle and harsh calls, with different shares. This is named by `GradeabilityNegative.gradeability_severed_underdetermination_witness` and instantiated as `GradeabilityNegative.severed_transcript_ungradeable`. `recordedUtterance_grade_determined` is the positive half as an `rfl` pin: a recorded utterance carries the whole weld, so its grade factors through the record by definition. The koan-form identification, the normative rule "may grade only where the call is carried", the quotable/gradeable genre contrast, and the Hakuin-epigram pedigree flag remain prose. The code checks the underdetermination fact and the carried-call architecture only. C.11 Meta/VerdictLedger.lean `generatorRecord` is the theorem-file verdict history rendered as data, not as a semantic interpretation of the generator. Its entries are episode-grained: Zahavi, the disposition/act cell, the arrow, and the intra-weld arrow are four retypes, so `generatorRecord_retype_count` is a check over the list rather than a stored multiplicity. The `anchors` field records the heterogeneity the paragraph needs: Zahavi and the disposition/act retype are prose-anchored, the arrow pins `DirectionNegative`, the intra-weld arrow pins `InteriorDirectionNegative`, and the answered cases name their theorem anchors. `restraintKind` is the legal coarsening. It projects the nine entries to the six display kinds, while `generatorRecord_restraintKind_seen_count` and `restraintKind_exhaustive_on_record` check the image. The ledger still adds no new-cell entry: `generatorRecord_newCell_count` is zero, so it records the generator's self-restraint independently of the weld-grain row added by the convention-layer schema. `misFeed_entries_carry_decomposition` checks only the structural half of the falsifier: entries tagged as requiring a mis-feed decomposition carry one. The rate-trend clause and the claims that the retypes were forced, timely, and historically prior remain prose, because they quantify over the history rather than over the current record. C.12 Meta/Glossary.lean `Meta/Glossary.lean` is the canonical glossary source. The three markdown glossaries are retired in favor of generated output from `WeldAndArrow/Gen/Glossary.lean`; the paper-facing table lives at `Exposition/Glossary.md`. The module checks office discipline, not exposition itself. `glossary.length` pins the curated table size, the term strings are `Nodup`, every `seeAlso` target resolves to an earlier row, and `#verify_glossary_anchors` checks that all named Lean anchors exist in the environment. Empty anchors are allowed for terms whose public gloss is prose-only. Gloss accuracy, canonical nuance, and the adequacy of each gloss for newcomers remain prose obligations; expert caveats live in the Disclaimers. C.13 Doctrines/Icchantika.lean `Icchantika` is entered as a declined foreclosure case rather than as a stored negative kind. The formal reading is deliberately literal and run-shaped: function is mounted somewhere, and every mounted response is live at the self-pole index. That makes the being non-stone and anti-terminus on its run, so `not_waaFullyEnlightened_of_icchantika` gives the honest agent-role bar: this run cannot seat the icchantika as the enlightened agent, because `WaaFullyEnlightened` includes terminus typing. The receiver-side result points the other way. `aversionContext_of_icchantika_reception` says an actual icchantika reception with live prior tendency supplies the `WaaAversionContext` antecedent, and `icchantika_reachable` routes that antecedent through the existing sraddha conditional. Thus the icchantika is maximally available as receiver exactly where it is unseatable as terminus-agent on the same run. `icchantika_release_not_foreclosed` is the anti-rank check. A concrete icchantika-typed receiver can itself be part of a share-drop landing from a higher prior tendency, so the run's clenched profile does not recover a permanent no-landing verdict. This is the same discipline as backsliding in reverse: attainment is not stored, and neither is non-attainment. The fighting stance is a seed, not a rank. -/ ===== FILE: WeldAndArrow/Identification/Disclaimers.lean ===== /- ================================================================================ WeldAndArrow.Identification.Disclaimers Disclaimer enumeration and number pins ================================================================================ Reading and motivation: Identification/Commentary.lean. -/ import WeldAndArrow.Identification.Registers namespace WAA /- ============================================================================== §5 Disclaimers ============================================================================== -/ /-- The paper-facing disclaimer entries enumerated in the disclaimer list. -/ inductive Disclaimer | tieringSeparateFuse | shoAgencyLent | forMeNessInWeld | receptionReachBack | threeRegisterSorting | linjiReading | shoVersusSatori | genjoArrivals | waaKarmaIdentification | weldTokenReflexivity | mmk17Decomposition | stoneOutsideEdge | generatedTaxonomy | twoErrorGrades | shareDropEvent | theoryStatus | rowTwoIndexPlacement | shareDetermination | dispositionActRetype | passiveSpent | clenchSelfShare | vacuityFromField | memoryPrudence | dukkhaFieldSide | asymmetricDomain | transposition | mirrorTerminus | threeKillings | officesSpine | contemporaryPlacement | hakuinReading | retypeOutcome | svakarmaDemotion | orthogonalityPrice | beingConvention | pilotGeneratedRows | beingTrichotomy | hareHornRegister | modalRealismFreeze | aptnessConditionality | sraddhaConditional | faithBothConjuncts | generatedTableStructure | poleAffirmingSemantics | proseRows | errorFreeReading | misFeedFence | tenBullsTyped | fiveRanksRetype | stageSchemeCoarsening | fetterCutTyping | twoAxisFetterLattice | enlightenmentLadder | ethicsBundledConditionalCode | codeHonestyClauses | verdictRecordData | compoundCellStacks namespace Disclaimer /-- Preserve the paper's numbering without making the number itself carry doctrinal weight. -/ def number : Disclaimer → Nat | .tieringSeparateFuse => 1 | .shoAgencyLent => 2 | .forMeNessInWeld => 3 | .receptionReachBack => 4 | .threeRegisterSorting => 5 | .linjiReading => 6 | .shoVersusSatori => 7 | .genjoArrivals => 8 | .waaKarmaIdentification => 9 | .weldTokenReflexivity => 10 | .mmk17Decomposition => 11 | .stoneOutsideEdge => 12 | .generatedTaxonomy => 13 | .twoErrorGrades => 14 | .shareDropEvent => 15 | .theoryStatus => 16 | .rowTwoIndexPlacement => 17 | .shareDetermination => 18 | .dispositionActRetype => 19 | .passiveSpent => 20 | .clenchSelfShare => 21 | .vacuityFromField => 22 | .memoryPrudence => 23 | .dukkhaFieldSide => 24 | .asymmetricDomain => 25 | .transposition => 26 | .mirrorTerminus => 27 | .threeKillings => 28 | .officesSpine => 29 | .contemporaryPlacement => 30 | .hakuinReading => 31 | .retypeOutcome => 32 | .svakarmaDemotion => 33 | .orthogonalityPrice => 34 | .beingConvention => 35 | .pilotGeneratedRows => 36 | .beingTrichotomy => 37 | .hareHornRegister => 38 | .modalRealismFreeze => 39 | .aptnessConditionality => 40 | .sraddhaConditional => 41 | .faithBothConjuncts => 42 | .generatedTableStructure => 43 | .poleAffirmingSemantics => 44 | .proseRows => 45 | .errorFreeReading => 46 | .misFeedFence => 47 | .tenBullsTyped => 48 | .fiveRanksRetype => 49 | .stageSchemeCoarsening => 50 | .fetterCutTyping => 51 | .twoAxisFetterLattice => 52 | .enlightenmentLadder => 53 | .ethicsBundledConditionalCode => 54 | .codeHonestyClauses => 55 | .verdictRecordData => 56 | .compoundCellStacks => 57 theorem waaKarmaIdentification_number : number Disclaimer.waaKarmaIdentification = 9 := rfl theorem mmk17Decomposition_number : number Disclaimer.mmk17Decomposition = 11 := rfl theorem modalRealismFreeze_number : number Disclaimer.modalRealismFreeze = 39 := rfl theorem aptnessConditionality_number : number Disclaimer.aptnessConditionality = 40 := rfl theorem sraddhaConditional_number : number Disclaimer.sraddhaConditional = 41 := rfl theorem faithBothConjuncts_number : number Disclaimer.faithBothConjuncts = 42 := rfl theorem generatedTableStructure_number : number Disclaimer.generatedTableStructure = 43 := rfl theorem poleAffirmingSemantics_number : number Disclaimer.poleAffirmingSemantics = 44 := rfl theorem proseRows_number : number Disclaimer.proseRows = 45 := rfl theorem errorFreeReading_number : number Disclaimer.errorFreeReading = 46 := rfl theorem misFeedFence_number : number Disclaimer.misFeedFence = 47 := rfl theorem tenBullsTyped_number : number Disclaimer.tenBullsTyped = 48 := rfl theorem fiveRanksRetype_number : number Disclaimer.fiveRanksRetype = 49 := rfl theorem stageSchemeCoarsening_number : number Disclaimer.stageSchemeCoarsening = 50 := rfl theorem fetterCutTyping_number : number Disclaimer.fetterCutTyping = 51 := rfl theorem twoAxisFetterLattice_number : number Disclaimer.twoAxisFetterLattice = 52 := rfl theorem enlightenmentLadder_number : number Disclaimer.enlightenmentLadder = 53 := rfl theorem ethicsBundledConditionalCode_number : number Disclaimer.ethicsBundledConditionalCode = 54 := rfl theorem codeHonestyClauses_number : number Disclaimer.codeHonestyClauses = 55 := rfl theorem verdictRecordData_number : number Disclaimer.verdictRecordData = 56 := rfl theorem compoundCellStacks_number : number Disclaimer.compoundCellStacks = 57 := rfl end Disclaimer end WAA ===== FILE: WeldAndArrow/Identification/Ownership.lean ===== /- ================================================================================ WeldAndArrow.Identification.Ownership Ownership faces, token-reflexivity, pole typing, and offices ================================================================================ Reading and motivation: Identification/Commentary.lean, C.2. -/ import WeldAndArrow.Identification.Residues namespace WAA namespace Grid variable {Contrib : Type} [PreorderBot Contrib] variable (G : Grid Contrib) /- ============================================================================== §2 Sower/reaper, reach-back, and WAA-ownership-face ============================================================================== -/ namespace DirectedConvention /-- The field-side report-face of "the sower reaps": the delivery line, before any act-time ownership is added. -/ def WaaReportFace (deed reception : G.Weld) : Prop := DeliveredTo G deed reception /-- The full WAA-ownership-face: delivery reaches an actual reception and that reception WAA-appropriates. It is a deed at reception-time, not a standing relation. -/ def WaaOwnershipFace (deed reception : G.Weld) : Prop := LandsAt G deed reception ∧ G.WaaAppropriates reception /-- The source's vacuous reach-back ("an appropriating with nothing arrived to appropriate — not a falsehood ... but vacuous"): an actual, appropriating reception whose claimed deed never delivered to it. The vacuity is a property of this three-conjunct face; bare non-delivery alone is `NotDeliveredTo` and carries no appropriation. -/ def WaaVacuousOwnershipFace (deed reception : G.Weld) : Prop := NotDeliveredTo G deed reception ∧ G.Actual reception ∧ G.WaaAppropriates reception /-- The WAA-ownership-face includes the report-face. -/ theorem waaReportFace_of_waaOwnershipFace {deed reception : G.Weld} (h : WaaOwnershipFace G deed reception) : WaaReportFace G deed reception := h.left.left /-- The WAA-ownership-face includes actual reception. -/ theorem actual_of_waaOwnershipFace {deed reception : G.Weld} (h : WaaOwnershipFace G deed reception) : G.Actual reception := h.left.right /-- The WAA-ownership-face includes WAA-appropriation at reception-time. -/ theorem waaAppropriates_of_waaOwnershipFace {deed reception : G.Weld} (h : WaaOwnershipFace G deed reception) : G.WaaAppropriates reception := h.right /-- Full landing plus WAA-appropriation introduces the WAA-ownership-face. -/ theorem waaOwnershipFace_intro {deed reception : G.Weld} (hland : LandsAt G deed reception) (happ : G.WaaAppropriates reception) : WaaOwnershipFace G deed reception := ⟨hland, happ⟩ /-- Bare non-delivery cannot at the same time be a full WAA-ownership-face for that deed and reception. -/ theorem not_waaOwnershipFace_of_vacuous {deed reception : G.Weld} (hv : NotDeliveredTo G deed reception) : ¬ WaaOwnershipFace G deed reception := fun hown => hv hown.left.left /-- A vacuous WAA-ownership attempt is not a full WAA-ownership-face. -/ theorem not_waaOwnershipFace_of_waaVacuousOwnershipFace {deed reception : G.Weld} (hv : WaaVacuousOwnershipFace G deed reception) : ¬ WaaOwnershipFace G deed reception := not_waaOwnershipFace_of_vacuous G hv.left /-- The diachronic whose-question decomposes into delivery plus fresh WAA-appropriation; no third cross-gap owner is part of this definition. -/ def WaaDiachronicWhose (deed reception : G.Weld) : Prop := DeliveredTo G deed reception ∧ G.WaaAppropriates reception theorem waaDiachronicWhose_iff_delivery_and_waaAppropriates (deed reception : G.Weld) : WaaDiachronicWhose G deed reception ↔ DeliveredTo G deed reception ∧ G.WaaAppropriates reception := Iff.rfl /-- Delivery alone never settles the diachronic whose-question; the fresh reception-time appropriation conjunct is still required. -/ theorem no_diachronicWhose_from_series_alone {deed reception : G.Weld} (hno : ¬ G.WaaAppropriates reception) : ¬ WaaDiachronicWhose G deed reception := by intro hwhose exact hno ((waaDiachronicWhose_iff_delivery_and_waaAppropriates G deed reception).mp hwhose).right /- ============================================================================== §2 Memory witness ============================================================================== -/ namespace MemoryWitness /-- The trace-source deed in the checked recall witness. It deliberately repeats the prudence witness's concrete registers under fresh names: memory and prudence share the same display grid without coupling their namespaces. -/ def pastDeed : registerClockGrid.Weld := ⟨(1 : Nat), (), (2 : Nat)⟩ /-- The later reception at which the trace is received and appropriated. -/ def recall : registerClockGrid.Weld := ⟨(2 : Nat), (), (3 : Nat)⟩ /-- A claimed deed whose delivery line does not reach `recall`. -/ def confabulatedDeed : registerClockGrid.Weld := ⟨(0 : Nat), (), (1 : Nat)⟩ /-- The trace-source deed is delivered to the later recall reception. -/ theorem trace_delivered : DeliveredTo registerClockGrid pastDeed recall := rfl theorem recall_waaAppropriates : registerClockGrid.WaaAppropriates recall := by dsimp [Grid.WaaAppropriates, Grid.HasSelfPoleIndex, Grid.share, registerClockGrid, recall, AtBot, shareBot] change ¬ (2 : Nat) ≤ 0 exact Nat.not_succ_le_zero 1 /-- Genuine recall has the full ownership face: the trace lands at an actual later reception, and that reception freshly appropriates. -/ theorem recall_waaOwnershipFace : WaaOwnershipFace registerClockGrid pastDeed recall := ⟨⟨trace_delivered, rfl⟩, recall_waaAppropriates⟩ /-- The diachronic whose-question for recall is delivery plus fresh reception-time appropriation. -/ theorem recall_waaDiachronicWhose : WaaDiachronicWhose registerClockGrid pastDeed recall := ⟨trace_delivered, recall_waaAppropriates⟩ /-- The confabulated deed is not delivered to the recall reception. -/ theorem confabulated_not_delivered : NotDeliveredTo registerClockGrid confabulatedDeed recall := by dsimp [NotDeliveredTo, registerClockGrid, confabulatedDeed, recall] decide /-- False memory has the vacuous ownership face: the reception is actual and appropriating, but the claimed deed did not arrive there. -/ theorem falseMemory_waaVacuousOwnershipFace : WaaVacuousOwnershipFace registerClockGrid confabulatedDeed recall := ⟨confabulated_not_delivered, ⟨rfl, recall_waaAppropriates⟩⟩ /-- The appropriating conjunct projected from the full recall face. -/ theorem fullFace_recall_waaAppropriates : registerClockGrid.WaaAppropriates recall := waaAppropriates_of_waaOwnershipFace registerClockGrid recall_waaOwnershipFace /-- The appropriating conjunct projected from the vacuous false-memory face. -/ theorem vacuousFace_recall_waaAppropriates : registerClockGrid.WaaAppropriates recall := falseMemory_waaVacuousOwnershipFace.right.right /-- Full recall and false memory share the same reception-side appropriation mark; the contrast is only whether delivery filled the second place. -/ theorem vacuity_not_inner_mark : registerClockGrid.WaaAppropriates recall ∧ registerClockGrid.WaaAppropriates recall ∧ ¬ WaaOwnershipFace registerClockGrid confabulatedDeed recall := ⟨fullFace_recall_waaAppropriates, vacuousFace_recall_waaAppropriates, not_waaOwnershipFace_of_waaVacuousOwnershipFace registerClockGrid falseMemory_waaVacuousOwnershipFace⟩ /-- Re-pitching into recall forgets every prior configuration: the mineness is made and spent at the recall weld, not stored in the trace. -/ theorem recall_spent (before1 before2 : Config Nat) : registerClockGrid.rePitch before1 recall = registerClockGrid.rePitch before2 recall := registerClockGrid.rePitch_forgets before1 before2 recall /-- The checked memory package: full recall, vacuous false memory, and recall-time spentness in one register-clock display. -/ theorem memory_witness : WaaOwnershipFace registerClockGrid pastDeed recall ∧ WaaVacuousOwnershipFace registerClockGrid confabulatedDeed recall ∧ (∀ before1 before2 : Config Nat, registerClockGrid.rePitch before1 recall = registerClockGrid.rePitch before2 recall) := ⟨recall_waaOwnershipFace, falseMemory_waaVacuousOwnershipFace, recall_spent⟩ end MemoryWitness /- ============================================================================== §2 Prudential privilege negative ============================================================================== -/ namespace PrudentialPrivilegeNegative open BeingConvention /-- The present-side fine register. -/ def deedAgent : Nat := 1 /-- The future-side fine register. -/ def receptionAgent : Nat := 2 /-- The future reception's mounted response. -/ def receptionResponse : Nat := 3 /-- The present concern/deed register in the checked prudence witness. -/ def deed : registerClockGrid.Weld := ⟨deedAgent, (), receptionAgent⟩ /-- The future reception register delivered by `deed`. -/ def reception : registerClockGrid.Weld := ⟨receptionAgent, (), receptionResponse⟩ /-- The concrete actual pair used to route the witness through the same `ReceptionPair` carrier as the diachronic ownership vocabulary. -/ def pair : ReceptionPair registerClockGrid where first := { weld := deed, actual := rfl } second := { weld := reception, actual := rfl } theorem pair_firstConditionsSecond : pair.FirstConditionsSecond := by rfl theorem deed_waaAppropriates : registerClockGrid.WaaAppropriates deed := by dsimp [Grid.WaaAppropriates, Grid.HasSelfPoleIndex, Grid.share, registerClockGrid, deed, AtBot, shareBot] change ¬ (1 : Nat) ≤ 0 exact Nat.not_succ_le_zero 0 theorem reception_waaAppropriates : registerClockGrid.WaaAppropriates reception := by dsimp [Grid.WaaAppropriates, Grid.HasSelfPoleIndex, Grid.share, registerClockGrid, reception, AtBot, shareBot] change ¬ (2 : Nat) ≤ 0 exact Nat.not_succ_le_zero 1 /-- Ordinary diachronic ownership can be made at reception-time in the witness: delivery plus fresh WAA-appropriation. -/ theorem reception_waaDiachronicWhose : WaaDiachronicWhose registerClockGrid deed reception := ⟨rfl, reception_waaAppropriates⟩ /-- The same pair also gives the full WAA-ownership face. -/ theorem reception_waaOwnershipFace : WaaOwnershipFace registerClockGrid deed reception := ⟨⟨rfl, rfl⟩, reception_waaAppropriates⟩ /-- Merge reading: every fine register belongs to one macro tag. -/ abbrev kMerge : BeingCoarsening registerClockGrid Unit := registerClockCoarsening /-- Split reading: each fine register keeps its own macro tag. -/ def kSplit : BeingCoarsening registerClockGrid Nat where proj := id theorem merge_same_fiber : kMerge.SameFiber deedAgent receptionAgent := rfl /-- Pairwise boundary induced by the merge reading. -/ abbrev mergeBoundary (_p _q : Nat) : Prop := True /-- Pairwise boundary induced by the split reading. -/ abbrev splitBoundary (p q : Nat) : Prop := p = q theorem merge_boundary_holds : mergeBoundary deedAgent receptionAgent := True.intro theorem split_boundary_fails : ¬ ((1 : Nat) = (2 : Nat)) := by decide /-- The grid data visible to a convention-free standing-owner recovery. -/ abbrev W : Type := RawWeld Nat Unit Nat /-- Function, grade, and delivery data, with no supplied being-convention. -/ abbrev GridData : Type := (Nat -> Unit -> Option Nat) × (Nat -> Unit -> Nat -> Nat) × (W -> W -> Prop) def gridData : GridData := (registerClockGrid.respondsTo, registerClockGrid.grade, registerClockGrid.conditions) /-- A standing cross-gap "mine" relation over the witness grid. -/ abbrev StandingMine : Type := registerClockGrid.Weld -> registerClockGrid.Weld -> Prop /-- Agreement with the merge convention at the prudential pair. -/ def AgreesWithMergeAt (mine : StandingMine) : Prop := mine deed reception ↔ mergeBoundary deedAgent receptionAgent /-- Agreement with the split convention at the same prudential pair. -/ def AgreesWithSplitAt (mine : StandingMine) : Prop := mine deed reception ↔ splitBoundary deedAgent receptionAgent /-- Prudential privilege, as a checked recovery claim: from the grid data alone, recover a standing cross-gap "mine" relation that settles the pair before any supplied being-convention. Such a relation would have to agree with both legal readings of the same grid data. -/ def PrudentialPrivilege : Prop := ∃ recover : GridData -> StandingMine, AgreesWithMergeAt (recover gridData) ∧ AgreesWithSplitAt (recover gridData) /-- The prudential privilege recovery claim fails in the register-clock witness: the merge and split being-conventions are both legal, but they disagree on whether the present deed-register and the future reception-register share a fiber. -/ theorem not_prudentialPrivilege : ¬ PrudentialPrivilege := by rintro ⟨recover, hmerge, hsplit⟩ have hmine : recover gridData deed reception := hmerge.mpr merge_boundary_holds have hnotMine : ¬ recover gridData deed reception := by intro h exact split_boundary_fails (hsplit.mp h) exact hnotMine hmine /-- Re-pitching the actual pair leaves the final configuration reading only the received future weld's share. The prior tendency is not an inheritance register for the deed-side owner. -/ theorem rePitchSequence_final_forgets_prior (before1 before2 : Config Nat) : (ReceptionPair.rePitchSequence (G := registerClockGrid) before1 pair).snd = (ReceptionPair.rePitchSequence (G := registerClockGrid) before2 pair).snd := registerClockGrid.rePitch_forgets (registerClockGrid.rePitch before1 pair.first.weld) (registerClockGrid.rePitch before2 pair.first.weld) pair.second.weld /-- The final tendency of the pair is just the future reception's share. -/ theorem rePitchSequence_final_tendency (before : Config Nat) : (ReceptionPair.rePitchSequence (G := registerClockGrid) before pair).snd.tendency = registerClockGrid.share reception := rfl /-- The grade side of the witness does not inspect downstream delivery conditions. -/ theorem deed_grade_independent_of_conditions (conditions1 conditions2 : registerClockGrid.Weld -> registerClockGrid.Weld -> Prop) : (registerClockGrid.withConditions conditions1).grade deed.agent deed.call deed.response = (registerClockGrid.withConditions conditions2).grade deed.agent deed.call deed.response := registerClockGrid.grade_independent_of_conditions conditions1 conditions2 deed.agent deed.call deed.response /-- The checked prudence package: fresh reception-time ownership is available, but standing grid-data privilege, stored inheritance, and delivery-sensitive grading are not. -/ theorem prudentialPrivilege_failure_modes : WaaDiachronicWhose registerClockGrid deed reception ∧ ¬ PrudentialPrivilege ∧ (∀ before1 before2 : Config Nat, (ReceptionPair.rePitchSequence (G := registerClockGrid) before1 pair).snd = (ReceptionPair.rePitchSequence (G := registerClockGrid) before2 pair).snd) ∧ (∀ conditions1 conditions2 : registerClockGrid.Weld -> registerClockGrid.Weld -> Prop, (registerClockGrid.withConditions conditions1).grade deed.agent deed.call deed.response = (registerClockGrid.withConditions conditions2).grade deed.agent deed.call deed.response) := ⟨reception_waaDiachronicWhose, not_prudentialPrivilege, rePitchSequence_final_forgets_prior, deed_grade_independent_of_conditions⟩ end PrudentialPrivilegeNegative end DirectedConvention /- ============================================================================== §2 Token-reflexivity ============================================================================== -/ /-- Token-reflexivity as a projection identity. Deliberately a `def` that can never fail (`selfAnchored` proves it for every weld): the content is the identity's *shape* — no route to "this act's agent" except through the completed weld — displayed, not risked. -/ def SelfAnchored (w : G.Weld) : Prop := G.index w = w.agent theorem selfAnchored (w : G.Weld) : G.SelfAnchored w := rfl /- ============================================================================== §3 Pole-typing and the verdict's own tier ============================================================================== -/ /-- The state-tool fits exactly when no live self-pole index remains. -/ def StateToolFits (w : G.Weld) : Prop := ¬ G.HasSelfPoleIndex w /-- The pole-class is the constructive direction of the pole-typing corollary: no self-pole index remains for a state-tool to miss. -/ theorem stateToolFits_of_atBot {w : G.Weld} (hshare : AtBot (G.share w)) : G.StateToolFits w := G.no_self_pole_index_of_atBot w hshare /-- Literal equality with the designated bottom is a bridge into the pole-class pole-typing corollary. -/ theorem stateToolFits_of_eq_shareBot {w : G.Weld} (hshare : G.share w = shareBot) : G.StateToolFits w := G.stateToolFits_of_atBot (atBot_of_eq_shareBot hshare) /-- With decidability of the one pole-class comparison, pole-typing can be read as an iff: the state-tool fits just where the share is at the pole-class. -/ theorem atBot_of_stateToolFits {w : G.Weld} [Decidable (AtBot (G.share w))] (hfits : G.StateToolFits w) : AtBot (G.share w) := by by_cases hshare : AtBot (G.share w) · exact hshare · exact False.elim (hfits hshare) /-- With decidability of the one pole-class comparison, pole-typing is an exact iff. -/ theorem stateToolFits_iff_atBot (w : G.Weld) [Decidable (AtBot (G.share w))] : G.StateToolFits w ↔ AtBot (G.share w) := ⟨G.atBot_of_stateToolFits, G.stateToolFits_of_atBot⟩ /-- Terminus responses are reducible in the corollary's sense. -/ theorem stateToolFits_of_terminus_response {b : G.Being} {c : G.Call} {r : G.Response} (hterm : G.Terminus b) (hresp : G.respondsTo b c = some r) : G.StateToolFits ⟨b, c, r⟩ := G.no_self_pole_index_of_terminus_response hterm hresp namespace DirectedConvention /-- If the state-tool fits a reception, the WAA-ownership-face cannot fire there. -/ theorem not_waaOwnershipFace_of_stateToolFits {deed reception : G.Weld} (hfits : G.StateToolFits reception) : ¬ WaaOwnershipFace G deed reception := fun hown => hfits hown.right end DirectedConvention -- The paper's "a mis-feed at the floor is not a claim" verdict is carried -- by `not_collapse_floor`; no separate theorem restates it. /-- A distinction obeying the separate/fuse rule fuses at the floor. -/ theorem obeysRule_fuses_at_floor {d : Distinction G} (h : d.ObeysSeparateFuse) : d.Fused (Tier.floor : Tier G) := G.fused_of_obeysSeparateFuse h Tier.floor /-- The same distinction separates at live act-time diagnosis. -/ theorem obeysRule_separates_at_actTime {d : Distinction G} (h : d.ObeysSeparateFuse) {w : G.Weld} (hidx : G.HasSelfPoleIndex w) : d.Separated (Tier.actTime w) := G.separated_of_obeysSeparateFuse h hidx /- ============================================================================== §4 The office-spine and contemporary placements ============================================================================== -/ end Grid /-- The WAA-offices karmic ownership holds in the paper's identity-claim. -/ inductive WaaOwnershipOffice | cetana | reception | practice | remorse | absolution | dedication namespace WaaOwnershipOffice variable {Contrib : Type} [PreorderBot Contrib] {G : Grid Contrib} /-- Each office is assigned to a weld's act-time tier (the office argument is unused). The paper's further claim — discharged *not by a cross-gap state* — is architectural, carried by what `Config` does not contain and by the absence of any `Config`-consuming assignment function; it is not this definition's proposition. -/ def assignedTier (_office : WaaOwnershipOffice) (w : G.Weld) : Grid.Tier G := Grid.Tier.actTime w theorem assignedTier_eq_actTime (office : WaaOwnershipOffice) (w : G.Weld) : office.assignedTier w = Grid.Tier.actTime w := rfl /-- Assigning an office to act-time has exactly the weld's live-share condition. -/ theorem assignedTier_hasLiveShare_iff (office : WaaOwnershipOffice) (w : G.Weld) : Grid.Tier.hasLiveShare G (office.assignedTier w) ↔ G.HasSelfPoleIndex w := Iff.rfl end WaaOwnershipOffice /- Reading and motivation: Identification/Commentary.lean, C.1. -/ namespace SelfLineWitness inductive Being | one inductive Call | call inductive Response | response def selfLineGrid : Grid Nat where Being := Being Call := Call Response := Response respondsTo _ _ := some Response.response grade _ _ _ := 1 conditions _ _ := True def w : selfLineGrid.Weld := ⟨Being.one, Call.call, Response.response⟩ theorem w_waaAppropriates : selfLineGrid.WaaAppropriates w := by intro hbot cases hbot theorem selfLine_conditions_self : selfLineGrid.conditions w w := True.intro theorem selfLine_landsAt_self : Grid.DirectedConvention.LandsAt selfLineGrid w w := ⟨True.intro, rfl⟩ theorem selfLine_waaOwnershipFace_self : Grid.DirectedConvention.WaaOwnershipFace selfLineGrid w w := ⟨⟨True.intro, rfl⟩, w_waaAppropriates⟩ end SelfLineWitness end WAA ===== FILE: WeldAndArrow/Identification/Placements.lean ===== /- ================================================================================ WeldAndArrow.Identification.Placements Contemporary placements ================================================================================ Reading and motivation: Identification/Commentary.lean. -/ import WeldAndArrow.Identification.Ownership namespace WAA /-- Contemporary positions placed by `Exposition/Identification.md`. -/ inductive ContemporaryPosition | siderits | ganeri | zahavi | sartre /-- Their grid placement. -/ inductive ContemporaryPlacement | seriesQuestions | nearestAlly | retype | occupant namespace ContemporaryPosition /-- The grid placement assigned to each contemporary position in the paper. -/ def waaPlacement : ContemporaryPosition → ContemporaryPlacement | .siderits => .seriesQuestions | .ganeri => .nearestAlly | .zahavi => .retype | .sartre => .occupant theorem siderits_waaPlacement : waaPlacement ContemporaryPosition.siderits = ContemporaryPlacement.seriesQuestions := rfl theorem ganeri_waaPlacement : waaPlacement ContemporaryPosition.ganeri = ContemporaryPlacement.nearestAlly := rfl theorem zahavi_waaPlacement : waaPlacement ContemporaryPosition.zahavi = ContemporaryPlacement.retype := rfl theorem sartre_waaPlacement : waaPlacement ContemporaryPosition.sartre = ContemporaryPlacement.occupant := rfl end ContemporaryPosition namespace Grid variable {Contrib : Type} [PreorderBot Contrib] variable (G : Grid Contrib) /- Encoding check: the `retype` constructor exists and applies to any pair of distinctions (used by the Zahavi placement and the disposition/act redrawing). An `example`, not a theorem, for the same reason the voice and placement checks are. -/ theorem retype_constructor_exists (oldDistinction newDistinction : Distinction G) : ∃ out : GeneratorOutcome G, out = GeneratorOutcome.retype oldDistinction newDistinction := ⟨GeneratorOutcome.retype oldDistinction newDistinction, rfl⟩ end Grid end WAA ===== FILE: WeldAndArrow/Identification/Registers.lean ===== /- ================================================================================ WeldAndArrow.Identification.Registers Disclaimer 5 register sorting ================================================================================ Reading and motivation: Identification/Commentary.lean, C.1. -/ import WeldAndArrow.Identification.Placements namespace WAA /- ============================================================================== §5 Register sorting ============================================================================== -/ /-- The three registers of disclaimer 5's fact-sorting: a sorting of registers, not of kinds of fact. -/ inductive Register | field | weld | stated /-- The paper's table instances, as inspectable data. -/ inductive SortedFact | causalSeries | delivery | seed | arrogationTendency | agentIndex | forMeNess | receptionReachBack | rowTwoPlacement namespace SortedFact /-- The register assigned to each sorted fact in disclaimer 5. -/ def register : SortedFact → Register | .causalSeries => .field | .delivery => .field | .seed => .field | .arrogationTendency => .field | .agentIndex => .weld | .forMeNess => .weld | .receptionReachBack => .weld | .rowTwoPlacement => .stated theorem causalSeries_register : register SortedFact.causalSeries = Register.field := rfl theorem delivery_register : register SortedFact.delivery = Register.field := rfl theorem seed_register : register SortedFact.seed = Register.field := rfl theorem arrogationTendency_register : register SortedFact.arrogationTendency = Register.field := rfl theorem agentIndex_register : register SortedFact.agentIndex = Register.weld := rfl theorem forMeNess_register : register SortedFact.forMeNess = Register.weld := rfl theorem receptionReachBack_register : register SortedFact.receptionReachBack = Register.weld := rfl theorem rowTwoPlacement_register : register SortedFact.rowTwoPlacement = Register.stated := rfl /-- Which sorted facts carry a self-index. -/ def selfIndexed : SortedFact → Bool | .agentIndex | .forMeNess | .receptionReachBack => true | _ => false /-- Only the field register is carried between deeds. -/ def carried : Register → Bool | .field => true | _ => false /-- Disclaimer 5's refined premise: nothing self-indexed is stored. The type-level enforcement is architectural (`Config` has no owner field); this is the paper-facing enumeration of the same claim. -/ theorem nothing_selfIndexed_carried : ∀ f : SortedFact, selfIndexed f = true → carried f.register = false := by intro f h cases f <;> simp [selfIndexed, carried, register] at h ⊢ end SortedFact end WAA ===== FILE: WeldAndArrow/Identification/Residues.lean ===== /- ================================================================================ WeldAndArrow.Identification.Residues Field residues and index recovery ================================================================================ Reading and motivation: Identification/Commentary.lean, C.0-C.1. -/ import WeldAndArrow.Consequences.Basic namespace WAA /- ============================================================================== §0 Field residues and index recovery ============================================================================== -/ namespace Grid variable {Contrib : Type} [PreorderBot Contrib] variable (G : Grid Contrib) /-- A field residue: the call and response left when the agent-index is not part of the data. -/ abbrev FieldFact : Type := G.Call × G.Response /-- A field-only recovery candidate tries to recover an agent-index from field residues alone. -/ abbrev FieldRecovery : Type := G.FieldFact → G.Being /-- Correctness for a field-only recovery candidate: for every actual weld, it must recover the very index projected from that weld. -/ def CorrectFieldRecovery (recover : G.FieldRecovery) : Prop := ∀ w : G.Weld, G.Actual w → recover (G.fieldOf w) = G.index w /-- A correct field-only recovery cannot distinguish two actual welds with the same field residue; it must assign them the same index. -/ theorem correctFieldRecovery_forces_same_index_of_same_field {recover : G.FieldRecovery} (hrec : G.CorrectFieldRecovery recover) {w₁ w₂ : G.Weld} (h₁ : G.Actual w₁) (h₂ : G.Actual w₂) (hfield : G.fieldOf w₁ = G.fieldOf w₂) : G.index w₁ = G.index w₂ := calc G.index w₁ = recover (G.fieldOf w₁) := (hrec w₁ h₁).symm _ = recover (G.fieldOf w₂) := congrArg recover hfield _ = G.index w₂ := hrec w₂ h₂ /-- If two actual welds share the field residue but differ in index, no field-only recovery can be correct. This is the modest internal fact that field residues under-determine the agent-index. -/ theorem no_agent_recovery_from_same_field_distinct_index {w₁ w₂ : G.Weld} (h₁ : G.Actual w₁) (h₂ : G.Actual w₂) (hfield : G.fieldOf w₁ = G.fieldOf w₂) (hne : G.index w₁ ≠ G.index w₂) : ¬ ∃ recover : G.FieldRecovery, G.CorrectFieldRecovery recover := fun ⟨_recover, hrec⟩ => hne (G.correctFieldRecovery_forces_same_index_of_same_field hrec h₁ h₂ hfield) /-- The concrete same-call/same-response witness used in the prose: two different beings can actually answer the same call with the same response, and the field residue cannot say which one acted. -/ theorem no_agent_recovery_from_same_call_response (a₁ a₂ : G.Being) (c : G.Call) (r : G.Response) (h₁ : G.Actual ⟨a₁, c, r⟩) (h₂ : G.Actual ⟨a₂, c, r⟩) (hne : a₁ ≠ a₂) : ¬ ∃ recover : G.FieldRecovery, G.CorrectFieldRecovery recover := G.no_agent_recovery_from_same_field_distinct_index h₁ h₂ rfl hne end Grid /- ============================================================================== Mis-feed negative: the avyākata fence and delivery gate ============================================================================== -/ namespace MisFeedNegative variable {Contrib : Type} [PreorderBot Contrib] /-- The index-seeking question-form, modeled as its universe of candidate answers: one purported self-pole index for each field residue. -/ abbrev IndexSeekingForm (G : Grid Contrib) : Type := G.FieldFact → G.Being /-- Success for the form: correctness at every actual weld. -/ def AnswersCorrectly (G : Grid Contrib) (ans : IndexSeekingForm G) : Prop := ∀ w : G.Weld, G.Actual w → ans (G.fieldOf w) = G.index w /-- A field collision: two actual welds with the same residue and distinct agents. -/ structure FieldCollision (G : Grid Contrib) where w1 : G.Weld w2 : G.Weld actual1 : G.Actual w1 actual2 : G.Actual w2 same_field : G.fieldOf w1 = G.fieldOf w2 distinct_agent : w1.agent ≠ w2.agent /-- No answer-function for the index-seeking form is correct under a field collision. The negation encloses the whole universe of candidate answers, so the obstruction belongs to the question-shape, not to one bad answer. -/ theorem no_indexSeeking_success_of_collision {G : Grid Contrib} (c : FieldCollision G) : ¬ ∃ ans : IndexSeekingForm G, AnswersCorrectly G ans := by rintro ⟨ans, hans⟩ have hsame : G.index c.w1 = G.index c.w2 := by calc G.index c.w1 = ans (G.fieldOf c.w1) := (hans c.w1 c.actual1).symm _ = ans (G.fieldOf c.w2) := congrArg ans c.same_field _ = G.index c.w2 := hans c.w2 c.actual2 exact c.distinct_agent (by simpa [Grid.index] using hsame) /-- Claim-level face of the same obstruction: one field residue has two actual-backed, distinct index claims. -/ theorem indexClaim_not_functional_of_collision {G : Grid Contrib} (c : FieldCollision G) : ∃ f : G.FieldFact, ∃ b1 b2 : G.Being, b1 ≠ b2 ∧ (∃ w : G.Weld, G.Actual w ∧ G.fieldOf w = f ∧ w.agent = b1) ∧ (∃ w : G.Weld, G.Actual w ∧ G.fieldOf w = f ∧ w.agent = b2) := ⟨G.fieldOf c.w1, c.w1.agent, c.w2.agent, c.distinct_agent, ⟨c.w1, c.actual1, rfl, rfl⟩, ⟨c.w2, c.actual2, c.same_field.symm, rfl⟩⟩ /-- Two beings, one call, one response: both actual welds have the same field residue. -/ inductive CollisionBeing | left | right deriving DecidableEq /-- A concrete grid witnessing a field collision while keeping delivery answerable in the same model. -/ def collisionGrid : Grid Nat where Being := CollisionBeing Call := Unit Response := Unit respondsTo _ _ := some () grade _ _ _ := 0 conditions _ _ := True def wLeft : collisionGrid.Weld := ⟨CollisionBeing.left, (), ()⟩ def wRight : collisionGrid.Weld := ⟨CollisionBeing.right, (), ()⟩ /-- The fence's hypothesis, witnessed concretely. -/ def collisionGrid_fieldCollision : FieldCollision collisionGrid where w1 := wLeft w2 := wRight actual1 := rfl actual2 := rfl same_field := rfl distinct_agent := by intro h cases h /-- The fence fired at the concrete witness. -/ theorem collisionGrid_no_indexSeeking_success : ¬ ∃ ans : IndexSeekingForm collisionGrid, AnswersCorrectly collisionGrid ans := no_indexSeeking_success_of_collision collisionGrid_fieldCollision /-- The delivery-typed twin question-form in the concrete model. -/ abbrev DeliveryForm : Type := collisionGrid.Weld → collisionGrid.Weld → Bool /-- Success for the delivery twin: agreement with `conditions` in the witness grid. -/ def DeliveryAnswersCorrectly (ans : DeliveryForm) : Prop := ∀ deed reception, ans deed reception = true ↔ collisionGrid.conditions deed reception /-- A checked delivery answer for the concrete model. -/ def deliveryTwinAnswer : DeliveryForm := fun _ _ => true /-- The delivery twin is answered in the same model. This is model-local: it shows the index fence does not enclose delivery-typed questions. -/ theorem deliveryTwinAnswers : DeliveryAnswersCorrectly deliveryTwinAnswer := by intro deed reception dsimp [DeliveryAnswersCorrectly, deliveryTwinAnswer, collisionGrid] exact ⟨fun _ => True.intro, fun _ => rfl⟩ /-- Fence and gate together in the same concrete model. -/ theorem fence_and_gate : (¬ ∃ ans : IndexSeekingForm collisionGrid, AnswersCorrectly collisionGrid ans) ∧ (∃ ans : DeliveryForm, DeliveryAnswersCorrectly ans) := ⟨collisionGrid_no_indexSeeking_success, ⟨deliveryTwinAnswer, deliveryTwinAnswers⟩⟩ end MisFeedNegative end WAA ===== FILE: WeldAndArrow/Meta.lean ===== import WeldAndArrow.Meta.Nishitani import WeldAndArrow.Meta.ReflexivityWitness import WeldAndArrow.Meta.Invariance import WeldAndArrow.Meta.InvarianceNegative import WeldAndArrow.Meta.VerdictLedger import WeldAndArrow.Meta.Glossary import WeldAndArrow.Meta.Audit ===== FILE: WeldAndArrow/Meta/AssumptionLedger.lean ===== /- ================================================================================ WeldAndArrow.Meta.AssumptionLedger Canonical assumption prose, checked anchors, and structural checks ================================================================================ The Signature layer keeps the compile-time tripwire for input-side declarations. This ledger is the canonical source for the reader-facing assumption prose and for the checked anchor metadata rendered to `Exposition/Assumptions.md`. -/ import Lean import WeldAndArrow.Signature.Assumptions import WeldAndArrow.Meta.InvarianceNegative import WeldAndArrow.Identification.Ownership import WeldAndArrow.Doctrines.FourTruths namespace WAA /- ============================================================================== Ledger data ============================================================================== -/ inductive AssumptionSection | asserted | declined | convenience deriving DecidableEq, Repr, BEq namespace AssumptionSection def key : AssumptionSection -> String | .asserted => "A" | .declined => "B" | .convenience => "C" def label : AssumptionSection -> String | .asserted => "What Is Asserted" | .declined => "What Is Deliberately Declined" | .convenience => "Conveniences and Stand-Ins" end AssumptionSection inductive AnchorStatus | proof | witness deriving DecidableEq, Repr, BEq namespace AnchorStatus def label : AnchorStatus -> String | .proof => "proof" | .witness => "witness" end AnchorStatus inductive AnchorLayer | signature | downstream deriving DecidableEq, Repr, BEq namespace AnchorLayer def label : AnchorLayer -> String | .signature => "Signature" | .downstream => "Downstream" end AnchorLayer structure AssumptionAnchor where name : Lean.Name status : AnchorStatus layer : AnchorLayer deriving Repr structure AssumptionEntry where «section» : AssumptionSection number : Nat title : String statement : String anchors : List AssumptionAnchor note : Option String := none deriving Repr def sigProof (name : Lean.Name) : AssumptionAnchor := { name, status := .proof, layer := .signature } def sigWitness (name : Lean.Name) : AssumptionAnchor := { name, status := .witness, layer := .signature } def downProof (name : Lean.Name) : AssumptionAnchor := { name, status := .proof, layer := .downstream } def downWitness (name : Lean.Name) : AssumptionAnchor := { name, status := .witness, layer := .downstream } /-- The canonical assumption ledger in paper order. -/ def assumptionLedger : List AssumptionEntry := [ { «section» := .asserted number := 1 title := "No prior agent" statement := "A weld is the primitive occurrence. `Grid.index` and `Grid.share` are projections from a completed `RawWeld`, not fields recovered from a separate performer or act. `no_agent_recovery_of_field_collision` records the internal obstruction: the same call-response field residue can be produced by distinct actual agents." anchors := [ sigProof ``RawWeld, sigProof ``Grid.index, sigProof ``Grid.share, sigWitness ``no_agent_recovery_of_field_collision ] }, { «section» := .asserted number := 2 title := "Nothing self-indexed is stored" statement := "`Config` stores only `tendency : Contrib`. It has no owner, being, weld, or field-residue slot. `rePitch` uses the received weld's share and ignores the prior configuration value." anchors := [ sigProof ``Config, sigProof ``Config.tendency, sigProof ``Grid.rePitch ] }, { «section» := .asserted number := 3 title := "The self-pole index is just live share" statement := "`HasSelfPoleIndex w` is `not AtBot (share w)`, and when the predicate is live the carried `selfPoleIndex` is the weld's agent tag." anchors := [ sigProof ``Grid.HasSelfPoleIndex, sigProof ``Grid.selfPoleIndex_eq_agent_of_hasSelfPoleIndex, sigProof ``Grid.no_self_pole_index_of_atBot ] }, { «section» := .asserted number := 4 title := "Stone and terminus split function from share" statement := "A `Stone` mounts no response. A `Terminus` may mount responses, but every mounted response is at the pole-class. `AtPoleClass` intentionally includes the vacuous stone case." anchors := [ sigProof ``Grid.Stone, sigProof ``Grid.Terminus, sigProof ``Grid.AtPoleClass, sigProof ``Grid.stone_is_terminus_vacuously, sigWitness ``clockGrid_function_share_split_witness ] }, { «section» := .asserted number := 5 title := "Self-lines are permitted, not built in" statement := "The bare signature does not impose irreflexivity on `conditions`; a model may supply reflexive delivery, and then the directed vocabulary can read a self-line." anchors := [ sigProof ``Grid.conditions, sigProof ``Grid.DirectedConvention.DeliveredTo, sigProof ``Grid.DirectedConvention.LandsAt, sigWitness ``AssumptionLocalWitnesses.signature_self_line_permitted, downWitness ``SelfLineWitness.selfLine_landsAt_self, downWitness ``SelfLineWitness.selfLine_waaOwnershipFace_self ] }, { «section» := .declined number := 1 title := "No arrow in `conditions`" statement := "The signature assumes no asymmetry, irreflexivity, or transitivity for `conditions`. `ConditionsEither` is the symmetric field fact; direction enters only in `Grid.DirectedConvention`. The downstream `DirectionNegative` witness elaborates this as non-recovery from symmetric closure." anchors := [ sigProof ``Grid.ConditionsEither, sigProof ``Grid.conditionsEither_symm, sigProof ``Grid.DirectedConvention.TimeDirection, sigWitness ``Grid.transpose, sigWitness ``Grid.transpose_conditionsEither_iff, sigWitness ``Grid.DirectedConvention.transpose_deliveredTo_iff, sigWitness ``RawWeld.transposeCR, sigWitness ``AssumptionLocalWitnesses.no_direction_recovery_from_conditionsEither, sigWitness ``InteriorDirectionNegative.no_interior_direction_recovery, downWitness ``DirectionNegative.no_direction_recovery_from_conditionsEither ] }, { «section» := .declined number := 2 title := "No `PreorderTop`" statement := "The signature supplies only `PreorderBot`. The share-zero pole is an attained bottom order-class (`AtBot`); the total-share or solipsist pole is an asymptote, not an element of the interface. `StrongSelfConditioningTag` is named and shelved in the being convention for the same reason." anchors := [ sigProof ``PreorderBot, sigProof ``AtBot, sigProof ``Grid.DirectedConvention.BeingConvention.BeingCoarsening.StrongSelfConditioningTag, sigWitness ``AssumptionLocalWitnesses.nat_preorderBot_has_no_top ] }, { «section» := .declined number := 3 title := "No privileged person-partition" statement := "A being boundary is supplied by a diagnosis-time `BeingCoarsening`, not stored as a field of `Grid`. The signature already admits both identity and total coarsenings for any grid; the downstream `BeingNegative` witness elaborates this as non-recovery of a unique partition from grid data." anchors := [ sigProof ``Grid.DirectedConvention.BeingConvention.BeingCoarsening, sigProof ``Grid.DirectedConvention.BeingConvention.BeingCoarsening.InFiber, sigProof ``Grid.DirectedConvention.BeingConvention.BeingCoarsening.SameFiber, sigWitness ``Grid.DirectedConvention.BeingConvention.BeingCoarsening.id, sigWitness ``Grid.DirectedConvention.BeingConvention.BeingCoarsening.total, sigWitness ``Grid.DirectedConvention.BeingConvention.BeingCoarsening.total_sameFiber, sigWitness ``Grid.DirectedConvention.BeingConvention.BeingCoarsening.id_not_sameFiber_of_ne, sigWitness ``AssumptionLocalWitnesses.partition_merge_split_disagree, downWitness ``BeingNegative.no_partition_recovery ] }, { «section» := .declined number := 4 title := "Direction resolution is display, not signature furniture" statement := "A clock's finite delivery-axis resolution is supplied by a diagnosis-time `DirectionCoarsening`, not by a `Grid` field and not by any pole or legitimacy predicate." anchors := [ sigProof ``Grid.DirectedConvention.DirectionCoarsening, sigProof ``Grid.DirectedConvention.DirectionCoarsening.SameTick, sigProof ``Grid.DirectedConvention.DirectionCoarsening.ResolutionBounded, sigProof ``Grid.DirectedConvention.DirectionCoarsening.no_timeDirection_within_tick, sigProof ``Grid.DirectedConvention.DirectionCoarsening.no_timeDirection_of_resolutionBounded_subsingleton, sigWitness ``Grid.DirectedConvention.DirectionCoarsening.transpose_subTickDelivery, downWitness ``DirectionCoarseningWitness.registerClock_unitTick_not_resolutionBounded, downWitness ``DirectionCoarseningWitness.unit_directionVoid_via_mergeToUnit, downWitness ``DirectionCoarseningWitness.fullyCoarseRegisterClock_no_timeDirection, downWitness ``DirectionCoarseningWitness.registerClock_directionCoarsening_independence ] }, { «section» := .declined number := 5 title := "Contribution values are display, not operational tokens" statement := "The Signature layer itself uses only order and pole vocabulary around `share`. The downstream `DisplayReparam` / `InvarianceNegative` modules give the full transport discipline: order- and pole-preserving display changes preserve the legal predicates, while equality to the chosen bottom does not." anchors := [ sigProof ``Grid.share_eq_grade_check, sigProof ``AtBot, sigProof ``OrderEq, sigProof ``Grid.Terminus, downProof ``DisplayReparam, downProof ``DisplayReparam.atBot_iff, downWitness ``InvarianceNegative.oldEqTerminus_not_invariant ] }, { «section» := .convenience number := 1 title := "Hand-rolled order classes" statement := "`Preorder` and `PreorderBot` are hand-rolled to keep assumptions visible and dependency-free. They play the local role Mathlib order classes would play, without importing Mathlib." anchors := [ sigProof ``Preorder, sigProof ``PreorderBot, sigProof ``shareBot, sigProof ``shareBot_le ] }, { «section» := .convenience number := 2 title := "`_before` is retained but currently ignored by `rePitch`" statement := "`rePitch` keeps a `_before` slot because the operation is conceptually a re-pitch from a prior configuration. The current implementation ignores that slot; the proof anchor below is a tripwire for the day that changes." anchors := [ sigProof ``Grid.rePitch ] note := some "The signature file keeps an `rfl` example showing that two prior configurations produce the same re-pitch for the same received weld." }, { «section» := .convenience number := 3 title := "The scalar is display over a partial order" statement := "`WaaMismatchGrade` lives in `Doctrines`, so this Signature module does not import it; the Signature-side checked fact is that `share` is the only contribution value exported by a weld." anchors := [ sigProof ``Grid.share, sigProof ``Grid.share_eq_grade_check, downProof ``Grid.WaaMismatchGrade, downProof ``Grid.waaMismatchGrade_eq_share ] }, { «section» := .convenience number := 4 title := "`Models.lean` witnesses are illustrative" statement := "The clock and register-clock models anchor possibility checks and taxonomy examples; they are not uniqueness claims." anchors := [ sigWitness ``clockGrid, sigWitness ``registerClockGrid, sigWitness ``registerClock_macro_sentient, sigWitness ``registerClock_macro_selfConditioning ] } ] /-- Declarations whose no-axiom status is pinned in `Signature.Assumptions`. -/ def assumptionAxiomAudit : List Lean.Name := [ ``no_agent_recovery_of_field_collision, ``Grid.DirectedConvention.DirectionCoarsening.no_timeDirection_within_tick, ``Grid.DirectedConvention.DirectionCoarsening.no_timeDirection_of_resolutionBounded_subsingleton ] /- ============================================================================== Structural checks ============================================================================== -/ def assumptionSectionEntries (sec : AssumptionSection) : List AssumptionEntry := assumptionLedger.filter (fun entry => entry.«section» == sec) def assumptionTitles : List String := assumptionLedger.map (fun entry => entry.title) def assumptionNumberingContiguous (sec : AssumptionSection) : Bool := let entries := assumptionSectionEntries sec entries.map (fun entry => entry.number) == (List.range entries.length).map (fun n => n + 1) example : (assumptionSectionEntries .asserted).length = 5 := rfl example : (assumptionSectionEntries .declined).length = 5 := rfl example : (assumptionSectionEntries .convenience).length = 4 := rfl example : assumptionNumberingContiguous .asserted = true := by native_decide example : assumptionNumberingContiguous .declined = true := by native_decide example : assumptionNumberingContiguous .convenience = true := by native_decide example : assumptionTitles.Nodup := by native_decide /- ============================================================================== Anchor verifier ============================================================================== -/ open Lean Elab Command Meta syntax (name := verifyAssumptionAnchors) "#verify_assumption_anchors" : command unsafe def evalAssumptionEntries : Term.TermElabM (List AssumptionEntry) := do evalExpr (List AssumptionEntry) (mkApp (mkConst ``List [Level.zero]) (mkConst ``AssumptionEntry)) (mkConst ``assumptionLedger) unsafe def evalAssumptionAxiomAudit : Term.TermElabM (List Lean.Name) := do evalExpr (List Lean.Name) (mkApp (mkConst ``List [Level.zero]) (mkConst ``Lean.Name)) (mkConst ``assumptionAxiomAudit) @[command_elab verifyAssumptionAnchors] unsafe def elabVerifyAssumptionAnchors : CommandElab := fun _stx => do let entries <- liftTermElabM evalAssumptionEntries let axiomAudit <- liftTermElabM evalAssumptionAxiomAudit let env <- getEnv let mut missing : Array String := #[] for entry in entries do for anchor in entry.anchors do unless env.contains anchor.name do missing := missing.push s!"{entry.«section».key}.{entry.number} {entry.title}: {anchor.name}" for name in axiomAudit do unless env.contains name do missing := missing.push s!"axiom audit: {name}" unless missing.isEmpty do let details := missing.foldl (fun acc item => acc ++ "\n" ++ item) "" throwError m!"missing assumption anchors:{details}" #verify_assumption_anchors end WAA ===== FILE: WeldAndArrow/Meta/Audit.lean ===== import WeldAndArrow.Meta.Invariance import WeldAndArrow.Meta.InvarianceNegative import WeldAndArrow.Meta.AssumptionLedger import WeldAndArrow.Meta.ReflexivityWitness import WeldAndArrow.Meta.VerdictLedger import WeldAndArrow.Doctrines.SraddhaNegative import WeldAndArrow.Doctrines.FaithNegative import WeldAndArrow.Doctrines.Deliberation import WeldAndArrow.Doctrines.Ledger import WeldAndArrow.Doctrines.CorrelationsNegative import WeldAndArrow.Doctrines.FettersNegative import WeldAndArrow.Doctrines.FactorsNegative namespace WAA /-- info: 'WAA.no_agent_recovery_of_field_collision' does not depend on any axioms -/ #guard_msgs in #print axioms no_agent_recovery_of_field_collision /-- info: 'WAA.strict_asymm' does not depend on any axioms -/ #guard_msgs in #print axioms strict_asymm /-- info: 'WAA.strict_trans' does not depend on any axioms -/ #guard_msgs in #print axioms strict_trans /-- info: 'WAA.Grid.transpose_transpose' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.transpose_transpose /-- info: 'WAA.DirectionNegative.no_direction_recovery_from_conditionsEither' depends on axioms: [propext, Quot.sound] -/ #guard_msgs in #print axioms DirectionNegative.no_direction_recovery_from_conditionsEither /-- info: 'WAA.CoverageNegative.directionVoid_needs_coverage' does not depend on any axioms -/ #guard_msgs in #print axioms CoverageNegative.directionVoid_needs_coverage /-- info: 'WAA.CoverageNegative.waaFullyEnlightened_needs_coverage' does not depend on any axioms -/ #guard_msgs in #print axioms CoverageNegative.waaFullyEnlightened_needs_coverage /-- info: 'WAA.Grid.stateToolFits_iff_atBot' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.stateToolFits_iff_atBot /-- info: 'WAA.Grid.map_actual_iff' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.map_actual_iff /-- info: 'WAA.Grid.map_isShareDrop_iff' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.map_isShareDrop_iff /-- info: 'WAA.Grid.map_transpose' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.map_transpose /-- info: 'WAA.Grid.staticized_transpose' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.staticized_transpose /-- info: 'WAA.Grid.map_staticized' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.map_staticized /-- info: 'WAA.Grid.DirectedConvention.DirectionCoarsening.mapDir_resolutionBounded_iff' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.DirectionCoarsening.mapDir_resolutionBounded_iff /-- info: 'WAA.DirectionCoarseningWitness.registerClock_unitTick_not_resolutionBounded' does not depend on any axioms -/ #guard_msgs in #print axioms DirectionCoarseningWitness.registerClock_unitTick_not_resolutionBounded /-- info: 'WAA.DirectionCoarseningWitness.unit_directionVoid_via_mergeToUnit' does not depend on any axioms -/ #guard_msgs in #print axioms DirectionCoarseningWitness.unit_directionVoid_via_mergeToUnit /-- info: 'WAA.DirectionCoarseningWitness.fullyCoarseRegisterClock_no_timeDirection' does not depend on any axioms -/ #guard_msgs in #print axioms DirectionCoarseningWitness.fullyCoarseRegisterClock_no_timeDirection /-- info: 'WAA.DirectionCoarseningWitness.registerClock_directionCoarsening_independence' does not depend on any axioms -/ #guard_msgs in #print axioms DirectionCoarseningWitness.registerClock_directionCoarsening_independence /-- info: 'WAA.Grid.DirectedConvention.map_landsWithShareDrop_iff' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.map_landsWithShareDrop_iff /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.BeingCoarsening.map_selfConditioningTag_iff' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.BeingCoarsening.map_selfConditioningTag_iff /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.BeingCoarsening.map_fiberAtPoleOn_iff' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.BeingCoarsening.map_fiberAtPoleOn_iff /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.BeingCoarsening.total_sameFiber' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.BeingCoarsening.total_sameFiber /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.BeingCoarsening.id_not_sameFiber_of_ne' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.BeingCoarsening.id_not_sameFiber_of_ne /-- info: 'WAA.Grid.map_waaBullSeven_iff' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.map_waaBullSeven_iff /-- info: 'WAA.Grid.map_waaBullTen_iff' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.map_waaBullTen_iff /-- info: 'WAA.Grid.bullSeven_not_bullEight' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.bullSeven_not_bullEight /-- info: 'WAA.Grid.bullTen_to_bullNine' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.bullTen_to_bullNine /-- info: 'WAA.CorrelationsNegative.pratyekabuddha_countermodel' does not depend on any axioms -/ #guard_msgs in #print axioms CorrelationsNegative.pratyekabuddha_countermodel /-- info: 'WAA.CorrelationsNegative.no_stage_boundary_recovery' does not depend on any axioms -/ #guard_msgs in #print axioms CorrelationsNegative.no_stage_boundary_recovery /-- info: 'WAA.Grid.classQuiet_no_clench_in_class' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.classQuiet_no_clench_in_class /-- info: 'WAA.Fetter.kind_lower_iff_cut_by_nonReturn' does not depend on any axioms -/ #guard_msgs in #print axioms Fetter.kind_lower_iff_cut_by_nonReturn /-- info: 'WAA.Grid.arhatPathQuiet_iff_fiberAtPole' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.arhatPathQuiet_iff_fiberAtPole /-- info: 'WAA.Grid.all_fetters_cut_at_arhatFiber' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.all_fetters_cut_at_arhatFiber /-- info: 'WAA.Grid.identityView_excluded_at_arhatFiber' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.identityView_excluded_at_arhatFiber /-- info: 'WAA.Grid.conceit_excluded_at_arhatFiber' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.conceit_excluded_at_arhatFiber /-- info: 'WAA.Grid.waaIrreversibleRegime_conditional' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.waaIrreversibleRegime_conditional /-- info: 'WAA.Grid.lower_fetters_covered_by_rites_view_resolve' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.lower_fetters_covered_by_rites_view_resolve /-- info: 'WAA.Grid.waaStreamWinner_iff_streamEntry_cutClasses' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.waaStreamWinner_iff_streamEntry_cutClasses /-- info: 'WAA.Grid.waaNonReturner_iff_nonReturn_cut' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.waaNonReturner_iff_nonReturn_cut /-- info: 'WAA.Grid.waaSerialFactorRegime_conditional' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.waaSerialFactorRegime_conditional /-- info: 'WAA.Grid.waaOnceReturner_attenuation_witness' depends on axioms: [propext] -/ #guard_msgs in #print axioms Grid.waaOnceReturner_attenuation_witness /-- info: 'WAA.FactorsNegative.no_hold_conceit_boundary_recovery' does not depend on any axioms -/ #guard_msgs in #print axioms FactorsNegative.no_hold_conceit_boundary_recovery /-- info: 'WAA.FactorsNegative.seen_run_underdetermines_factorOrder' depends on axioms: [propext] -/ #guard_msgs in #print axioms FactorsNegative.seen_run_underdetermines_factorOrder /-- info: 'WAA.FactorsNegative.lineage_underdetermined_by_seen_run' does not depend on any axioms -/ #guard_msgs in #print axioms FactorsNegative.lineage_underdetermined_by_seen_run /-- info: 'WAA.FettersNegative.seen_run_underdetermines_fetterCut' depends on axioms: [propext] -/ #guard_msgs in #print axioms FettersNegative.seen_run_underdetermines_fetterCut /-- info: 'WAA.Grid.DirectedConvention.waaPathOught_conditional' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.waaPathOught_conditional /-- info: 'WAA.Grid.DirectedConvention.waaFaithOught_conditional' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.waaFaithOught_conditional /-- info: 'WAA.Grid.DirectedConvention.map_waaFaithPrinciple_reflect' depends on axioms: [propext] -/ #guard_msgs in #print axioms Grid.DirectedConvention.map_waaFaithPrinciple_reflect /-- info: 'WAA.FaithNegative.waaFaithPrinciple_id_fails' does not depend on any axioms -/ #guard_msgs in #print axioms FaithNegative.waaFaithPrinciple_id_fails /-- info: 'WAA.Grid.DirectedConvention.no_waa_path_at_pole' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.no_waa_path_at_pole /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.rowOf_obeys' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.rowOf_obeys /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.pole_validates_all_claims' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.pole_validates_all_claims /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.denied_misfits_live_offer' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.denied_misfits_live_offer /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.rowOf_obeys_iff_errorFree' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.rowOf_obeys_iff_errorFree /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.reEmptied_obeys_of_errorFree' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.reEmptied_obeys_of_errorFree /-- info: 'WAA.rung_not_pole_witness' does not depend on any axioms -/ #guard_msgs in #print axioms rung_not_pole_witness /-- info: 'WAA.standing_does_not_determine_dated' does not depend on any axioms -/ #guard_msgs in #print axioms standing_does_not_determine_dated /-- info: 'WAA.Grid.DirectedConvention.map_waaAversionContext_iff' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.map_waaAversionContext_iff /-- info: 'WAA.OrthogonalityNegative.waaFullyEnlightened_stronger_than_terminus' does not depend on any axioms -/ #guard_msgs in #print axioms OrthogonalityNegative.waaFullyEnlightened_stronger_than_terminus /-- info: 'WAA.MisFeedNegative.fence_and_gate' does not depend on any axioms -/ #guard_msgs in #print axioms MisFeedNegative.fence_and_gate /-- info: 'WAA.misFeed_entries_carry_decomposition' does not depend on any axioms -/ #guard_msgs in #print axioms misFeed_entries_carry_decomposition /-- info: 'WAA.Grid.grade_independent_of_conditions' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.grade_independent_of_conditions /-- info: 'WAA.Grid.rePitch_forgets' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.rePitch_forgets /-- info: 'WAA.Grid.stone_of_no_call' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.stone_of_no_call /-- info: 'WAA.Grid.respondsToEveryCall_of_no_call' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.respondsToEveryCall_of_no_call /-- info: 'WAA.Grid.allStone_of_no_being' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.allStone_of_no_being /-- info: 'WAA.ContentNegative.emptyCallGrid_false_stone_and_respondsToEveryCall' does not depend on any axioms -/ #guard_msgs in #print axioms ContentNegative.emptyCallGrid_false_stone_and_respondsToEveryCall /-- info: 'WAA.ContentNegative.emptyBeingGrid_no_liveTier' does not depend on any axioms -/ #guard_msgs in #print axioms ContentNegative.emptyBeingGrid_no_liveTier /-- info: 'WAA.ContentNegative.contentBeingsRow_obeys_emptyBeing' does not depend on any axioms -/ #guard_msgs in #print axioms ContentNegative.contentBeingsRow_obeys_emptyBeing /-- info: 'WAA.Grid.DirectedConvention.PrudentialPrivilegeNegative.prudentialPrivilege_failure_modes' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.PrudentialPrivilegeNegative.prudentialPrivilege_failure_modes /-- info: 'WAA.Grid.ConsequentialistConvention.dropCountInFiber_le_dropCount' depends on axioms: [propext] -/ #guard_msgs in #print axioms Grid.ConsequentialistConvention.dropCountInFiber_le_dropCount /-- info: 'WAA.Grid.ConsequentialistConvention.dropCount_eq_sum_dropCountInFiber' depends on axioms: [propext] -/ #guard_msgs in #print axioms Grid.ConsequentialistConvention.dropCount_eq_sum_dropCountInFiber /-- info: 'WAA.Grid.ConsequentialistConvention.map_dropCountInFiberSum' depends on axioms: [propext] -/ #guard_msgs in #print axioms Grid.ConsequentialistConvention.map_dropCountInFiberSum /-- info: 'WAA.ObjectiveNegative.split_dropCount_sum_eq_mergedDropCount' does not depend on any axioms -/ #guard_msgs in #print axioms ObjectiveNegative.split_dropCount_sum_eq_mergedDropCount /-- info: 'WAA.ObjectiveNegative.no_grid_data_objective_for_my_drops' does not depend on any axioms -/ #guard_msgs in #print axioms ObjectiveNegative.no_grid_data_objective_for_my_drops /-- info: 'WAA.TransferNegative.adaptive_track_record_underdetermines_new_effect' does not depend on any axioms -/ #guard_msgs in #print axioms TransferNegative.adaptive_track_record_underdetermines_new_effect /-- info: 'WAA.DeliveryArrogationNegative.command_utterance_not_fits' does not depend on any axioms -/ #guard_msgs in #print axioms DeliveryArrogationNegative.command_utterance_not_fits /-- info: 'WAA.Grid.DirectedConvention.landing_call_in_modality' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.landing_call_in_modality /-- info: 'WAA.LedgerCase.decree_engineers_calls_not_receptions' depends on axioms: [propext] -/ #guard_msgs in #print axioms LedgerCase.decree_engineers_calls_not_receptions /-- info: 'WAA.LedgerCase.purge_loop_runs_on' depends on axioms: [propext] -/ #guard_msgs in #print axioms LedgerCase.purge_loop_runs_on /-- info: 'WAA.InteriorDirectionNegative.transposeCR_involutive' does not depend on any axioms -/ #guard_msgs in #print axioms InteriorDirectionNegative.transposeCR_involutive /-- info: 'WAA.InteriorDirectionNegative.unorderedCRContent_transpose_invariant' depends on axioms: [propext] -/ #guard_msgs in #print axioms InteriorDirectionNegative.unorderedCRContent_transpose_invariant /-- info: 'WAA.InteriorDirectionNegative.transpose_swaps_readings' does not depend on any axioms -/ #guard_msgs in #print axioms InteriorDirectionNegative.transpose_swaps_readings /-- info: 'WAA.DoerDeedNegative.priority_readings_disagree' does not depend on any axioms -/ #guard_msgs in #print axioms DoerDeedNegative.priority_readings_disagree /-- info: 'WAA.DoerDeedNegative.no_priority_recovery' does not depend on any axioms -/ #guard_msgs in #print axioms DoerDeedNegative.no_priority_recovery /-- info: 'WAA.ContentNegative.constantResponseGrid_no_variation' does not depend on any axioms -/ #guard_msgs in #print axioms ContentNegative.constantResponseGrid_no_variation /-- info: 'WAA.ContentNegative.constantResponseWeld_no_live_share' does not depend on any axioms -/ #guard_msgs in #print axioms ContentNegative.constantResponseWeld_no_live_share /-- info: 'WAA.ContentNegative.contentIntraWeldArrowRow_not_fused_constantResponse' does not depend on any axioms -/ #guard_msgs in #print axioms ContentNegative.contentIntraWeldArrowRow_not_fused_constantResponse /-- info: 'WAA.ContentNegative.contentIntraWeldArrowRow_not_obeys_constantResponse' does not depend on any axioms -/ #guard_msgs in #print axioms ContentNegative.contentIntraWeldArrowRow_not_obeys_constantResponse /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.intraWeldArrowRow_obeys' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.intraWeldArrowRow_obeys /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.intraWeldArrowRow_not_freeze' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.intraWeldArrowRow_not_freeze /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.no_order_collapse_self_refuting' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.no_order_collapse_self_refuting /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.doerDeedRow_obeys' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.doerDeedRow_obeys /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.doerDeedRow_not_freeze' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.doerDeedRow_not_freeze /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.no_prior_doer_collapse_self_refuting' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.no_prior_doer_collapse_self_refuting /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.contentLayerRow_obeys_of_variation' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.contentLayerRow_obeys_of_variation /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.contentIntraWeldArrowRow_obeys_of_variation' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.contentIntraWeldArrowRow_obeys_of_variation /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.interior_order_denial_unfit_for_live_utterer' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.interior_order_denial_unfit_for_live_utterer /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.intraWeldArrowLadder_obeys' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.intraWeldArrowLadder_obeys /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.intraWeldArrowLadder_obeys_succ' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.intraWeldArrowLadder_obeys_succ /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.intraWeldArrowLadder_no_level_final' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.intraWeldArrowLadder_no_level_final /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.doerDeedLadder_obeys' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.doerDeedLadder_obeys /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.doerDeedLadder_obeys_succ' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.doerDeedLadder_obeys_succ /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.doerDeedLadder_no_level_final' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.doerDeedLadder_no_level_final /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.Nishitani.intraWeldArrow_sunyata' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.Nishitani.intraWeldArrow_sunyata /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.Nishitani.doerDeed_sunyata' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.Nishitani.doerDeed_sunyata /-- info: 'WAA.Grid.map_responseVariesWithCall_iff' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.map_responseVariesWithCall_iff /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.map_intraWeldArrowRow_obeys' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.map_intraWeldArrowRow_obeys /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.map_doerDeedRow_obeys' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.map_doerDeedRow_obeys /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.map_contentIntraWeldArrowRow_obeys_of_variation' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.map_contentIntraWeldArrowRow_obeys_of_variation /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.map_intraWeldArrowLadder_obeys' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.map_intraWeldArrowLadder_obeys /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.map_intraWeldArrowLadder_obeys_succ' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.map_intraWeldArrowLadder_obeys_succ /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.map_intraWeldArrowLadder_no_level_final' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.map_intraWeldArrowLadder_no_level_final /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.map_doerDeedLadder_obeys' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.map_doerDeedLadder_obeys /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.map_doerDeedLadder_obeys_succ' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.map_doerDeedLadder_obeys_succ /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.map_doerDeedLadder_no_level_final' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.map_doerDeedLadder_no_level_final /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.ladderRungGrid_beings_sunyata' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.ladderRungGrid_beings_sunyata /-- info: 'WAA.Grid.DirectedConvention.BeingConvention.GridConvention.ladderRungGrid_no_level_final' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.BeingConvention.GridConvention.ladderRungGrid_no_level_final end WAA ===== FILE: WeldAndArrow/Meta/Glossary.lean ===== /- ================================================================================ WeldAndArrow.Meta.Glossary Canonical glossary data and structural checks ================================================================================ The glossary is the single source for short definitions used by the paper-facing markdown. Lean checks the office discipline around the prose: term uniqueness, backward-only `seeAlso` references, and declaration-anchor resolvability. The accuracy and aptness of the glosses remain prose obligations. -/ import Lean import WeldAndArrow.Consequences.Compounds import WeldAndArrow.Doctrines import WeldAndArrow.Identification import WeldAndArrow.Meta.InvarianceNegative import WeldAndArrow.Meta.Nishitani import WeldAndArrow.Meta.ReflexivityWitness import WeldAndArrow.Meta.VerdictLedger namespace WAA /- ============================================================================== Glossary data ============================================================================== -/ /-- The paper layer where a system term first does its work. -/ inductive SourceLayer | theory | theorems | identification deriving DecidableEq, Repr, BEq namespace SourceLayer def label : SourceLayer -> String | .theory => "Theory" | .theorems => "Theorems" | .identification => "Identification" end SourceLayer /-- Provenance of a term in the merged glossary. -/ inductive TermKind | coinage (layer : SourceLayer) | canonical | leanConvention deriving DecidableEq, Repr, BEq namespace TermKind def label : TermKind -> String | .coinage layer => layer.label | .canonical => "Canonical" | .leanConvention => "Lean convention" end TermKind /-- A glossary row. `anchors` name checked declarations; empty anchors are allowed for prose-only terms. `seeAlso` entries must point to earlier rows. -/ structure GlossaryEntry where term : String kind : TermKind gloss : String anchors : List Lean.Name := [] seeAlso : List String := [] deriving Repr /-- The glossary in pedagogical order. This order is the generated table order. -/ def glossary : List GlossaryEntry := [ { term := "floor" kind := .coinage .theory gloss := "A floor is the place where no deeper support is being claimed. In this system it names the self-emptying limit at which every distinction is conventional, including the distinction between conventional and ultimate truth." anchors := [``Grid.Tier.floor] }, { term := "genjō" kind := .canonical gloss := "Genjō means manifestation, the way something comes forward as this case. In this system it also names the pole-class face where no share is claimed." anchors := [``AtBot] seeAlso := ["floor"] }, { term := "grid" kind := .coinage .theory gloss := "A grid is a deliberately small model of who responds to what and how those responses are connected. It supplies the apparatus for welds, grades, delivery, and diagnostics without pretending to be the whole doctrine." anchors := [``Grid] seeAlso := ["floor"] }, { term := "act-grammar" kind := .coinage .theory gloss := "An act-grammar is a way to parse an occurrence into roles. In this system it is the three-row pattern that lets the grid discuss dependence, manifestation, resonance, practice, and causal carrying without storing a self." anchors := [``Grid.Tier, ``Grid.Distinction] seeAlso := ["grid"] }, { term := "mujishō-sōe" kind := .canonical gloss := "Mujishō-sōe means mutual dependence without own-being. In this system it is the first-row dependence face of the act-grammar." seeAlso := ["act-grammar"] }, { term := "kannō-sōe" kind := .canonical gloss := "Kannō-sōe means responsive resonance or mutual answering. In this system it is the second-row dependence face, where a call and a response are placed together." anchors := [``Grid.MountsAt] seeAlso := ["act-grammar"] }, { term := "banpō susumite" kind := .canonical gloss := "Banpō susumite means the myriad dharmas advancing. In this system it is the second-row enactment face, where what arrives is answered by a concrete response." anchors := [``Grid.Actual] seeAlso := ["kannō-sōe"] }, { term := "shō" kind := .canonical gloss := "Shō means realization. In this system it is read as the non-possessive face at the floor, not as a stored attainment." seeAlso := ["floor"] }, { term := "shu" kind := .canonical gloss := "Shu means practice. In this system it names the enacted side of the occurrence, the doing that is spent as the occurrence happens." anchors := [``RawWeld] seeAlso := ["act-grammar"] }, { term := "shushō-ittō" kind := .canonical gloss := "Shushō-ittō means practice and realization as non-dual. In this system it is read as one occurrence with two faces, not two events that later get joined." seeAlso := ["shō", "shu"] }, { term := "shugenjō" kind := .coinage .theory gloss := "Shugenjō is the paper's compound for practice that manifests without a scaffold. It is treated as a proper subset of genjō, not as a synonym for all manifestation." seeAlso := ["genjō", "shu"] }, { term := "genjōkōan" kind := .canonical gloss := "Genjōkōan is a manifest case, not an abstract principle floating free of use. In this system it names the first-row manifestation arriving in a second-row situation." seeAlso := ["genjō", "kannō-sōe"] }, { term := "satori" kind := .canonical gloss := "Satori means awakening or realization in ordinary Buddhist usage. In this system it is a pole-typed dharmas-forward event and is kept distinct from shō and kenshō." seeAlso := ["genjō", "shō"] }, { term := "call" kind := .coinage .theory gloss := "A call is something that arrives to be answered. In the grid it is the input slot of a weld, the thing a response addresses or fails to address." anchors := [``RawWeld.call, ``Grid.RecordedUtterance.answersCall] seeAlso := ["grid"] }, { term := "response" kind := .coinage .theory gloss := "A response is what a being produces when it answers a call. In the grid it is the output slot of a weld and the visible side of function." anchors := [``RawWeld.response, ``Grid.MountsAt] seeAlso := ["call"] }, { term := "field" kind := .coinage .theory gloss := "A field is the impersonal web of conditioning and delivery. In this system it carries connections through time without carrying an owner or self-index." anchors := [``Grid.conditions, ``Grid.ConditionsEither] seeAlso := ["grid"] }, { term := "inga" kind := .canonical gloss := "Inga means cause and effect. In this system it is read as the field's conditioning structure, not as a stored moral account." anchors := [``Grid.conditions] seeAlso := ["field"] }, { term := "delivery" kind := .coinage .theory gloss := "Delivery is the fact that one occurrence reaches another as part of the field. It is checked by a directed relation, but the act that receives it still has to be actual." anchors := [``Grid.DirectedConvention.DeliveredTo, ``Grid.DirectedConvention.LandsAt] seeAlso := ["field"] }, { term := "delivery-regime" kind := .coinage .theory gloss := "A delivery-regime is the whole pattern of what reaches what. In this system it is ceded as a world-fact and is never something a single act commands." anchors := [``Grid.conditions] seeAlso := ["delivery", "field"] }, { term := "weld" kind := .coinage .theory gloss := "A weld is one concrete occurrence of answering. In the grid it bundles agent, call, and response, so the act's index is made by the act rather than stored before it." anchors := [``RawWeld, ``Grid.Weld, ``Grid.index] seeAlso := ["call", "response"] }, { term := "reach-back" kind := .coinage .theory gloss := "Reach-back is a reception reading what arrived as the return of some earlier deed. In the system it is full when delivery supplies the earlier deed and vacuous when it does not." anchors := [``Grid.DirectedConvention.WaaReachBackFull, ``Grid.DirectedConvention.deliveredTo_iff_waaReachBackFull] seeAlso := ["delivery", "weld"] }, { term := "upādāna" kind := .canonical gloss := "Upādāna ordinarily means grasping or appropriation. In this system it is the traditional word closest to reach-back, with the technical decomposition handled by the grid." anchors := [``Grid.WaaAppropriates] seeAlso := ["reach-back"] }, { term := "vacuity" kind := .coinage .theory gloss := "Vacuity is a place left unfilled rather than a false claim. In the system it names the reach-back shape where appropriation occurs but delivery supplies no deed to fill the second slot." anchors := [``Grid.DirectedConvention.NotDeliveredTo] seeAlso := ["reach-back", "delivery"] }, { term := "share" kind := .coinage .theory gloss := "A share is the portion of an occurrence's drive that is claimed as self-maintaining. In the grid it is the contribution value projected from a weld." anchors := [``Grid.share, ``Grid.share_eq_grade_check] seeAlso := ["weld"] }, { term := "grade" kind := .coinage .theory gloss := "A grade is an ordered display of how much share a concrete response carries. It is third-personal in form but indexical in content, because it reads this weld's placement." anchors := [``Grid.grade, ``Grid.WaaMismatchGrade, ``Grid.share_eq_grade_check] seeAlso := ["share", "weld"] }, { term := "clench" kind := .coinage .theory gloss := "Clench is self-maintenance tightening around a response. In the grid it is read through live share rather than through a stored inner state." anchors := [``Grid.HasSelfPoleIndex, ``Grid.WaaAppropriates] seeAlso := ["share", "weld"] }, { term := "arrogation" kind := .coinage .theory gloss := "Arrogation is a response claiming subjecthood for itself. In this system it is per call and per weld, never a standing rank possessed by a being." anchors := [``Grid.HasSelfPoleIndex] seeAlso := ["clench", "weld"] }, { term := "self-forward" kind := .coinage .theory gloss := "Self-forward means carrying a self toward what is met. In this system it is the delusive direction of a live weld, not a permanent condition." seeAlso := ["arrogation", "weld"] }, { term := "function" kind := .coinage .theory gloss := "Function is the ability to mount a response at all. The grid keeps it separate from share, so answering a call and claiming the answer are not the same fact." anchors := [``Grid.MountsAt, ``Grid.RespondsToEveryCall] seeAlso := ["response", "share"] }, { term := "pole" kind := .coinage .theory gloss := "A pole is the zero-share class in the ordering. In the grid it is represented by `AtBot`, so the system can speak of no live self-index without choosing a numerical scale." anchors := [``AtBot, ``Grid.AtPoleClass] seeAlso := ["share", "genjō"] }, { term := "stone" kind := .coinage .theory gloss := "A stone is the zero-function edge: no response is mounted. In this system it can sit at the pole only vacuously, because there is no answering act to grade." anchors := [``Grid.Stone, ``Grid.stone_is_terminus_vacuously] seeAlso := ["function", "pole"] }, { term := "solipsist" kind := .coinage .theory gloss := "The solipsist is the opposite edge from the stone. It names the imagined case where response is all self-claim and the call has effectively vanished." seeAlso := ["function", "share"] }, { term := "terminus" kind := .coinage .theory gloss := "A terminus is a responder whose mounted responses lie at the pole. It answers without live share, so the system treats it differently from a stone." anchors := [``Grid.Terminus, ``Grid.LiveTerminus, ``Grid.ResponsiveTerminus] seeAlso := ["function", "pole"] }, { term := "tier" kind := .leanConvention gloss := "A tier is the level at which a claim is offered or tested. Lean uses tiers to distinguish the floor from an act-time weld." anchors := [``Grid.Tier, ``Grid.Tier.hasLiveShare] seeAlso := ["floor", "weld"] }, { term := "Row 2" kind := .coinage .theory gloss := "Row 2 is the resonance row, where call and response are placed together. It is where the system states grade without turning grade into something possessed." anchors := [``Grid.Tier.hasLiveShare] seeAlso := ["kannō-sōe", "grade"] }, { term := "determination clause" kind := .coinage .theory gloss := "The determination clause says the grade is fixed by what actually drove this response. It rejects a private glow or later outcome as the source of grading." anchors := [``Grid.share_eq_grade_check] seeAlso := ["grade", "response"] }, { term := "probe" kind := .coinage .theory gloss := "A probe is a third-person way of varying calls to display a response pattern. It can show a placement, but it does not create the placement it shows." anchors := [``Grid.ProbeConstant] seeAlso := ["call", "grade"] }, { term := "effectiveness" kind := .coinage .theory gloss := "Effectiveness is a landing rate within a delivery-regime. In this system it grades whether calls land; it does not type what a responder is." anchors := [``Grid.DirectedConvention.HasShareDropLanding, ``Grid.DirectedConvention.ShortfallClosedAt] seeAlso := ["delivery-regime", "grade"] }, { term := "fixed/adaptive" kind := .coinage .theory gloss := "Fixed and adaptive describe how a responder's output relates to calls. The grid can model both without making adaptivity the ground of liberation." anchors := [``Grid.ResponseInvariant, ``Grid.ResponseVariesWithCall] seeAlso := ["call", "response", "effectiveness"] }, { term := "orthogonality rule" kind := .coinage .theory gloss := "The orthogonality rule says two dimensions do not determine each other. Here function and share type the responder, while effectiveness grades landing." anchors := [``OrthogonalityNegative.waaFullyEnlightened_stronger_than_terminus] seeAlso := ["function", "share", "effectiveness"] }, { term := "domain joint" kind := .coinage .theory gloss := "The domain joint is the question of what counts as responding at all. The grid answers it by drive-composition and accepts the resulting artifact cases openly." anchors := [``Grid.MountsAt] seeAlso := ["function", "response"] }, { term := "aimed call" kind := .coinage .theory gloss := "An aimed call is a deed configured for a landing. In Lean this thin reading is just delivery from the deed to the reception, not a new intention primitive." anchors := [``Grid.DirectedConvention.WaaAimedAt] seeAlso := ["call", "delivery"] }, { term := "re-pitch" kind := .coinage .theory gloss := "Re-pitch is what a reception hands forward as the next carried tendency. In the current signature it records the received weld's share and forgets the previous configuration." anchors := [``Grid.rePitch, ``Grid.rePitch_forgets] seeAlso := ["share", "weld"] }, { term := "seed" kind := .coinage .theory gloss := "A seed is a carried tendency rather than a bearer. In Lean it is modeled by a configuration value with no stored owner, weld, or self-index." anchors := [``Config, ``Config.tendency] seeAlso := ["field", "re-pitch"] }, { term := "standing/dated" kind := .coinage .theory gloss := "Standing means carried as a tendency; dated means enacted now. The system treats reading a dated occurrence directly from a standing tendency as a diagnostic error." anchors := [``Grid.DirectedConvention.BeingConvention.GridConvention.RowTag.standingDated, ``standing_does_not_determine_dated] seeAlso := ["seed", "weld"] }, { term := "three registers" kind := .coinage .theory gloss := "The three registers are carried field facts, spent weld facts, and per-call grade statements. The split keeps the system from storing self-indexed ownership between acts." anchors := [``SortedFact.register] seeAlso := ["field", "weld", "grade"] }, { term := "separate/fuse rule" kind := .coinage .theory gloss := "The separate/fuse rule says live act-time distinctions must be kept apart and floor-level distinctions must fuse. It is the grammar behind the taxonomy's collapse and freeze diagnoses." anchors := [``Grid.Distinction.ObeysSeparateFuse] seeAlso := ["floor", "tier"] }, { term := "collapse/freeze" kind := .coinage .theory gloss := "Collapse fuses what should be separate; freeze holds separate what should fuse. These are the two basic ways the taxonomy catches a misuse of a distinction." anchors := [``Grid.Distinction.Collapse, ``Grid.Distinction.Freeze] seeAlso := ["separate/fuse rule"] }, { term := "assert/display" kind := .leanConvention gloss := "Assert and display are two voices for a verdict. The grid asserts grammatical failures inside its lens and only displays value-laden or soteriological shortfall." anchors := [``Grid.VerdictVoice, ``Grid.ErrorGrade, ``Grid.ErrorGrade.voice] seeAlso := ["collapse/freeze"] }, { term := "orange / eat this" kind := .coinage .theory gloss := "The orange is the paper's image for its own offering. It gives a thing to receive, while the phrase eat this marks the risk of turning a description into an injunction." seeAlso := ["assert/display", "call"] }, { term := "object-axis/subject-axis" kind := .coinage .theory gloss := "Object-axis means being available as something received; subject-axis means mounting responses oneself. The grid keeps these axes apart, especially for stones and termini." anchors := [``Grid.DirectedConvention.ObjectAxisStanding, ``Grid.MountsAt] seeAlso := ["delivery", "function"] }, { term := "index-question" kind := .coinage .theory gloss := "The index-question asks whose act or whose fruit is at issue. In this system the answer is enacted in a weld or stated by a grade, never stored in the field." anchors := [``Grid.index, ``Grid.HasSelfPoleIndex] seeAlso := ["weld", "field", "grade"] }, { term := "mis-feed" kind := .coinage .identification gloss := "A mis-feed is an internal diagnostic where the wrong register is fed to a question. The checked fence covers index-free field answers being used where an index-bearing designation is required." anchors := [``MisFeedNegative.fence_and_gate] seeAlso := ["index-question", "field"] }, { term := "dukkha" kind := .canonical gloss := "Dukkha ordinarily names suffering or unsatisfactoriness. In this system it is the mismatch of a live self-maintaining response with delivery that answers to no self." anchors := [``Grid.WaaMismatchGrade, ``Grid.WaaMismatchLive] seeAlso := ["share", "delivery", "clench"] }, { term := "before/after" kind := .coinage .theory gloss := "Before and after are ordinary temporal words. In this system they are a reading over roles in the field, not extra furniture stored inside the field." anchors := [``Grid.DirectedConvention.TimeDirection] seeAlso := ["field", "delivery"] }, { term := "arrow" kind := .coinage .theory gloss := "The arrow is direction read into conditioning. The retyped system treats direction as a display over field structure, not as a primitive property of that structure." anchors := [``Grid.DirectedConvention.TimeDirection, ``DirectionNegative.no_direction_recovery_from_conditionsEither] seeAlso := ["field", "before/after"] }, { term := "ratchet" kind := .coinage .theory gloss := "A ratchet is a mechanism that reads a gradient as direction. In the paper it motivates why beings may read an arrow without making the arrow part of the field itself." seeAlso := ["arrow", "field"] }, { term := "Waa marker" kind := .leanConvention gloss := "The Waa marker flags a system-point-of-view reading. It tells readers that a Lean name reports how the grid reads a concept, not what the tradition must mean by it." anchors := [``Grid.WaaAppropriates, ``Grid.WaaMismatchGrade, ``Grid.DirectedConvention.WaaReachBackFull] seeAlso := ["grid"] }, { term := "DirectedConvention" kind := .leanConvention gloss := "DirectedConvention is the namespace for vocabulary that reads direction into the grid. It keeps directed delivery words separate from the direction-free signature beneath them." anchors := [``Grid.DirectedConvention.DeliveredTo] seeAlso := ["arrow", "delivery"] }, { term := "being-convention" kind := .coinage .theory gloss := "A being-convention is a diagnosis-time way of reading fine tags as macro beings. It permits naming without claiming that the grid stores the true partition." anchors := [``Grid.DirectedConvention.BeingConvention.BeingCoarsening] seeAlso := ["grid", "DirectedConvention"] }, { term := "coarsening" kind := .leanConvention gloss := "A coarsening maps fine tags to macro tags. Lean uses it to model a chosen being-reading while leaving the underlying grid unchanged." anchors := [``Grid.DirectedConvention.BeingConvention.BeingCoarsening, ``Grid.DirectedConvention.BeingConvention.BeingCoarsening.InFiber] seeAlso := ["being-convention"] }, { term := "tag/fiber" kind := .coinage .theory gloss := "A tag is a fine identifier; a fiber is the set of fine tags read as one macro tag by a coarsening. Fiber-level predicates let the system discuss beings without storing beings as substances." anchors := [``Grid.DirectedConvention.BeingConvention.BeingCoarsening.InFiber, ``Grid.DirectedConvention.BeingConvention.BeingCoarsening.SameFiber] seeAlso := ["coarsening"] }, { term := "tag-region/soma-reading" kind := .coinage .theory gloss := "A tag-region is a model-supplied class of fine tags. A soma-reading uses such a class to localize a cut to a region without making the region recoverable from grid data alone." anchors := [``Grid.SomaReading] seeAlso := ["tag/fiber"] }, { term := "within-cut" kind := .coinage .theory gloss := "A within-cut is quietness inside a product of call-class and tag-region. It says enactment has ceased in that rectangle, not that a person owns an anti-fetter." anchors := [``Grid.FetterCutWithin] seeAlso := ["tag-region/soma-reading", "call"] }, { term := "vāsanā" kind := .canonical gloss := "Vāsanā means residual habit or trace. In this system it is clench still enacted in an uncut region after another region has gone quiet." seeAlso := ["clench", "within-cut"] }, { term := "sentient/insentient tag" kind := .coinage .theory gloss := "A sentient tag is one whose fiber mounts response somewhere; an insentient tag lacks that. The distinction is fiber-level and convention-relative." anchors := [``Grid.DirectedConvention.BeingConvention.BeingCoarsening.SentientTag, ``Grid.DirectedConvention.BeingConvention.BeingCoarsening.not_sentientTag_iff_fiber_all_stone] seeAlso := ["tag/fiber", "function"] }, { term := "FiberAtPole / SelfAptTag / Patchy" kind := .leanConvention gloss := "These names describe a fiber spectrum: all actual welds at pole, all actual welds self-apt, or an irreducibly mixed case. They deliberately avoid defining an aggregate share for a fiber." anchors := [``Grid.DirectedConvention.BeingConvention.BeingCoarsening.FiberAtPole, ``Grid.DirectedConvention.BeingConvention.BeingCoarsening.SelfAptTag, ``Grid.DirectedConvention.BeingConvention.BeingCoarsening.Patchy] seeAlso := ["tag/fiber", "pole"] }, { term := "coherence (grade)" kind := .coinage .theory gloss := "Coherence is a display grade over a coarsening. It can report how well a reading behaves, but it never licenses or forbids the naming of a being." seeAlso := ["coarsening", "grade"] }, { term := "delegation" kind := .coinage .theory gloss := "Delegation reads macro agency through an actual fine weld in a fiber. The share remains the fine weld's share, so macro agency does not create a new stored subject." seeAlso := ["weld", "tag/fiber", "share"] }, { term := "freedom witness" kind := .coinage .theory gloss := "A freedom witness is a countermodel showing that a supposed boundary is not forced by grid data. The being-boundary version permits both split and merge readings of the same fine grid." anchors := [``BeingNegative.no_partition_recovery] seeAlso := ["being-convention", "coarsening"] }, { term := "kenshō" kind := .canonical gloss := "Kenshō ordinarily means seeing nature. In this system it is kept as a countable share-ceding event, not as a possession or stored attainment." anchors := [``Grid.IsShareDrop] seeAlso := ["share", "re-pitch"] }, { term := "call/response" kind := .coinage .theory gloss := "Call/response is the smallest public shape of an occurrence: something arrives and something answers. In the grid this pair is carried by the weld and later inspected by the taxonomy." anchors := [``RawWeld.call, ``RawWeld.response, ``Grid.RecordedUtterance] seeAlso := ["call", "response", "weld"] }, { term := "delivery-engineering" kind := .coinage .theorems gloss := "Delivery-engineering is legal work on what may arrive. Responder-side it finds calls that land; sowing-side it configures aimed calls without commanding the regime." anchors := [``Grid.DirectedConvention.WaaAimedAt, ``Grid.DirectedConvention.HasShareDropLanding] seeAlso := ["delivery", "aimed call"] }, { term := "delivery-arrogation" kind := .coinage .theorems gloss := "Delivery-arrogation is claiming authority over what arrives next. The system treats that as grasping the one register no weld owns." anchors := [``DeliveryArrogationNegative.command_utterance_not_fits] seeAlso := ["delivery-regime", "arrogation"] }, { term := "buddha-side shortfall" kind := .coinage .theorems gloss := "Buddha-side shortfall is failing to meet a not-yet-buddha's call where it is. It is the pole's live grade and is tracked by effectiveness rather than by terminus typing alone." anchors := [``Grid.DirectedConvention.ShortfallClosedAt, ``OrthogonalityNegative.waaFullyEnlightened_stronger_than_terminus] seeAlso := ["effectiveness", "terminus"] }, { term := "backsliding theorem" kind := .coinage .theorems gloss := "The backsliding theorem says a share-drop event cannot be held as a stored attainment. Later live welds are possible because nothing self-indexed is carried between acts." anchors := [``backsliding_witness, ``backsliding_rePitchSequence_witness] seeAlso := ["kenshō", "re-pitch", "seed"] }, { term := "memory theorem" kind := .coinage .theorems gloss := "The memory theorem reads a trace as a seed and remembering as a fresh reception. Felt mineness is predicted at recall-time without being stored before recall." anchors := [``Grid.DirectedConvention.MemoryWitness.memory_witness, ``Grid.DirectedConvention.WaaVacuousOwnershipFace, ``Grid.DirectedConvention.WaaDiachronicWhose] seeAlso := ["seed", "reach-back"] }, { term := "retrospective soul" kind := .coinage .theorems gloss := "The retrospective soul is the error of freezing reach-back into a standing backward owner. It is the psychological version of treating fresh mineness as stored mineness." anchors := [``Grid.DirectedConvention.BeingConvention.GridConvention.sowingReapingRow_not_freeze, ``no_agent_recovery_of_field_collision] seeAlso := ["memory theorem", "reach-back", "standing/dated"] }, { term := "prudence theorem" kind := .coinage .theorems gloss := "The prudence theorem says special authority for self-concern is not recoverable from the grid. The standing cross-gap whose that prudence would need is exactly what the typing declines." anchors := [``Grid.DirectedConvention.PrudentialPrivilegeNegative.not_prudentialPrivilege] seeAlso := ["index-question", "standing/dated"] }, { term := "deliberator theorem" kind := .coinage .theorems gloss := "The deliberator theorem blocks a maximizer at three joints: supplied being-convention, absent accumulator, and failed command over delivery. It is a check on consequentialist reuse of the grid." anchors := [``ObjectiveNegative.no_grid_data_objective_for_my_drops, ``TransferNegative.adaptive_track_record_underdetermines_new_effect, ``DeliveryArrogationNegative.command_utterance_not_fits, ``Grid.ConsequentialistConvention.map_dropCount, ``Grid.ConsequentialistConvention.map_dropCountInFiber] seeAlso := ["being-convention", "re-pitch", "delivery-arrogation"] }, { term := "covariation" kind := .coinage .theorems gloss := "Covariation means two quantities move together without being declared identical in every respect. The dukkha reading covaries with share, ordinally and per call." anchors := [``Grid.WaaMismatchGrade] seeAlso := ["dukkha", "share"] }, { term := "proneness/occurrence" kind := .coinage .theorems gloss := "Proneness is a carried tendency; occurrence is the live event. The dukkha split uses this standing/dated distinction to avoid storing suffering as a bearer." seeAlso := ["dukkha", "seed", "standing/dated"] }, { term := "transposition" kind := .coinage .theorems gloss := "Transposition is the answer to the terminus question: the self-pole index disappears, while reception-side activity for others can still run. Nothing travels from one pole to another." anchors := [``Grid.no_self_pole_index_of_atBot, ``Grid.DirectedConvention.BeingConvention.GridConvention.transposition_erased_downward_collapse_self_refuting] seeAlso := ["terminus", "pole", "object-axis/subject-axis"] }, { term := "kiriya / ahosi" kind := .canonical gloss := "Kiriya and ahosi name action and lapsed fruit in Buddhist idiom around the arhat. In this system the point is derived from share-zero: fruit can land without a live index-question." seeAlso := ["share", "pole", "delivery"] }, { term := "mirror" kind := .canonical gloss := "The mirror is the image of responsive output without possession. In this system it is function without share, legal as a display over a run." anchors := [``Grid.LiveTerminus] seeAlso := ["function", "share", "terminus"] }, { term := "device / device-nature" kind := .coinage .theorems gloss := "A device is a compressed way to speak of pole-like responsiveness. It is legal as display and becomes a freeze when treated as a standing nature owned by a being." seeAlso := ["mirror", "terminus", "collapse/freeze"] }, { term := "maximally adaptive call" kind := .coinage .theorems gloss := "The maximally adaptive call is the limiting case of call-fitting. The system deflates it from the ground of the terminus to the limit where buddha-side shortfall closes." seeAlso := ["fixed/adaptive", "buddha-side shortfall"] }, { term := "generator" kind := .coinage .theorems gloss := "The generator is the taxonomy engine that makes rows from distinctions. Its discipline is that errors must land in existing cells, force a new cell, be declined, or force a retype." anchors := [``Grid.GeneratorOutcome, ``Grid.DirectedConvention.BeingConvention.GridConvention.tableOrder] seeAlso := ["collapse/freeze"] }, { term := "four verdicts" kind := .coinage .theorems gloss := "The four verdicts are existing-cell, new-cell, declined, and retype. They are the public outcomes available when the generator meets a candidate error." anchors := [``Verdict, ``generatorRecord_newCell_count] seeAlso := ["generator"] }, { term := "Sunyata" kind := .canonical gloss := "Sunyata means emptiness. In this system it is the no-final-freeze property of a distinction's re-emptying ladder." anchors := [``Grid.DirectedConvention.BeingConvention.GridConvention.Nishitani.Sunyata] seeAlso := ["collapse/freeze"] }, { term := "direction-underdetermination witness" kind := .coinage .theorems gloss := "This witness shows that symmetric field residue does not determine direction. Two grids can agree on the undirected relation and disagree on the directed one." anchors := [``DirectionNegative.no_direction_recovery_from_conditionsEither] seeAlso := ["arrow", "field"] }, { term := "being-boundary witness" kind := .coinage .theorems gloss := "This witness shows that grid data do not recover a unique being-boundary. Merge and split coarsenings can both be legal over the same fine grid." anchors := [``BeingNegative.no_partition_recovery] seeAlso := ["being-convention", "freedom witness"] }, { term := "weld-boundary witness" kind := .coinage .theorems gloss := "Grid data do not recover a unique weld-segmentation. Merge and split readings of what counts as one call-response pairing are both legal over the same field." anchors := [``WeldNegative.no_weld_boundary_recovery] seeAlso := ["weld", "being-convention", "freedom witness"] }, { term := "intra-weld arrow row" kind := .coinage .theorems gloss := "The intra-weld arrow row checks the call-to-response direction inside a weld as a convention layer. Its content form denies response-variation, and its witness says the unordered residue does not recover an interior arrow." anchors := [``Grid.DirectedConvention.BeingConvention.GridConvention.intraWeldArrowRow, ``Grid.DirectedConvention.BeingConvention.GridConvention.Nishitani.intraWeldArrow_sunyata, ``InteriorDirectionNegative.no_interior_direction_recovery] seeAlso := ["arrow", "weld", "weld-boundary witness"] }, { term := "doer/deed row" kind := .coinage .theorems gloss := "The doer/deed row is the schema-only MMK 8 cell: a prior-doer reading is diagnosed without adding priority as a primitive field of the grid." anchors := [``Grid.DirectedConvention.BeingConvention.GridConvention.doerDeedRow, ``Grid.DirectedConvention.BeingConvention.GridConvention.Nishitani.doerDeed_sunyata, ``DoerDeedNegative.no_priority_recovery] seeAlso := ["weld", "collapse/freeze", "intra-weld arrow row"] }, { term := "coming-to / going-from" kind := .coinage .theory gloss := "Coming-to and going-from are display labels for the two orientation readings of a weld's faces. Transposition reverses the labels; they are not tier names." anchors := [``InteriorDirectionNegative.transpose_swaps_readings, ``InteriorDirectionNegative.no_interior_direction_recovery] seeAlso := ["arrow", "weld", "intra-weld arrow row"] }, { term := "reflexivity witness" kind := .coinage .theorems gloss := "The reflexivity witness instantiates a grid's being carrier with rung labels, showing that the beings ladder still has no final freeze when read over its own indices." anchors := [``Grid.DirectedConvention.BeingConvention.GridConvention.ladderRungGrid_beings_sunyata] seeAlso := ["being-convention", "Sunyata"] }, { term := "weld row / weld śūnyatā" kind := .coinage .theorems gloss := "The weld row names the weld-grain distinction as a convention layer, and weld śūnyatā says its re-emptying ladder has no final frozen level." anchors := [``Grid.DirectedConvention.BeingConvention.GridConvention.weldRow, ``Grid.DirectedConvention.BeingConvention.GridConvention.Nishitani.weld_sunyata] seeAlso := ["collapse/freeze", "Sunyata"] }, { term := "declined case" kind := .coinage .theorems gloss := "A declined case is a candidate that the taxonomy refuses to mark as error. The deaf-blind example matters because over-generating error would itself freeze the lens." anchors := [``InstructiveAbsence.declinedCase] seeAlso := ["four verdicts"] }, { term := "Grade 1 / Grade 2" kind := .coinage .theorems gloss := "Grade 1 names grammatical errors assertable inside the lens; Grade 2 names shortfalls only displayable by the lens. The difference prevents the grid from issuing its own value command." anchors := [``Grid.ErrorGrade, ``Grid.ErrorGrade.voice] seeAlso := ["assert/display"] }, { term := "clenched reception" kind := .coinage .theorems gloss := "A clenched reception is an arriving response taken tightly as mine. It is still graded as a fresh weld, not as evidence of a stored owner." seeAlso := ["clench", "reach-back", "weld"] }, { term := "declining the orange" kind := .coinage .theorems gloss := "Declining the orange is a low-resonance reception of this offered call. It is not a global wrong and does not prove anything about a person." seeAlso := ["orange / eat this", "call"] }, { term := "defiance" kind := .coinage .theorems gloss := "Defiance is arrogation hardened into policy. The fighting stance is a seed, but each fight remains a new act." seeAlso := ["arrogation", "seed", "weld"] }, { term := "cetanā" kind := .canonical gloss := "Cetanā means intention or volition. In this system it is the traditional anchor for the claim that grading tracks the weld rather than the downstream event." anchors := [``Grid.grade_independent_of_conditions, ``Grid.share_independent_of_conditions] seeAlso := ["weld", "grade"] }, { term := "cetanā theorem" kind := .coinage .theorems gloss := "The cetanā theorem is the derived version of intention as karma. It says the grading component follows the weld even where event-success and delivery diverge." anchors := [``Grid.grade_independent_of_conditions, ``Grid.share_independent_of_conditions, ``cetana_grading_tracks_weld_not_field_witness, ``cetana_live_share_without_object_standing_witness] seeAlso := ["cetanā", "weld", "field"] }, { term := "futility theorem" kind := .coinage .theorems gloss := "The futility theorem says the deliberate attempt fails at target and downstream. The body can be staticized as a delivery loss without subtracting object-axis standing." anchors := [``Grid.staticized, ``Grid.futility_delivery_loss_real, ``Grid.futility_object_axis_subtraction_nil, ``Grid.DirectedConvention.staticized_objectAxisStanding_iff] seeAlso := ["delivery", "object-axis/subject-axis", "device / device-nature"] }, { term := "victim-rank" kind := .coinage .theorems gloss := "Victim-rank is severity read from the victim's station. The system treats it as a freeze because rank is being smuggled into what should be per-weld grading." seeAlso := ["grade", "collapse/freeze"] }, { term := "hell-typed" kind := .coinage .theorems gloss := "Hell-typed means a configuration receives no gentler call in the actual delivery-regime. The claim is regime-relative, not a statement about all possible calls." seeAlso := ["delivery-regime", "call"] }, { term := "ledger" kind := .coinage .theorems gloss := "A ledger is a public register that prices what can be counted. In the Huichang case it names an economic modality and the errors produced by reading that modality as a being-sized truth." anchors := [``LedgerCase.decree_engineers_calls_not_receptions, ``LedgerCase.purge_loop_runs_on] seeAlso := ["delivery-regime", "Grade 1 / Grade 2"] }, { term := "economic legibility" kind := .coinage .theorems gloss := "Economic legibility is a field-fact about which configurations a purge can reach. The system can assert that register while only displaying the worth of survival." anchors := [``Grid.DirectedConvention.landing_call_in_modality] seeAlso := ["ledger", "field"] }, { term := "gradeability rule" kind := .coinage .theorems gloss := "The gradeability rule says a recorded utterance may be graded only where the record carries its call. Lean checks both the severed-transcript obstruction and the call-carrying positive form." anchors := [``GradeabilityNegative.no_grade_recovery_from_severed, ``GradeabilityNegative.gradeability_severed_underdetermination_witness, ``recordedUtterance_grade_determined] seeAlso := ["call", "grade", "weld"] }, { term := "transcription" kind := .coinage .theorems gloss := "Transcription turns an adaptive event into a fixed record. In the system the transcript is a seed-like fixed call, not a stored fault in the words." seeAlso := ["fixed/adaptive", "seed", "call"] }, { term := "per-call/global freeze" kind := .coinage .theorems gloss := "The per-call/global freeze turns a local grade into a global rank. It is the error behind treating stages, awakening, or census categories as stored altitude." anchors := [``Grid.DirectedConvention.BeingConvention.GridConvention.RowTag.perCallGlobal] seeAlso := ["grade", "collapse/freeze"] }, { term := "subitism/gradualism" kind := .canonical gloss := "Subitism and gradualism name sudden and staged arrival patterns. The system permits both as run shapes while refusing to store a rate preference as attainment." anchors := [``Grid.WaaSuddenArrival, ``Grid.WaaGradualArrival, ``Grid.rate_invisible_to_config, ``SuddenGradualNegative.subitism_frequency_underdetermined] seeAlso := ["re-pitch", "per-call/global freeze"] }, { term := "PathFactor" kind := .leanConvention gloss := "PathFactor names the factor-side regrouping of the existing fetter table. Rites, view, and resolve are active; speech and conduct are named but inert until the upper-pair question is settled." anchors := [``PathFactor, ``PathFactor.blockerClass] seeAlso := ["coarsening", "tag/fiber"] }, { term := "FactorHeld" kind := .leanConvention gloss := "FactorHeld is a seen-run witness: an actual in-fiber weld in the factor blocker class carries a live self-pole index. It is not itself an error; it is factor-frame vocabulary, not freeze/collapse and not clench alone." anchors := [``Grid.FactorHeld] seeAlso := ["PathFactor", "clench", "weld"] }, { term := "FactorReleased" kind := .leanConvention gloss := "FactorReleased is the release half of the factor pair: the fiber is at pole on the factor blocker class. One actual live weld in that class refutes it." anchors := [``Grid.FactorReleased, ``Grid.not_factorHeld_of_factorReleased] seeAlso := ["PathFactor", "FactorHeld", "pole"] }, { term := "WaaStreamEnterer" kind := .leanConvention gloss := "WaaStreamEnterer is the path-position reading over the first pair: rites released, view held on the seen run. It deliberately separates path display from the fruit cut." anchors := [``Grid.WaaStreamEnterer] seeAlso := ["FactorHeld", "FactorReleased"] }, { term := "WaaStreamWinner" kind := .leanConvention gloss := "WaaStreamWinner is the fruit-position reading for stream entry: rites and view are released, and Lean proves it coincides with the existing stream-entry cut class. The terminology is a checked departure from treating sotapanna as only one undivided label." anchors := [``Grid.WaaStreamWinner, ``Grid.waaStreamWinner_iff_streamEntry_cutClasses] seeAlso := ["WaaStreamEnterer", "FactorReleased"] }, { term := "WaaOnceReturner" kind := .leanConvention gloss := "WaaOnceReturner keeps the stream-winning fruit and adds a witnessed resolve hold on the seen run. Its extra checked content is attenuation, not a new cut class." anchors := [``Grid.WaaOnceReturner] seeAlso := ["WaaStreamWinner", "FactorHeld"] }, { term := "WaaNonReturner" kind := .leanConvention gloss := "WaaNonReturner is the fruit-position reading after resolve release. Lean proves it is exactly the non-return cut class, so the factor scheme remains a reading over the fetter lattice." anchors := [``Grid.WaaNonReturner, ``Grid.waaNonReturner_iff_nonReturn_cut] seeAlso := ["WaaOnceReturner", "FactorReleased"] }, { term := "WaaResolveAttenuation" kind := .leanConvention gloss := "WaaResolveAttenuation gives once-return positive content: a strict resolve-class share-drop run whose final tendency has not reached the pole." anchors := [``Grid.WaaResolveAttenuation, ``Grid.waaOnceReturner_attenuation_witness, ``Grid.attenuation_not_release] seeAlso := ["WaaOnceReturner", "re-pitch"] }, { term := "WaaSerialFactorRegime" kind := .leanConvention gloss := "WaaSerialFactorRegime is the conditional voice for factor order. If the supplied regime reads seen share-drops as rites before view before resolve, it promotes path readings to fruit readings; the grid never derives the regime or any frequency claim." anchors := [``Grid.WaaSerialFactorRegime, ``Grid.waaSerialFactorRegime_conditional, ``FactorsNegative.seen_run_underdetermines_factorOrder] seeAlso := ["WaaResolveAttenuation", "subitism/gradualism"] }, { term := "śraddhā" kind := .canonical gloss := "Śraddhā means faith or trust. In this system it is modeled as an antecedent for testimony and path response, never as a field fact the grid can discharge by itself." anchors := [``Grid.DirectedConvention.WaaFaithPrinciple, ``Grid.DirectedConvention.waaFaithOught_conditional] seeAlso := ["buddha-side shortfall", "delivery"] }, { term := "icchantika" kind := .canonical gloss := "Icchantika ordinarily names a being cut off from buddhahood. Here it is the terminus's inverse: non-stone, with a live self-pole index at every mounted response. It is reachable as a receiver and cannot be seated as an enlightened agent on its run. The permanent cannot-become-buddha verdict is declined, because foreclosure would be a stored rank the system forbids; defiance is a seed, not a rank." anchors := [``Icchantika, ``not_waaFullyEnlightened_of_icchantika, ``aversionContext_of_icchantika_reception, ``icchantika_release_not_foreclosed] seeAlso := ["defiance", "terminus", "backsliding theorem", "śraddhā"] }, { term := "tariki / other-power" kind := .canonical gloss := "Tariki means other-power. In this system it is a delivery-regime reading, not a second act-grammar: the reception is still an ordinary weld." anchors := [``Grid.DirectedConvention.WaaTarikiLine, ``Grid.DirectedConvention.reception_typing_ignores_sower, ``TarikiCase.universal_fixed_call_lands_without_reading, ``OtherPowerNegative.regime_does_not_determine_share] seeAlso := ["delivery-regime", "weld"] }, { term := "pariṇāmanā / dedication" kind := .canonical gloss := "Pariṇāmanā means dedication or turning over merit. In this system it is sowing-side share-cession whose routing is left to delivery rather than commanded by the act." anchors := [``Grid.DirectedConvention.BeingConvention.GridConvention.CompoundPosition.ledgerPicture, ``Grid.DirectedConvention.BeingConvention.GridConvention.CompoundPosition.ledgerPicture_decomposition, ``Grid.DirectedConvention.BeingConvention.GridConvention.CompoundPosition.ledgerPicture_contains_legal_causalSkeleton, ``Grid.DirectedConvention.SameAgentDelivery, ``Grid.DirectedConvention.CrossAgentDelivery, ``Grid.DirectedConvention.reception_typing_ignores_sower, ``OtherPowerNegative.regime_does_not_determine_share, ``OtherPowerNegative.share_does_not_determine_regime] seeAlso := ["share", "delivery-regime", "aimed call"] }, { term := "instructive absences" kind := .coinage .theorems gloss := "Instructive absences are gaps the system keeps because they do diagnostic work. Lean mirrors them as data with status and numbering rather than treating them as forgotten cases." anchors := [``InstructiveAbsence, ``InstructiveAbsence.status, ``InstructiveAbsence.number] seeAlso := ["declined case", "generator"] }, { term := "identification claim" kind := .coinage .identification gloss := "The identification claim says karma names the loop where the field carries diachronic relations and the weld enacts every index. It is a decomposition claim, not a stored-self claim." seeAlso := ["field", "weld", "index-question"] }, { term := "state-designation vs. act-fixing" kind := .coinage .identification gloss := "State-designation names something over a standing base at a time; act-fixing makes the relevant index in the act itself. The contrast blocks a state-tool from ranging over karmic ownership." anchors := [``Grid.stateToolFits_iff_atBot] seeAlso := ["standing/dated", "weld"] }, { term := "offices-spine" kind := .coinage .identification gloss := "The offices-spine is the list of traditional places where karmic ownership has work to do. The identification argues that each office discharges at act-time." anchors := [``WaaOwnershipOffice] seeAlso := ["identification claim", "weld"] }, { term := "thin for-me-ness" kind := .coinage .identification gloss := "Thin for-me-ness is pre-reflective givenness without appropriation. The system keeps the token-reflexive light needed by the weld and removes standing ownership." seeAlso := ["weld", "arrogation"] }, { term := "Sartrean occupant" kind := .coinage .identification gloss := "The Sartrean occupant is the remaining inhabitant of clench-as-structure after thin for-me-ness is pared back. It names anguish as a structure, not ownership as a stored thing." seeAlso := ["thin for-me-ness", "clench"] }, { term := "sower-reaps split" kind := .coinage .identification gloss := "The sower-reaps split separates the report that a delivery line exists from the ownership face made at reception. It keeps true field reporting away from standing ownership." anchors := [``Grid.DirectedConvention.WaaReportFace, ``Grid.DirectedConvention.WaaOwnershipFace, ``Grid.DirectedConvention.WaaVacuousOwnershipFace] seeAlso := ["delivery", "reach-back"] }, { term := "pole-typing corollary" kind := .coinage .identification gloss := "The pole-typing corollary says the state-tool fits exactly where live welding ceases. At share-zero there is no live self-pole index for the tool to miss." anchors := [``Grid.stateToolFits_iff_atBot, ``Grid.no_self_pole_index_of_atBot] seeAlso := ["pole", "index-question"] }, { term := "soul-guard" kind := .coinage .identification gloss := "The soul-guard blocks storage by making the agent more empty, not more substantial. Both forward-facing and retrospective bearers are declined." anchors := [``no_agent_recovery_of_field_collision] seeAlso := ["field", "weld"] }, { term := "being trichotomy" kind := .coinage .identification gloss := "The being trichotomy gives three readings: collapse deletes beings, freeze reifies a partition, and convention leaves naming free. It keeps designation useful without making it metaphysical." anchors := [``Disclaimer.beingTrichotomy] seeAlso := ["being-convention", "collapse/freeze"] }, { term := "hare's horn" kind := .canonical gloss := "A hare's horn is the stock example of something nameable but unrealizable. In this system it shows that designation is constrained at use, not at the mere act of naming." anchors := [``Disclaimer.hareHornRegister] seeAlso := ["being-convention"] }, { term := "Modal Realism" kind := .canonical gloss := "Modal Realism treats possible beings as fully real. In this system it is the beings-row freeze: plenitude moved into ontology rather than left as conventional designation." anchors := [``Disclaimer.modalRealismFreeze] seeAlso := ["being trichotomy", "collapse/freeze"] }, { term := "disclaimers" kind := .coinage .identification gloss := "The disclaimers are the paper's explicit flags for original or non-canonical moves. They say which precision remains prose even when Lean checks anchors, numbering, and structural constraints." anchors := [``Disclaimer, ``Disclaimer.number] seeAlso := ["instructive absences"] } ] /- ============================================================================== Structural checks ============================================================================== -/ def glossaryTerms : List String := glossary.map (fun entry => entry.term) /-- Every `seeAlso` target must have appeared earlier in the curated order. -/ def seeAlsoTargetsEarlierFrom (seen : List String) : List GlossaryEntry -> Bool | [] => true | entry :: rest => entry.seeAlso.all (fun target => seen.contains target) && seeAlsoTargetsEarlierFrom (entry.term :: seen) rest def seeAlsoTargetsEarlier : Bool := seeAlsoTargetsEarlierFrom [] glossary example : glossary.length = 140 := rfl example : glossaryTerms.Nodup := by native_decide example : seeAlsoTargetsEarlier = true := by native_decide /- ============================================================================== Anchor verifier ============================================================================== -/ open Lean Elab Command Meta syntax (name := verifyGlossaryAnchors) "#verify_glossary_anchors" : command unsafe def evalGlossaryEntries : Term.TermElabM (List GlossaryEntry) := do evalExpr (List GlossaryEntry) (mkApp (mkConst ``List [Level.zero]) (mkConst ``GlossaryEntry)) (mkConst ``glossary) @[command_elab verifyGlossaryAnchors] unsafe def elabVerifyGlossaryAnchors : CommandElab := fun _stx => do let entries <- liftTermElabM evalGlossaryEntries let env <- getEnv let mut missing : Array String := #[] for entry in entries do for anchor in entry.anchors do unless env.contains anchor do missing := missing.push s!"{entry.term}: {anchor}" unless missing.isEmpty do let details := missing.foldl (fun acc item => acc ++ "\n" ++ item) "" throwError m!"missing glossary anchors:{details}" #verify_glossary_anchors end WAA ===== FILE: WeldAndArrow/Meta/Invariance.lean ===== /- ================================================================================ WeldAndArrow.Meta.Invariance Display reparameterization and transport lemmas ================================================================================ This module transports grid predicates across display reparameterizations and keeps transport lemmas centralized so missing invariance facts are conspicuous. Reading and motivation: Identification/Commentary.lean, C.3. -/ import WeldAndArrow.Consequences.ContentRows import WeldAndArrow.Signature.DirectionConvention import WeldAndArrow.Identification import WeldAndArrow.Doctrines.Deliberation import WeldAndArrow.Doctrines.Sraddha import WeldAndArrow.Doctrines.Faith import WeldAndArrow.Doctrines.Correlations /-! Any predicate over the contribution carrier added anywhere in the library owes a `map_*` transport lemma in this file, or it counts as operational residue. Transport lemmas stay centralized here so a missing lemma is conspicuous. -/ namespace WAA /-- A display-reparameterization: preserves and reflects the ordering and the pole-class. The invariance theorems below are the formal content of "display conventions over that partial order". -/ structure DisplayReparam (Contrib Contrib' : Type) [PreorderBot Contrib] [PreorderBot Contrib'] where toFun : Contrib → Contrib' le_iff : ∀ a b, a ≼ b ↔ toFun a ≼ toFun b atBot_bot : AtBot (toFun shareBot) namespace DisplayReparam variable {Contrib Contrib' : Type} [PreorderBot Contrib] [PreorderBot Contrib'] variable (f : DisplayReparam Contrib Contrib') /-- The identity display reparameterization. -/ protected def id (Contrib : Type) [PreorderBot Contrib] : DisplayReparam Contrib Contrib where toFun := id le_iff := fun _ _ => Iff.rfl atBot_bot := atBot_shareBot @[simp] theorem id_toFun (a : Contrib) : (DisplayReparam.id Contrib).toFun a = a := rfl /-- Composition of display reparameterizations. -/ def comp {Contrib'' : Type} [PreorderBot Contrib''] (f : DisplayReparam Contrib Contrib') (g : DisplayReparam Contrib' Contrib'') : DisplayReparam Contrib Contrib'' where toFun := fun a => g.toFun (f.toFun a) le_iff := fun a b => (f.le_iff a b).trans (g.le_iff (f.toFun a) (f.toFun b)) atBot_bot := Preorder.le_trans ((g.le_iff (f.toFun shareBot) shareBot).mp f.atBot_bot) g.atBot_bot @[simp] theorem comp_toFun {Contrib'' : Type} [PreorderBot Contrib''] (f : DisplayReparam Contrib Contrib') (g : DisplayReparam Contrib' Contrib'') (a : Contrib) : (DisplayReparam.comp f g).toFun a = g.toFun (f.toFun a) := rfl /-- Reparameterization preserves and reflects the pole-class. -/ theorem atBot_iff (a : Contrib) : AtBot (f.toFun a) ↔ AtBot a := by constructor · intro h exact (f.le_iff a shareBot).mpr (Preorder.le_trans h (shareBot_le (f.toFun shareBot))) · intro h exact Preorder.le_trans ((f.le_iff a shareBot).mp h) f.atBot_bot /-- Reparameterization preserves and reflects order-equivalence. -/ theorem orderEq_iff (a b : Contrib) : OrderEq (f.toFun a) (f.toFun b) ↔ OrderEq a b := by constructor · intro h exact ⟨(f.le_iff a b).mpr h.left, (f.le_iff b a).mpr h.right⟩ · intro h exact ⟨(f.le_iff a b).mp h.left, (f.le_iff b a).mp h.right⟩ theorem strict_iff (a b : Contrib) : Strict (f.toFun a) (f.toFun b) ↔ Strict a b := by constructor · intro h exact ⟨(f.le_iff a b).mpr h.left, fun hle => h.right ((f.le_iff b a).mp hle)⟩ · intro h exact ⟨(f.le_iff a b).mp h.left, fun hle => h.right ((f.le_iff b a).mpr hle)⟩ theorem directionVoid_reflect (f : DisplayReparam Contrib Contrib') (h : DirectionVoid Contrib') : DirectionVoid Contrib := fun a b hstrict => h (f.toFun a) (f.toFun b) ((f.strict_iff a b).mpr hstrict) /-- Full preservation of carrier-wide direction-voidness needs the target display to be covered by the reparameterization. `CoverageNegative.directionVoid_needs_coverage` shows the hypothesis is needed. -/ theorem directionVoid_of_surjective (hsurj : ∀ b : Contrib', ∃ a : Contrib, f.toFun a = b) (h : DirectionVoid Contrib) : DirectionVoid Contrib' := by intro a' b' hstrict rcases hsurj a' with ⟨a, rfl⟩ rcases hsurj b' with ⟨b, rfl⟩ exact h a b ((f.strict_iff a b).mp hstrict) theorem exists_strict_map (f : DisplayReparam Contrib Contrib') (h : ∃ a b : Contrib, Strict a b) : ∃ a' b' : Contrib', Strict a' b' := by rcases h with ⟨a, b, hstrict⟩ exact ⟨f.toFun a, f.toFun b, (f.strict_iff a b).mpr hstrict⟩ end DisplayReparam namespace Config variable {Contrib Contrib' : Type} [PreorderBot Contrib] [PreorderBot Contrib'] /-- Transport a stored display tendency along a display reparameterization. -/ def map (before : Config Contrib) (f : DisplayReparam Contrib Contrib') : Config Contrib' := { tendency := f.toFun before.tendency } @[simp] theorem map_tendency (before : Config Contrib) (f : DisplayReparam Contrib Contrib') : (before.map f).tendency = f.toFun before.tendency := rfl end Config namespace Grid variable {Contrib Contrib' : Type} [PreorderBot Contrib] [PreorderBot Contrib'] /-- Transport a grid by reparameterizing only its Row-2 display carrier. -/ def map (G : Grid Contrib) (f : DisplayReparam Contrib Contrib') : Grid Contrib' where Being := G.Being Call := G.Call Response := G.Response respondsTo := G.respondsTo grade := fun b c r => f.toFun (G.grade b c r) conditions := G.conditions variable (G : Grid Contrib) (f : DisplayReparam Contrib Contrib') @[simp] theorem map_grade (b : G.Being) (c : G.Call) (r : G.Response) : (G.map f).grade b c r = f.toFun (G.grade b c r) := rfl @[simp] theorem map_share (w : G.Weld) : (G.map f).share w = f.toFun (G.share w) := rfl theorem map_transpose : (G.map f).transpose = G.transpose.map f := rfl theorem map_staticized [h : DecidableEq G.Being] (b : G.Being) : @Grid.staticized Contrib' _ (G.map f) h b = (@Grid.staticized Contrib _ G h b).map f := rfl /-- Function-side predicates do not mention the contribution carrier, so they transport by definitional unfolding. -/ theorem map_actual_iff (w : G.Weld) : (G.map f).Actual w ↔ G.Actual w := Iff.rfl theorem map_exists_actual_iff : (∃ w : (G.map f).Weld, (G.map f).Actual w) ↔ ∃ w : G.Weld, G.Actual w := by constructor · rintro ⟨w, hactual⟩ exact ⟨w, (G.map_actual_iff f w).mp hactual⟩ · rintro ⟨w, hactual⟩ exact ⟨w, (G.map_actual_iff f w).mpr hactual⟩ namespace ActualWeld /-- Transport an actual weld along a display reparameterization. The weld is the same occurrence; only the contribution display has moved. -/ def map {G : Grid Contrib} (f : DisplayReparam Contrib Contrib') : ActualWeld G -> ActualWeld (G.map f) | ⟨w, h⟩ => ⟨w, (G.map_actual_iff f w).mpr h⟩ @[simp] theorem map_weld {G : Grid Contrib} (f : DisplayReparam Contrib Contrib') (aw : ActualWeld G) : (aw.map f).weld = aw.weld := rfl end ActualWeld theorem map_mountsAt_iff (b : G.Being) (c : G.Call) : (G.map f).MountsAt b c ↔ G.MountsAt b c := Iff.rfl theorem map_mountsSomewhere_iff (b : G.Being) : (G.map f).MountsSomewhere b ↔ G.MountsSomewhere b := Iff.rfl theorem map_respondsToEveryCall_iff (b : G.Being) : (G.map f).RespondsToEveryCall b ↔ G.RespondsToEveryCall b := Iff.rfl theorem map_responseVariesWithCall_iff (b : G.Being) : (G.map f).ResponseVariesWithCall b ↔ G.ResponseVariesWithCall b := Iff.rfl theorem map_stone_iff (b : G.Being) : (G.map f).Stone b ↔ G.Stone b := Iff.rfl theorem map_allStone_iff : (G.map f).AllStone ↔ G.AllStone := by constructor · intro h b exact (G.map_stone_iff f b).mp (h b) · intro h b exact (G.map_stone_iff f b).mpr (h b) namespace DirectedConvention theorem map_deliveredTo_iff (deed reception : G.Weld) : DeliveredTo (G.map f) deed reception ↔ DeliveredTo G deed reception := Iff.rfl theorem map_landsAt_iff (deed reception : G.Weld) : LandsAt (G.map f) deed reception ↔ LandsAt G deed reception := Iff.rfl theorem map_environsLine_iff (b : G.Being) (deed reception : G.Weld) : EnvironsLine (G.map f) b deed reception ↔ EnvironsLine G b deed reception := Iff.rfl namespace DirectionCoarsening variable {G : Grid Contrib} {Tick : Type} /-- Direction-coarsening transported across a display reparameterization. Ticks are display-side data over unchanged welds. -/ def displayMapDir (ρ : DirectionCoarsening G Tick) (f : DisplayReparam Contrib Contrib') : DirectionCoarsening (G.map f) Tick where tick := ρ.tick theorem mapDir_sameTick_iff (ρ : DirectionCoarsening G Tick) (f : DisplayReparam Contrib Contrib') (w₁ w₂ : G.Weld) : (displayMapDir ρ f).SameTick w₁ w₂ ↔ ρ.SameTick w₁ w₂ := Iff.rfl theorem mapDir_resolutionBounded_iff (ρ : DirectionCoarsening G Tick) (f : DisplayReparam Contrib Contrib') : (displayMapDir ρ f).ResolutionBounded ↔ ρ.ResolutionBounded := by constructor · intro h w₁ w₂ hsame have hmapped : OrderEq (f.toFun (G.share w₁)) (f.toFun (G.share w₂)) := by simpa [Grid.map_share] using h w₁ w₂ hsame exact (f.orderEq_iff (G.share w₁) (G.share w₂)).mp hmapped · intro h w₁ w₂ hsame have horig : OrderEq (G.share w₁) (G.share w₂) := h w₁ w₂ hsame have hmapped : OrderEq (f.toFun (G.share w₁)) (f.toFun (G.share w₂)) := (f.orderEq_iff (G.share w₁) (G.share w₂)).mpr horig simpa [Grid.map_share] using hmapped /-- If the display reparameterization collapses within-tick shares to order-equivalence in the target, the mapped grid is resolution-bounded. -/ theorem resolutionBounded_of_reparam_collapses (ρ : DirectionCoarsening G Tick) (f : DisplayReparam Contrib Contrib') (hcollapse : ∀ w₁ w₂ : G.Weld, ρ.SameTick w₁ w₂ -> OrderEq (f.toFun (G.share w₁)) (f.toFun (G.share w₂))) : (displayMapDir ρ f).ResolutionBounded := by intro w₁ w₂ hsame simpa [Grid.map_share] using hcollapse w₁ w₂ hsame end DirectionCoarsening end DirectedConvention theorem map_terminus_iff (b : G.Being) : (G.map f).Terminus b ↔ G.Terminus b := by constructor · intro h c r hresp exact (f.atBot_iff (G.grade b c r)).mp (h c r hresp) · intro h c r hresp exact (f.atBot_iff (G.grade b c r)).mpr (h c r hresp) theorem map_liveTerminus_iff (b : G.Being) : (G.map f).LiveTerminus b ↔ G.LiveTerminus b := by constructor · intro h exact ⟨(G.map_mountsSomewhere_iff f b).mp h.left, (G.map_terminus_iff f b).mp h.right⟩ · intro h exact ⟨(G.map_mountsSomewhere_iff f b).mpr h.left, (G.map_terminus_iff f b).mpr h.right⟩ theorem map_responsiveTerminus_iff (b : G.Being) : (G.map f).ResponsiveTerminus b ↔ G.ResponsiveTerminus b := by constructor · intro h exact ⟨(G.map_respondsToEveryCall_iff f b).mp h.left, (G.map_terminus_iff f b).mp h.right⟩ · intro h exact ⟨(G.map_respondsToEveryCall_iff f b).mpr h.left, (G.map_terminus_iff f b).mpr h.right⟩ theorem map_atPoleClass_iff (b : G.Being) : (G.map f).AtPoleClass b ↔ G.AtPoleClass b := by constructor · intro h exact h.elim (fun hstone => Or.inl ((G.map_stone_iff f b).mp hstone)) (fun hterm => Or.inr ((G.map_terminus_iff f b).mp hterm)) · intro h exact h.elim (fun hstone => Or.inl ((G.map_stone_iff f b).mpr hstone)) (fun hterm => Or.inr ((G.map_terminus_iff f b).mpr hterm)) theorem map_hasSelfPoleIndex_iff (w : G.Weld) : (G.map f).HasSelfPoleIndex w ↔ G.HasSelfPoleIndex w := by constructor · intro h hbot exact h ((f.atBot_iff (G.share w)).mpr hbot) · intro h hbot exact h ((f.atBot_iff (G.share w)).mp hbot) @[simp] theorem map_waaMismatchGrade (w : G.Weld) : (G.map f).WaaMismatchGrade w = f.toFun (G.WaaMismatchGrade w) := rfl theorem map_waaMismatchLive_iff (w : G.Weld) : (G.map f).WaaMismatchLive w ↔ G.WaaMismatchLive w := by constructor · intro h exact ⟨(G.map_actual_iff f w).mp h.left, (G.map_hasSelfPoleIndex_iff f w).mp h.right⟩ · intro h exact ⟨(G.map_actual_iff f w).mpr h.left, (G.map_hasSelfPoleIndex_iff f w).mpr h.right⟩ theorem map_probeConstant_iff (b : G.Being) (cs : G.Call → Prop) : (G.map f).ProbeConstant b cs ↔ G.ProbeConstant b cs := by constructor · intro h c₁ c₂ hc₁ hc₂ r₁ r₂ hr₁ hr₂ exact (f.orderEq_iff (G.grade b c₁ r₁) (G.grade b c₂ r₂)).mp (h c₁ c₂ hc₁ hc₂ r₁ r₂ hr₁ hr₂) · intro h c₁ c₂ hc₁ hc₂ r₁ r₂ hr₁ hr₂ exact (f.orderEq_iff (G.grade b c₁ r₁) (G.grade b c₂ r₂)).mpr (h c₁ c₂ hc₁ hc₂ r₁ r₂ hr₁ hr₂) theorem map_waaBullSeven_iff (b : G.Being) : (G.map f).WaaBullSeven b ↔ G.WaaBullSeven b := by constructor · rintro ⟨hprobe, w, hactual, hagent, hidx⟩ exact ⟨(G.map_probeConstant_iff f b (fun _ => True)).mp hprobe, ⟨w, (G.map_actual_iff f w).mp hactual, hagent, (G.map_hasSelfPoleIndex_iff f w).mp hidx⟩⟩ · rintro ⟨hprobe, w, hactual, hagent, hidx⟩ exact ⟨(G.map_probeConstant_iff f b (fun _ => True)).mpr hprobe, ⟨w, (G.map_actual_iff f w).mpr hactual, hagent, (G.map_hasSelfPoleIndex_iff f w).mpr hidx⟩⟩ namespace DirectedConvention namespace BeingConvention namespace BeingCoarsening variable {G : Grid Contrib} {Macro : Type} /-- Transport a diagnosis-time being coarsening across a display reparameterization. The fine tags are unchanged; only Row-2 display values move. -/ def displayMap (κ : BeingCoarsening G Macro) (f : DisplayReparam Contrib Contrib') : BeingCoarsening (G.map f) Macro where proj := κ.proj theorem map_inFiber_iff (κ : BeingCoarsening G Macro) (f : DisplayReparam Contrib Contrib') (b : Macro) (w : G.Weld) : (displayMap κ f).InFiber b w ↔ κ.InFiber b w := Iff.rfl theorem map_sameFiber_iff (κ : BeingCoarsening G Macro) (f : DisplayReparam Contrib Contrib') (p q : G.Being) : (displayMap κ f).SameFiber p q ↔ κ.SameFiber p q := Iff.rfl theorem map_fiberInhabited_iff (κ : BeingCoarsening G Macro) (f : DisplayReparam Contrib Contrib') (b : Macro) : (displayMap κ f).FiberInhabited b ↔ κ.FiberInhabited b := Iff.rfl theorem map_actualFiberInhabited_iff (κ : BeingCoarsening G Macro) (f : DisplayReparam Contrib Contrib') (b : Macro) : (displayMap κ f).ActualFiberInhabited b ↔ κ.ActualFiberInhabited b := by constructor · rintro ⟨w, hactual, hfiber⟩ exact ⟨w, (G.map_actual_iff f w).mp hactual, hfiber⟩ · rintro ⟨w, hactual, hfiber⟩ exact ⟨w, (G.map_actual_iff f w).mpr hactual, hfiber⟩ theorem map_sentientTag_iff (κ : BeingCoarsening G Macro) (f : DisplayReparam Contrib Contrib') (b : Macro) : (displayMap κ f).SentientTag b ↔ κ.SentientTag b := by constructor · rintro ⟨p, hp, hmounts⟩ exact ⟨p, hp, (G.map_mountsSomewhere_iff f p).mp hmounts⟩ · rintro ⟨p, hp, hmounts⟩ exact ⟨p, hp, (G.map_mountsSomewhere_iff f p).mpr hmounts⟩ theorem map_fiberAtPole_iff (κ : BeingCoarsening G Macro) (f : DisplayReparam Contrib Contrib') (b : Macro) : (displayMap κ f).FiberAtPole b ↔ κ.FiberAtPole b := by constructor · intro h w hactual hfiber have hmapped : AtBot (f.toFun (G.share w)) := by simpa [Grid.map_share] using h w ((G.map_actual_iff f w).mpr hactual) hfiber exact (f.atBot_iff (G.share w)).mp hmapped · intro h w hactual hfiber have horig : AtBot (G.share w) := h w ((G.map_actual_iff f w).mp hactual) hfiber have hmapped : AtBot (f.toFun (G.share w)) := (f.atBot_iff (G.share w)).mpr horig simpa [Grid.map_share] using hmapped theorem map_actualFiberInhabitedOn_iff (κ : BeingCoarsening G Macro) (f : DisplayReparam Contrib Contrib') (b : Macro) (cs : G.Call → Prop) : (displayMap κ f).ActualFiberInhabitedOn b cs ↔ κ.ActualFiberInhabitedOn b cs := by constructor · rintro ⟨w, hactual, hfiber, hclass⟩ exact ⟨w, (G.map_actual_iff f w).mp hactual, hfiber, hclass⟩ · rintro ⟨w, hactual, hfiber, hclass⟩ exact ⟨w, (G.map_actual_iff f w).mpr hactual, hfiber, hclass⟩ theorem map_actualFiberInhabitedWithin_iff (κ : BeingCoarsening G Macro) (f : DisplayReparam Contrib Contrib') (b : Macro) (ts : G.Being → Prop) : (displayMap κ f).ActualFiberInhabitedWithin b ts ↔ κ.ActualFiberInhabitedWithin b ts := by constructor · rintro ⟨w, hactual, hfiber, htag⟩ exact ⟨w, (G.map_actual_iff f w).mp hactual, hfiber, htag⟩ · rintro ⟨w, hactual, hfiber, htag⟩ exact ⟨w, (G.map_actual_iff f w).mpr hactual, hfiber, htag⟩ theorem map_fiberAtPoleOn_iff (κ : BeingCoarsening G Macro) (f : DisplayReparam Contrib Contrib') (b : Macro) (cs : G.Call → Prop) : (displayMap κ f).FiberAtPoleOn b cs ↔ κ.FiberAtPoleOn b cs := by constructor · intro h w hactual hfiber hclass have hmapped : AtBot (f.toFun (G.share w)) := by simpa [Grid.map_share] using h w ((G.map_actual_iff f w).mpr hactual) hfiber hclass exact (f.atBot_iff (G.share w)).mp hmapped · intro h w hactual hfiber hclass have horig : AtBot (G.share w) := h w ((G.map_actual_iff f w).mp hactual) hfiber hclass have hmapped : AtBot (f.toFun (G.share w)) := (f.atBot_iff (G.share w)).mpr horig simpa [Grid.map_share] using hmapped theorem map_fiberAtPoleOnWithin_iff (κ : BeingCoarsening G Macro) (f : DisplayReparam Contrib Contrib') (b : Macro) (cs : G.Call → Prop) (ts : G.Being → Prop) : (displayMap κ f).FiberAtPoleOnWithin b cs ts ↔ κ.FiberAtPoleOnWithin b cs ts := by constructor · intro h w hactual hfiber hclass htag have hmapped : AtBot (f.toFun (G.share w)) := by simpa [Grid.map_share] using h w ((G.map_actual_iff f w).mpr hactual) hfiber hclass htag exact (f.atBot_iff (G.share w)).mp hmapped · intro h w hactual hfiber hclass htag have horig : AtBot (G.share w) := h w ((G.map_actual_iff f w).mp hactual) hfiber hclass htag have hmapped : AtBot (f.toFun (G.share w)) := (f.atBot_iff (G.share w)).mpr horig simpa [Grid.map_share] using hmapped theorem map_fiberAtPoleWithin_iff (κ : BeingCoarsening G Macro) (f : DisplayReparam Contrib Contrib') (b : Macro) (ts : G.Being → Prop) : (displayMap κ f).FiberAtPoleWithin b ts ↔ κ.FiberAtPoleWithin b ts := map_fiberAtPoleOnWithin_iff κ f b (fun _ => True) ts theorem map_liveFiberAtPoleOn_iff (κ : BeingCoarsening G Macro) (f : DisplayReparam Contrib Contrib') (b : Macro) (cs : G.Call → Prop) : (displayMap κ f).LiveFiberAtPoleOn b cs ↔ κ.LiveFiberAtPoleOn b cs := by constructor · intro h exact ⟨(map_actualFiberInhabitedOn_iff κ f b cs).mp h.left, (map_fiberAtPoleOn_iff κ f b cs).mp h.right⟩ · intro h exact ⟨(map_actualFiberInhabitedOn_iff κ f b cs).mpr h.left, (map_fiberAtPoleOn_iff κ f b cs).mpr h.right⟩ theorem map_liveFiberAtPoleWithin_iff (κ : BeingCoarsening G Macro) (f : DisplayReparam Contrib Contrib') (b : Macro) (ts : G.Being → Prop) : (displayMap κ f).LiveFiberAtPoleWithin b ts ↔ κ.LiveFiberAtPoleWithin b ts := by constructor · intro h exact ⟨(map_actualFiberInhabitedWithin_iff κ f b ts).mp h.left, (map_fiberAtPoleWithin_iff κ f b ts).mp h.right⟩ · intro h exact ⟨(map_actualFiberInhabitedWithin_iff κ f b ts).mpr h.left, (map_fiberAtPoleWithin_iff κ f b ts).mpr h.right⟩ theorem map_liveFiberAtPole_iff (κ : BeingCoarsening G Macro) (f : DisplayReparam Contrib Contrib') (b : Macro) : (displayMap κ f).LiveFiberAtPole b ↔ κ.LiveFiberAtPole b := by constructor · intro h exact ⟨(map_actualFiberInhabited_iff κ f b).mp h.left, (map_fiberAtPole_iff κ f b).mp h.right⟩ · intro h exact ⟨(map_actualFiberInhabited_iff κ f b).mpr h.left, (map_fiberAtPole_iff κ f b).mpr h.right⟩ theorem map_selfAptTag_iff (κ : BeingCoarsening G Macro) (f : DisplayReparam Contrib Contrib') (b : Macro) : (displayMap κ f).SelfAptTag b ↔ κ.SelfAptTag b := by constructor · intro h w hactual hfiber have hidx : (G.map f).HasSelfPoleIndex w := h w ((G.map_actual_iff f w).mpr hactual) hfiber exact (G.map_hasSelfPoleIndex_iff f w).mp hidx · intro h w hactual hfiber have hidx : G.HasSelfPoleIndex w := h w ((G.map_actual_iff f w).mp hactual) hfiber exact (G.map_hasSelfPoleIndex_iff f w).mpr hidx theorem map_selfAptTagWithin_iff (κ : BeingCoarsening G Macro) (f : DisplayReparam Contrib Contrib') (b : Macro) (ts : G.Being → Prop) : (displayMap κ f).SelfAptTagWithin b ts ↔ κ.SelfAptTagWithin b ts := by constructor · intro h w hactual hfiber htag have hidx : (G.map f).HasSelfPoleIndex w := h w ((G.map_actual_iff f w).mpr hactual) hfiber htag exact (G.map_hasSelfPoleIndex_iff f w).mp hidx · intro h w hactual hfiber htag have hidx : G.HasSelfPoleIndex w := h w ((G.map_actual_iff f w).mp hactual) hfiber htag exact (G.map_hasSelfPoleIndex_iff f w).mpr hidx theorem map_liveSelfAptTag_iff (κ : BeingCoarsening G Macro) (f : DisplayReparam Contrib Contrib') (b : Macro) : (displayMap κ f).LiveSelfAptTag b ↔ κ.LiveSelfAptTag b := by constructor · intro h exact ⟨(map_actualFiberInhabited_iff κ f b).mp h.left, (map_selfAptTag_iff κ f b).mp h.right⟩ · intro h exact ⟨(map_actualFiberInhabited_iff κ f b).mpr h.left, (map_selfAptTag_iff κ f b).mpr h.right⟩ theorem map_patchy_iff (κ : BeingCoarsening G Macro) (f : DisplayReparam Contrib Contrib') (b : Macro) : (displayMap κ f).Patchy b ↔ κ.Patchy b := by constructor · intro h exact ⟨fun hpole => h.left ((map_fiberAtPole_iff κ f b).mpr hpole), fun hself => h.right ((map_selfAptTag_iff κ f b).mpr hself)⟩ · intro h exact ⟨fun hpole => h.left ((map_fiberAtPole_iff κ f b).mp hpole), fun hself => h.right ((map_selfAptTag_iff κ f b).mp hself)⟩ theorem map_selfConditioningTag_iff (κ : BeingCoarsening G Macro) (f : DisplayReparam Contrib Contrib') (b : Macro) : (displayMap κ f).SelfConditioningTag b ↔ κ.SelfConditioningTag b := by constructor · rintro ⟨deed, reception, hdeed, hreception, hactual, hdel⟩ exact ⟨deed, reception, hdeed, hreception, (G.map_actual_iff f reception).mp hactual, (DirectedConvention.map_deliveredTo_iff G f deed reception).mp hdel⟩ · rintro ⟨deed, reception, hdeed, hreception, hactual, hdel⟩ exact ⟨deed, reception, hdeed, hreception, (G.map_actual_iff f reception).mpr hactual, (DirectedConvention.map_deliveredTo_iff G f deed reception).mpr hdel⟩ theorem map_strongSelfConditioningTag_iff (κ : BeingCoarsening G Macro) (f : DisplayReparam Contrib Contrib') (b : Macro) : (displayMap κ f).StrongSelfConditioningTag b ↔ κ.StrongSelfConditioningTag b := by constructor · intro h reception hfiber hactual rcases h reception hfiber ((G.map_actual_iff f reception).mpr hactual) with ⟨deed, hdeed, hdel⟩ exact ⟨deed, hdeed, (DirectedConvention.map_deliveredTo_iff G f deed reception).mp hdel⟩ · intro h reception hfiber hactual rcases h reception hfiber ((G.map_actual_iff f reception).mp hactual) with ⟨deed, hdeed, hdel⟩ exact ⟨deed, hdeed, (DirectedConvention.map_deliveredTo_iff G f deed reception).mpr hdel⟩ end BeingCoarsening end BeingConvention end DirectedConvention theorem map_waaBullTen_iff {Macro : Type} (κ : DirectedConvention.BeingConvention.BeingCoarsening G Macro) (b : G.Being) : (G.map f).WaaBullTen (κ.displayMap f) b ↔ G.WaaBullTen κ b := by constructor · intro h refine ⟨(G.map_responsiveTerminus_iff f b).mp h.left, ?_⟩ rcases h.right with ⟨deed, reception, hdeed, hactual, hnotSame, hsentient, hdel⟩ exact ⟨deed, reception, (DirectedConvention.BeingConvention.BeingCoarsening.map_inFiber_iff κ f (κ.proj b) deed).mp hdeed, (G.map_actual_iff f reception).mp hactual, (fun hsame => hnotSame ((DirectedConvention.BeingConvention.BeingCoarsening.map_sameFiber_iff κ f deed.agent reception.agent).mpr hsame)), (DirectedConvention.BeingConvention.BeingCoarsening.map_sentientTag_iff κ f (κ.proj reception.agent)).mp hsentient, (DirectedConvention.map_deliveredTo_iff G f deed reception).mp hdel⟩ · intro h refine ⟨(G.map_responsiveTerminus_iff f b).mpr h.left, ?_⟩ rcases h.right with ⟨deed, reception, hdeed, hactual, hnotSame, hsentient, hdel⟩ exact ⟨deed, reception, (DirectedConvention.BeingConvention.BeingCoarsening.map_inFiber_iff κ f (κ.proj b) deed).mpr hdeed, (G.map_actual_iff f reception).mpr hactual, (fun hsame => hnotSame ((DirectedConvention.BeingConvention.BeingCoarsening.map_sameFiber_iff κ f deed.agent reception.agent).mp hsame)), (DirectedConvention.BeingConvention.BeingCoarsening.map_sentientTag_iff κ f (κ.proj reception.agent)).mpr hsentient, (DirectedConvention.map_deliveredTo_iff G f deed reception).mpr hdel⟩ theorem map_stateToolFits_iff (w : G.Weld) : (G.map f).StateToolFits w ↔ G.StateToolFits w := by constructor · intro h hidx exact h ((G.map_hasSelfPoleIndex_iff f w).mpr hidx) · intro h hidx exact h ((G.map_hasSelfPoleIndex_iff f w).mp hidx) namespace Tier /-- Transport a diagnostic tier along a grid reparameterization. -/ def map {G : Grid Contrib} (f : DisplayReparam Contrib Contrib') : Tier G → Tier (G.map f) | .floor => .floor | .actTime w => .actTime w end Tier theorem map_tier_hasLiveShare_iff : ∀ t : Tier G, Tier.hasLiveShare (G.map f) (Tier.map f t) ↔ Tier.hasLiveShare G t | .floor => Iff.rfl | .actTime w => G.map_hasSelfPoleIndex_iff f w theorem map_exists_liveTier_iff : (∃ t : Tier (G.map f), Tier.hasLiveShare (G.map f) t) ↔ ∃ t : Tier G, Tier.hasLiveShare G t := by constructor · rintro ⟨t, ht⟩ cases t with | floor => cases ht | actTime w => exact ⟨Tier.actTime w, (G.map_hasSelfPoleIndex_iff f w).mp ht⟩ · rintro ⟨t, ht⟩ exact ⟨Tier.map f t, (G.map_tier_hasLiveShare_iff f t).mpr ht⟩ theorem map_rePitch (before : Config Contrib) (received : G.Weld) : (G.map f).rePitch (before.map f) received = (G.rePitch before received).map f := rfl theorem map_isShareDrop_iff (before : Config Contrib) (received : G.Weld) : (G.map f).IsShareDrop (before.map f) received ↔ G.IsShareDrop before received := by constructor · intro h exact ⟨(f.le_iff (G.share received) before.tendency).mpr h.left, fun hle => h.right ((f.le_iff before.tendency (G.share received)).mp hle)⟩ · intro h exact ⟨(f.le_iff (G.share received) before.tendency).mp h.left, fun hle => h.right ((f.le_iff before.tendency (G.share received)).mpr hle)⟩ theorem map_shareDropRun {before : Config Contrib} {run : List G.Weld} (h : G.ShareDropRun before run) : (G.map f).ShareDropRun (before.map f) run := by induction h with | nil before => exact ShareDropRun.nil (before.map f) | cons hactual hdrop _hrest ih => exact ShareDropRun.cons ((G.map_actual_iff f _).mpr hactual) ((G.map_isShareDrop_iff f _ _).mpr hdrop) (by simpa [Grid.map_rePitch] using ih) /-- Transport a Bull-ascent run across a display reparameterization. -/ def map_bullAscent (a : G.BullAscent) : (G.map f).BullAscent where before := a.before.map f run := a.run drops := G.map_shareDropRun f a.drops namespace ConsequentialistConvention /-- Transport a finite deliberation sample across a display reparameterization. The actual receptions are the same welds, re-read in the mapped display. -/ def DeliberationSample.map (s : DeliberationSample G) : DeliberationSample (G.map f) where before := s.before.map f run := s.run.map (ActualWeld.map f) @[simp] theorem deliberationSample_map_before (s : DeliberationSample G) : (DeliberationSample.map G f s).before = s.before.map f := rfl @[simp] theorem deliberationSample_map_run (s : DeliberationSample G) : (DeliberationSample.map G f s).run = s.run.map (ActualWeld.map f) := rfl /-- Drop-counting is invariant under display reparameterization. -/ theorem map_dropCount [∀ before received, Decidable (G.IsShareDrop before received)] [∀ before received, Decidable ((G.map f).IsShareDrop before received)] (before : Config Contrib) (run : List (ActualWeld G)) : DropCount (G.map f) (before.map f) (run.map (ActualWeld.map f)) = DropCount G before run := by induction run generalizing before with | nil => rfl | cons aw rest ih => unfold DropCount by_cases hdrop : G.IsShareDrop before aw.weld · have hmapped : (G.map f).IsShareDrop (before.map f) aw.weld := by simpa using (G.map_isShareDrop_iff f before aw.weld).mpr hdrop simp [hmapped, hdrop, Grid.map_rePitch, ih] · have hmapped : ¬ (G.map f).IsShareDrop (before.map f) aw.weld := by intro h exact hdrop ((G.map_isShareDrop_iff f before aw.weld).mp h) simp [hmapped, hdrop, Grid.map_rePitch, ih] /-- Fiber-restricted drop-counting is invariant under display reparameterization when the supplied being-coarsening is transported too. -/ theorem map_dropCountInFiber [∀ before received, Decidable (G.IsShareDrop before received)] [∀ before received, Decidable ((G.map f).IsShareDrop before received)] {Macro : Type} (κ : DirectedConvention.BeingConvention.BeingCoarsening G Macro) [∀ b w, Decidable (κ.InFiber b w)] [∀ b w, Decidable ((κ.displayMap f).InFiber b w)] (b : Macro) (before : Config Contrib) (run : List (ActualWeld G)) : DropCountInFiber (G.map f) (κ.displayMap f) b (before.map f) (run.map (ActualWeld.map f)) = DropCountInFiber G κ b before run := by induction run generalizing before with | nil => rfl | cons aw rest ih => unfold DropCountInFiber by_cases hfiber : κ.InFiber b aw.weld · have hmappedFiber : (κ.displayMap f).InFiber b aw.weld := by simpa using (DirectedConvention.BeingConvention.BeingCoarsening.map_inFiber_iff κ f b aw.weld).mpr hfiber by_cases hdrop : G.IsShareDrop before aw.weld · have hmappedDrop : (G.map f).IsShareDrop (before.map f) aw.weld := by simpa using (G.map_isShareDrop_iff f before aw.weld).mpr hdrop simp [hmappedFiber, hfiber, hmappedDrop, hdrop, Grid.map_rePitch, ih] · have hmappedDrop : ¬ (G.map f).IsShareDrop (before.map f) aw.weld := by intro h exact hdrop ((G.map_isShareDrop_iff f before aw.weld).mp h) simp [hmappedFiber, hfiber, hmappedDrop, hdrop, Grid.map_rePitch, ih] · have hmappedFiber : ¬ (κ.displayMap f).InFiber b aw.weld := by intro h exact hfiber ((DirectedConvention.BeingConvention.BeingCoarsening.map_inFiber_iff κ f b aw.weld).mp h) simp [hmappedFiber, hfiber, Grid.map_rePitch, ih] theorem map_dropCountInFiberSum [∀ before received, Decidable (G.IsShareDrop before received)] [∀ before received, Decidable ((G.map f).IsShareDrop before received)] {Macro : Type} (κ : DirectedConvention.BeingConvention.BeingCoarsening G Macro) [∀ b w, Decidable (κ.InFiber b w)] [∀ b w, Decidable ((κ.displayMap f).InFiber b w)] (tags : List Macro) (before : Config Contrib) (run : List (ActualWeld G)) : DropCountInFiberSum (G.map f) (κ.displayMap f) tags (before.map f) (run.map (ActualWeld.map f)) = DropCountInFiberSum G κ tags before run := by induction tags with | nil => rfl | cons b rest ih => unfold DropCountInFiberSum simp [map_dropCountInFiber G f κ b before run, ih] theorem map_dropCount_sample [∀ before received, Decidable (G.IsShareDrop before received)] [∀ before received, Decidable ((G.map f).IsShareDrop before received)] (s : DeliberationSample G) : DropCount (G.map f) (DeliberationSample.map G f s).before (DeliberationSample.map G f s).run = DropCount G s.before s.run := by simpa [DeliberationSample.map] using (map_dropCount G f s.before s.run) theorem map_dropCountInFiber_sample [∀ before received, Decidable (G.IsShareDrop before received)] [∀ before received, Decidable ((G.map f).IsShareDrop before received)] {Macro : Type} (κ : DirectedConvention.BeingConvention.BeingCoarsening G Macro) [∀ b w, Decidable (κ.InFiber b w)] [∀ b w, Decidable ((κ.displayMap f).InFiber b w)] (b : Macro) (s : DeliberationSample G) : DropCountInFiber (G.map f) (κ.displayMap f) b (DeliberationSample.map G f s).before (DeliberationSample.map G f s).run = DropCountInFiber G κ b s.before s.run := by simpa [DeliberationSample.map] using (map_dropCountInFiber G f κ b s.before s.run) end ConsequentialistConvention namespace DirectedConvention theorem map_landsWithShareDrop_iff (before : Config Contrib) (deed reception : G.Weld) : LandsWithShareDrop (G.map f) (before.map f) deed reception ↔ LandsWithShareDrop G before deed reception := by constructor · intro h exact ⟨(map_landsAt_iff G f deed reception).mp h.left, (G.map_isShareDrop_iff f before reception).mp h.right⟩ · intro h exact ⟨(map_landsAt_iff G f deed reception).mpr h.left, (G.map_isShareDrop_iff f before reception).mpr h.right⟩ theorem map_hasShareDropLanding_iff (before : Config Contrib) (deed : G.Weld) : HasShareDropLanding (G.map f) (before.map f) deed ↔ HasShareDropLanding G before deed := by constructor · rintro ⟨reception, hland⟩ exact ⟨reception, (map_landsWithShareDrop_iff G f before deed reception).mp hland⟩ · rintro ⟨reception, hland⟩ exact ⟨reception, (map_landsWithShareDrop_iff G f before deed reception).mpr hland⟩ theorem map_shareDropLine_iff (before : Config Contrib) (b : G.Being) (deed reception : G.Weld) : ShareDropLine (G.map f) (before.map f) b deed reception ↔ ShareDropLine G before b deed reception := by constructor · intro h exact ⟨(map_environsLine_iff G f b deed reception).mp h.left, (G.map_isShareDrop_iff f before reception).mp h.right⟩ · intro h exact ⟨(map_environsLine_iff G f b deed reception).mpr h.left, (G.map_isShareDrop_iff f before reception).mpr h.right⟩ theorem map_shortfallClosedAt_iff (before : Config Contrib) (deed reception : G.Weld) : ShortfallClosedAt (G.map f) (before.map f) deed reception ↔ ShortfallClosedAt G before deed reception := by constructor · intro h hlive hdel have hmappedLive : ¬ AtBot (f.toFun before.tendency) := by intro hbot exact hlive ((f.atBot_iff before.tendency).mp hbot) have hlanding := h hmappedLive ((map_deliveredTo_iff G f deed reception).mpr hdel) exact (map_hasShareDropLanding_iff G f before deed).mp hlanding · intro h hlive hdel have horigLive : ¬ AtBot before.tendency := by intro hbot exact hlive ((f.atBot_iff before.tendency).mpr hbot) have hlanding := h horigLive ((map_deliveredTo_iff G f deed reception).mp hdel) exact (map_hasShareDropLanding_iff G f before deed).mpr hlanding theorem map_waaFullyEnlightened_reflect {b : G.Being} (h : WaaFullyEnlightened (G.map f) b) : WaaFullyEnlightened G b := by constructor · exact (G.map_responsiveTerminus_iff f b).mp h.left · intro before deed reception hdeed exact (map_shortfallClosedAt_iff G f before deed reception).mp (h.right (before.map f) deed reception hdeed) /-- Preservation of the universally quantified faith closure needs the target display carrier to be covered by the reparameterization. `CoverageNegative.waaFullyEnlightened_needs_coverage` shows the hypothesis is needed. -/ theorem map_waaFullyEnlightened_of_surjective (hsurj : ∀ b' : Contrib', ∃ a : Contrib, f.toFun a = b') {b : G.Being} (h : WaaFullyEnlightened G b) : WaaFullyEnlightened (G.map f) b := by constructor · exact (G.map_responsiveTerminus_iff f b).mpr h.left · intro before' deed reception hdeed cases before' with | mk tendency => rcases hsurj tendency with ⟨a, ha⟩ let before : Config Contrib := { tendency := a } intro hlive hdel have horigLive : ¬ AtBot before.tendency := by intro hbot apply hlive have hmapped : AtBot (f.toFun a) := (f.atBot_iff a).mpr hbot simpa [before, ha] using hmapped have horigDel : DeliveredTo G deed reception := (map_deliveredTo_iff G f deed reception).mp hdel have hlanding := h.right before deed reception hdeed horigLive horigDel have hmapped := (map_hasShareDropLanding_iff G f before deed).mpr hlanding simpa [Config.map, before, ha] using hmapped /-- Transport of a path claim: reparameterize the stored configuration; the welds are carried unchanged. -/ def WaaPathClaim.map (c : WaaPathClaim G) : WaaPathClaim (G.map f) := { before := c.before.map f deed := c.deed reception := c.reception } /-- Truth of a path claim is display-invariant. The language ignores the tier, so the tiers on the two sides are unconstrained. -/ theorem map_waaPathClaim_holds_iff (t' : Tier (G.map f)) (t : Tier G) (c : WaaPathClaim G) : (waaPathClaimLanguage (G.map f)).Holds t' (WaaPathClaim.map G f c) ↔ (waaPathClaimLanguage G).Holds t c := by simpa [waaPathClaimLanguage, WaaPathClaim.map] using (map_shortfallClosedAt_iff G f c.before c.deed c.reception) /-- With target-carrier coverage, full enlightenment is display-invariant outright. -/ theorem map_waaFullyEnlightened_iff (hsurj : ∀ b' : Contrib', ∃ a : Contrib, f.toFun a = b') (b : G.Being) : WaaFullyEnlightened (G.map f) b ↔ WaaFullyEnlightened G b := ⟨fun h => map_waaFullyEnlightened_reflect G f h, fun h => map_waaFullyEnlightened_of_surjective G f hsurj h⟩ /-- Faith has no monotonicity or congruence law. Under coverage, the mapped faith-object is propositionally the same object, so transport goes through propositional extensionality. -/ theorem map_faith_object_eq (hsurj : ∀ b' : Contrib', ∃ a : Contrib, f.toFun a = b') (Faith : Prop → Prop) (b : G.Being) : Faith (WaaFullyEnlightened (G.map f) b) = Faith (WaaFullyEnlightened G b) := by rw [propext (map_waaFullyEnlightened_iff G f hsurj b)] /-- Reflection of the faith principle across a covering display reparameterization, for the path-claim language. -/ theorem map_waaFaithPrinciple_reflect (hsurj : ∀ b' : Contrib', ∃ a : Contrib, f.toFun a = b') {Faith : Prop → Prop} (h : WaaFaithPrinciple (G.map f) (waaPathClaimLanguage (G.map f)) Faith) : WaaFaithPrinciple G (waaPathClaimLanguage G) Faith := by intro b hfaith u hutter have hfaith' : Faith (WaaFullyEnlightened (G.map f) b) := by rw [map_faith_object_eq G f hsurj Faith b] exact hfaith let u' : RecordedUtterance (G.map f) (waaPathClaimLanguage (G.map f)) := { weld := u.weld actual := u.actual offeredAt := Tier.floor content := WaaPathClaim.map G f u.content } have hfit' : u'.FitsOfferedTier := h b hfaith' u' hutter change (waaPathClaimLanguage G).TrueAt u.offeredAt u.content have hholds : (waaPathClaimLanguage G).Holds u.offeredAt u.content := (map_waaPathClaim_holds_iff G f u'.offeredAt u.offeredAt u.content).mp (by change (waaPathClaimLanguage (G.map f)).TrueAt u'.offeredAt u'.content at hfit' simpa [ClaimLanguage.TrueAt, u'] using hfit') simpa [ClaimLanguage.TrueAt] using hholds theorem map_waaAversionContext_iff (before : Config Contrib) (reception : G.Weld) : WaaAversionContext (G.map f) (before.map f) reception ↔ WaaAversionContext G before reception := by constructor · intro h refine { liveBefore := ?_ mismatchLive := ?_ } · intro hbot exact h.liveBefore ((f.atBot_iff before.tendency).mpr hbot) · exact (G.map_waaMismatchLive_iff f reception).mp h.mismatchLive · intro h refine { liveBefore := ?_ mismatchLive := ?_ } · intro hbot exact h.liveBefore ((f.atBot_iff before.tendency).mp hbot) · exact (G.map_waaMismatchLive_iff f reception).mpr h.mismatchLive end DirectedConvention namespace DirectedConvention namespace BeingConvention namespace GridConvention theorem map_rowOf_obeys [∀ w : (G.map f).Weld, Decidable (AtBot ((G.map f).share w))] (r : RowTag) : (rowOf (G.map f) r).ObeysSeparateFuse := rowOf_obeys (G.map f) r theorem map_layerRow_obeys [∀ w : (G.map f).Weld, Decidable (AtBot ((G.map f).share w))] (l : ConventionLayer) : (layerRow (G.map f) l).ObeysSeparateFuse := map_rowOf_obeys G f (.layer l) theorem map_weldRow_obeys [∀ w : (G.map f).Weld, Decidable (AtBot ((G.map f).share w))] : (weldRow (G.map f)).ObeysSeparateFuse := map_rowOf_obeys G f (.layer .weldGrain) theorem map_intraWeldArrowRow_obeys [∀ w : (G.map f).Weld, Decidable (AtBot ((G.map f).share w))] : (intraWeldArrowRow (G.map f)).ObeysSeparateFuse := map_rowOf_obeys G f (.layer .intraWeldArrow) theorem map_doerDeedRow_obeys [∀ w : (G.map f).Weld, Decidable (AtBot ((G.map f).share w))] : (doerDeedRow (G.map f)).ObeysSeparateFuse := map_rowOf_obeys G f .doerDeed theorem map_contentBeforeAfterRow_obeys_of_direction (h : ∃ a b : Contrib, Strict a b) : (contentBeforeAfterRow (G.map f)).ObeysSeparateFuse := contentBeforeAfterRow_obeys_of_direction (G.map f) (f.exists_strict_map h) theorem map_contentIntraWeldArrowRow_obeys_of_variation (h : ∃ b : G.Being, G.ResponseVariesWithCall b) : (contentIntraWeldArrowRow (G.map f)).ObeysSeparateFuse := by apply contentIntraWeldArrowRow_obeys_of_variation rcases h with ⟨b, hvaries⟩ exact ⟨b, (G.map_responseVariesWithCall_iff f b).mpr hvaries⟩ theorem map_contentBeingsRow_obeys_of_being (h : ∃ b : G.Being, ¬ G.Stone b) : (contentBeingsRow (G.map f)).ObeysSeparateFuse := by apply contentBeingsRow_obeys_of_being rcases h with ⟨b, hnotStone⟩ exact ⟨b, fun hstone => hnotStone ((G.map_stone_iff f b).mp hstone)⟩ theorem map_contentGridLensRow_obeys_of_liveTier (h : ∃ t : Tier G, Tier.hasLiveShare G t) : (contentGridLensRow (G.map f)).ObeysSeparateFuse := contentGridLensRow_obeys_of_liveTier (G.map f) ((G.map_exists_liveTier_iff f).mpr h) theorem map_contentWeldRow_obeys_of_actual (h : ∃ w : G.Weld, G.Actual w) : (contentWeldRow (G.map f)).ObeysSeparateFuse := contentWeldRow_obeys_of_actual (G.map f) ((G.map_exists_actual_iff f).mpr h) theorem map_beingsLadder_obeys [∀ w : (G.map f).Weld, Decidable (AtBot ((G.map f).share w))] : ∀ n, (beingsLadder (G.map f) n).ObeysSeparateFuse := beingsLadder_obeys (G.map f) theorem map_beingsLadder_obeys_succ : ∀ n, (beingsLadder (G.map f) (n + 1)).ObeysSeparateFuse := beingsLadder_obeys_succ (G.map f) theorem map_weldLadder_obeys [∀ w : (G.map f).Weld, Decidable (AtBot ((G.map f).share w))] : ∀ n, (weldLadder (G.map f) n).ObeysSeparateFuse := weldLadder_obeys (G.map f) theorem map_weldLadder_obeys_succ : ∀ n, (weldLadder (G.map f) (n + 1)).ObeysSeparateFuse := weldLadder_obeys_succ (G.map f) theorem map_weldLadder_no_level_final : ∀ n, ¬ (weldLadder (G.map f) n).Freeze := weldLadder_no_level_final (G.map f) theorem map_intraWeldArrowLadder_obeys [∀ w : (G.map f).Weld, Decidable (AtBot ((G.map f).share w))] : ∀ n, (intraWeldArrowLadder (G.map f) n).ObeysSeparateFuse := intraWeldArrowLadder_obeys (G.map f) theorem map_intraWeldArrowLadder_obeys_succ : ∀ n, (intraWeldArrowLadder (G.map f) (n + 1)).ObeysSeparateFuse := intraWeldArrowLadder_obeys_succ (G.map f) theorem map_intraWeldArrowLadder_no_level_final : ∀ n, ¬ (intraWeldArrowLadder (G.map f) n).Freeze := intraWeldArrowLadder_no_level_final (G.map f) theorem map_doerDeedLadder_obeys [∀ w : (G.map f).Weld, Decidable (AtBot ((G.map f).share w))] : ∀ n, (doerDeedLadder (G.map f) n).ObeysSeparateFuse := doerDeedLadder_obeys (G.map f) theorem map_doerDeedLadder_obeys_succ : ∀ n, (doerDeedLadder (G.map f) (n + 1)).ObeysSeparateFuse := doerDeedLadder_obeys_succ (G.map f) theorem map_doerDeedLadder_no_level_final : ∀ n, ¬ (doerDeedLadder (G.map f) n).Freeze := doerDeedLadder_no_level_final (G.map f) end GridConvention end BeingConvention end DirectedConvention end Grid end WAA ===== FILE: WeldAndArrow/Meta/InvarianceNegative.lean ===== /- ================================================================================ WeldAndArrow.Meta.InvarianceNegative Countermodels for invariance and recovery claims ================================================================================ Reading and motivation: Identification/Commentary.lean, C.3. -/ import WeldAndArrow.Meta.Invariance namespace WAA /- ============================================================================== Negative example: equality-at-bottom does not transport ============================================================================== -/ namespace InvarianceNegative inductive TwoBottom | chosen | other instance : PreorderBot TwoBottom where le := fun _ _ => True le_refl := fun _ => True.intro le_trans := fun _ _ => True.intro bot := TwoBottom.chosen bot_le := fun _ => True.intro instance : PreorderBot Unit where le := fun _ _ => True le_refl := fun _ => True.intro le_trans := fun _ _ => True.intro bot := () bot_le := fun _ => True.intro def mergeToUnit : DisplayReparam TwoBottom Unit where toFun _ := () le_iff _ _ := ⟨fun _ => True.intro, fun _ => True.intro⟩ atBot_bot := True.intro def twoBottomGrid : Grid TwoBottom where Being := Unit Call := Unit Response := Unit respondsTo _ _ := some () grade _ _ _ := TwoBottom.other conditions _ _ := False /-- The old, equality-token version of terminus, kept only for this counterexample. It is not the system predicate. -/ def OldEqTerminus {Contrib : Type} [PreorderBot Contrib] (G : Grid Contrib) (b : G.Being) : Prop := ∀ c r, G.respondsTo b c = some r → G.grade b c r = shareBot theorem twoBottomGrid_terminus : twoBottomGrid.Terminus () := fun _ _ _ => True.intro theorem not_oldEqTerminus_twoBottomGrid : ¬ OldEqTerminus twoBottomGrid () := by intro h have hbad : TwoBottom.other = TwoBottom.chosen := h () () rfl cases hbad theorem oldEqTerminus_map_mergeToUnit : OldEqTerminus (twoBottomGrid.map mergeToUnit) () := fun _ _ _ => rfl /-- The new predicate transports across the merge, while the old equality-token predicate would hold after the merge and fail before it. -/ theorem oldEqTerminus_not_invariant : ((twoBottomGrid.map mergeToUnit).Terminus () ↔ twoBottomGrid.Terminus ()) ∧ OldEqTerminus (twoBottomGrid.map mergeToUnit) () ∧ ¬ OldEqTerminus twoBottomGrid () := ⟨twoBottomGrid.map_terminus_iff mergeToUnit (), fun _ _ _ => rfl, by intro h have hbad : TwoBottom.other = TwoBottom.chosen := h () () rfl cases hbad⟩ end InvarianceNegative /- Reading and motivation: Identification/Commentary.lean, C.3. -/ namespace DirectionNegative /-- One being, two calls, one response: a small carrier with two orientations. -/ abbrev W := RawWeld Unit Bool Unit /-- The weld at the `false` call. -/ def wFalse : W := ⟨(), false, ()⟩ /-- The weld at the `true` call. -/ def wTrue : W := ⟨(), true, ()⟩ /-- The web read one way: the `false`-weld conditions the `true`-weld. -/ def forwardGrid : Grid Nat where Being := Unit Call := Bool Response := Unit respondsTo _ _ := some () grade _ _ _ := 0 conditions w₁ w₂ := w₁.call = false ∧ w₂.call = true /-- The same web read the other way: only `conditions` is reversed. -/ def backwardGrid : Grid Nat where Being := Unit Call := Bool Response := Unit respondsTo _ _ := some () grade _ _ _ := 0 conditions w₁ w₂ := w₁.call = true ∧ w₂.call = false /-- The two orientations agree on the symmetric closure at every pair. -/ theorem conditionsEither_agrees (w₁ w₂ : W) : forwardGrid.ConditionsEither w₁ w₂ ↔ backwardGrid.ConditionsEither w₁ w₂ := ⟨fun h => h.elim (fun ⟨h1, h2⟩ => Or.inr ⟨h2, h1⟩) (fun ⟨h1, h2⟩ => Or.inl ⟨h2, h1⟩), fun h => h.elim (fun ⟨h1, h2⟩ => Or.inr ⟨h2, h1⟩) (fun ⟨h1, h2⟩ => Or.inl ⟨h2, h1⟩)⟩ /-- They disagree on `conditions` at the witness pair. -/ theorem conditions_disagree : forwardGrid.conditions wFalse wTrue ∧ ¬ backwardGrid.conditions wFalse wTrue := by constructor · exact ⟨rfl, rfl⟩ · intro h cases h.left /- Reading and motivation: Identification/Commentary.lean, C.3. -/ theorem no_direction_recovery_from_conditionsEither : ¬ ∃ recover : (W → W → Prop) → (W → W → Prop), recover forwardGrid.ConditionsEither = forwardGrid.conditions ∧ recover backwardGrid.ConditionsEither = backwardGrid.conditions := by rintro ⟨recover, hf, hb⟩ have hsame : forwardGrid.ConditionsEither = backwardGrid.ConditionsEither := by funext w₁ w₂ exact propext (conditionsEither_agrees w₁ w₂) have hcond : forwardGrid.conditions = backwardGrid.conditions := by rw [← hf, hsame, hb] exact conditions_disagree.right (hcond ▸ conditions_disagree.left) /-- The equilibrium-pole face, on the existing negative carrier: where everything is order-equivalent, nothing is strict. -/ theorem not_strict_twoBottom (a b : InvarianceNegative.TwoBottom) : ¬ Strict a b := no_strict_of_all_orderEq (fun _ _ => ⟨True.intro, True.intro⟩) a b end DirectionNegative /- ============================================================================== Direction-coarsening witnesses ============================================================================== -/ namespace DirectionCoarseningWitness open Grid.DirectedConvention open Grid.DirectedConvention.DirectionCoarsening /-- The raw register-clock read through a one-tick delivery clock. -/ def registerClockUnitTick : DirectionCoarsening registerClockGrid Unit where tick _ := () def registerClockLow : registerClockGrid.Weld := ⟨(0 : Nat), (), (1 : Nat)⟩ def registerClockHigh : registerClockGrid.Weld := ⟨(1 : Nat), (), (2 : Nat)⟩ /-- Honest snag: the raw `Nat` register display is injective on registers, so a universal tick cannot be resolution-bounded. -/ theorem registerClock_unitTick_not_resolutionBounded : ¬ registerClockUnitTick.ResolutionBounded := by intro h have hEq : OrderEq (registerClockGrid.share registerClockLow) (registerClockGrid.share registerClockHigh) := h registerClockLow registerClockHigh rfl have hle : (1 : Nat) ≼ 0 := by simpa [Grid.share, registerClockGrid, registerClockLow, registerClockHigh] using hEq.right change (1 : Nat) ≤ 0 at hle cases hle /-- A fully coarse display of the same register-clock response and delivery shape. The carrier is already one-point, so this is the slow-clock limit after display choice, not a collapse of the raw `Nat` order. -/ def fullyCoarseRegisterClockGrid : Grid Unit where Being := Nat Call := Unit Response := Nat respondsTo n _ := some (n + 1) grade _ _ _ := () conditions deed reception := reception.agent = deed.response def fullyCoarseRegisterClockUnitTick : DirectionCoarsening fullyCoarseRegisterClockGrid Unit where tick _ := () /-- The fully coarse display is resolution-bounded by construction. -/ theorem fullyCoarseRegisterClock_resolutionBounded : fullyCoarseRegisterClockUnitTick.ResolutionBounded := by intro _w₁ _w₂ _hsame exact ⟨True.intro, True.intro⟩ /-- The target one-point carrier is direction-void, obtained through the existing legal display collapse from the all-equivalent `TwoBottom` carrier. -/ theorem unit_directionVoid_via_mergeToUnit : DirectionVoid Unit := DisplayReparam.directionVoid_of_surjective InvarianceNegative.mergeToUnit (fun b => ⟨InvarianceNegative.TwoBottom.chosen, by cases b; rfl⟩) (fun a b => DirectionNegative.not_strict_twoBottom a b) /-- In the fully coarse register-clock display, no pair of weld-shares carries strict time-direction. -/ theorem fullyCoarseRegisterClock_no_timeDirection (w₁ w₂ : fullyCoarseRegisterClockGrid.Weld) : ¬ TimeDirection (fullyCoarseRegisterClockGrid.share w₁) (fullyCoarseRegisterClockGrid.share w₂) := fullyCoarseRegisterClockUnitTick.no_timeDirection_of_resolutionBounded_subsingleton fullyCoarseRegisterClock_resolutionBounded (fun _ _ => rfl) w₁ w₂ /-- Function and internal-delivery witnesses for the macro register clock do not consume direction-coarsening or resolution-boundedness hypotheses. -/ theorem registerClock_directionCoarsening_independence : (∀ {Tick : Type} (_ρ : DirectionCoarsening registerClockGrid Tick), registerClockCoarsening.SentientTag () ∧ registerClockCoarsening.SelfConditioningTag ()) ∧ (∀ {Tick : Type} (ρ : DirectionCoarsening registerClockGrid Tick), ρ.ResolutionBounded -> registerClockCoarsening.SentientTag () ∧ registerClockCoarsening.SelfConditioningTag ()) := by constructor · intro _Tick _ρ exact ⟨registerClock_macro_sentient, registerClock_macro_selfConditioning⟩ · intro _Tick _ρ _hbounded exact ⟨registerClock_macro_sentient, registerClock_macro_selfConditioning⟩ end DirectionCoarseningWitness /- ============================================================================== Content-row countermodels ============================================================================== -/ namespace ContentNegative open Grid.DirectedConvention.BeingConvention.GridConvention def allStoneGrid : Grid InvarianceNegative.TwoBottom where Being := Unit Call := Unit Response := Unit respondsTo _ _ := none grade _ _ _ := InvarianceNegative.TwoBottom.chosen conditions _ _ := False def allStoneWeld : allStoneGrid.Weld := ⟨(), (), ()⟩ theorem allStoneGrid_allStone : allStoneGrid.AllStone := by intro _b _c hmount rcases hmount with ⟨_r, hr⟩ cases hr theorem allStoneGrid_no_liveTier (t : Grid.Tier allStoneGrid) : ¬ Grid.Tier.hasLiveShare allStoneGrid t := by cases t with | floor => intro h exact h | actTime _ => intro hidx exact hidx True.intro theorem allStoneWeld_no_live_share : ¬ Grid.Tier.hasLiveShare allStoneGrid (Grid.Tier.actTime allStoneWeld) := allStoneGrid_no_liveTier (Grid.Tier.actTime allStoneWeld) theorem contentBeingsRow_not_fused_allStone : ¬ (contentBeingsRow allStoneGrid).Fused (Grid.Tier.actTime allStoneWeld) := by intro hfused have hiff := hfused allStoneWeld_no_live_share have hdenial : (contentLayerLanguage allStoneGrid).TrueAt (Grid.Tier.actTime allStoneWeld) (.layerDenied .beings) := by dsimp [contentLayerLanguage, Grid.ClaimLanguage.TrueAt] exact allStoneGrid_allStone exact allStoneWeld_no_live_share (hiff.mpr hdenial) theorem contentBeingsRow_not_obeys_allStone : ¬ (contentBeingsRow allStoneGrid).ObeysSeparateFuse := by intro h exact contentBeingsRow_not_fused_allStone (allStoneGrid.fused_of_obeysSeparateFuse h (Grid.Tier.actTime allStoneWeld)) theorem contentGridLensRow_not_fused_noLive : ¬ (contentGridLensRow allStoneGrid).Fused (Grid.Tier.actTime allStoneWeld) := by intro hfused have hiff := hfused allStoneWeld_no_live_share have hdenial : (contentLayerLanguage allStoneGrid).TrueAt (Grid.Tier.actTime allStoneWeld) (.layerDenied .gridLens) := by dsimp [contentLayerLanguage, Grid.ClaimLanguage.TrueAt] exact allStoneGrid_no_liveTier exact allStoneWeld_no_live_share (hiff.mpr hdenial) theorem contentGridLensRow_not_obeys_noLive : ¬ (contentGridLensRow allStoneGrid).ObeysSeparateFuse := by intro h exact contentGridLensRow_not_fused_noLive (allStoneGrid.fused_of_obeysSeparateFuse h (Grid.Tier.actTime allStoneWeld)) /-- Empty calls make stone-typing and call-entire response coincide vacuously; this is the function-axis analogue of a collapsed share axis. -/ def emptyCallGrid : Grid InvarianceNegative.TwoBottom where Being := Bool Call := Empty Response := Unit respondsTo _ c := Empty.elim c grade _ _ _ := InvarianceNegative.TwoBottom.chosen conditions _ _ := False theorem emptyCallGrid_stone_iff_respondsToEveryCall (b : emptyCallGrid.Being) : emptyCallGrid.Stone b ↔ emptyCallGrid.RespondsToEveryCall b := emptyCallGrid.stone_iff_respondsToEveryCall_of_no_call (fun c => Empty.elim c) b theorem emptyCallGrid_false_stone_and_respondsToEveryCall : emptyCallGrid.Stone false ∧ emptyCallGrid.RespondsToEveryCall false := ⟨emptyCallGrid.stone_of_no_call (fun c => Empty.elim c) false, emptyCallGrid.respondsToEveryCall_of_no_call (fun c => Empty.elim c) false⟩ def emptyBeingGrid : Grid InvarianceNegative.TwoBottom where Being := Empty Call := Unit Response := Unit respondsTo b _ := Empty.elim b grade b _ _ := Empty.elim b conditions _ _ := False theorem emptyBeingGrid_allStone : emptyBeingGrid.AllStone := emptyBeingGrid.allStone_of_no_being (fun b => Empty.elim b) theorem emptyBeingGrid_no_liveTier (t : Grid.Tier emptyBeingGrid) : ¬ Grid.Tier.hasLiveShare emptyBeingGrid t := by cases t with | floor => intro h exact h | actTime w => cases w.agent theorem emptyBeingGrid_contentBeings_denial (t : Grid.Tier emptyBeingGrid) : (contentLayerLanguage emptyBeingGrid).TrueAt t (.layerDenied .beings) := by cases t with | floor => exact True.intro | actTime _ => dsimp [contentLayerLanguage, Grid.ClaimLanguage.TrueAt] exact emptyBeingGrid_allStone theorem contentBeingsRow_fused_emptyBeing (t : Grid.Tier emptyBeingGrid) : (contentBeingsRow emptyBeingGrid).Fused t := by intro _hnot cases t with | floor => constructor <;> intro _ <;> exact True.intro | actTime w => cases w.agent theorem contentBeingsRow_obeys_emptyBeing : (contentBeingsRow emptyBeingGrid).ObeysSeparateFuse := by constructor · intro t hlive exact False.elim (emptyBeingGrid_no_liveTier t hlive) · intro t hnot exact contentBeingsRow_fused_emptyBeing t hnot def twoBottomWeld : InvarianceNegative.twoBottomGrid.Weld := ⟨(), (), ()⟩ theorem twoBottomGrid_directionVoid : DirectionVoid InvarianceNegative.TwoBottom := DirectionNegative.not_strict_twoBottom theorem twoBottomWeld_no_live_share : ¬ Grid.Tier.hasLiveShare InvarianceNegative.twoBottomGrid (Grid.Tier.actTime twoBottomWeld) := by intro hidx exact hidx True.intro theorem contentBeforeAfterRow_not_fused_twoBottom : ¬ (contentBeforeAfterRow InvarianceNegative.twoBottomGrid).Fused (Grid.Tier.actTime twoBottomWeld) := by intro hfused have hiff := hfused twoBottomWeld_no_live_share have hdenial : (contentLayerLanguage InvarianceNegative.twoBottomGrid).TrueAt (Grid.Tier.actTime twoBottomWeld) (.layerDenied .directedTime) := by dsimp [contentLayerLanguage, Grid.ClaimLanguage.TrueAt] exact twoBottomGrid_directionVoid exact twoBottomWeld_no_live_share (hiff.mpr hdenial) theorem contentBeforeAfterRow_not_obeys_twoBottom : ¬ (contentBeforeAfterRow InvarianceNegative.twoBottomGrid).ObeysSeparateFuse := by intro h exact contentBeforeAfterRow_not_fused_twoBottom (InvarianceNegative.twoBottomGrid.fused_of_obeysSeparateFuse h (Grid.Tier.actTime twoBottomWeld)) def constantResponseGrid : Grid InvarianceNegative.TwoBottom where Being := Unit Call := Bool Response := Unit respondsTo _ _ := some () grade _ _ _ := InvarianceNegative.TwoBottom.chosen conditions _ _ := False def constantResponseWeld : constantResponseGrid.Weld := ⟨(), false, ()⟩ theorem constantResponseGrid_no_variation : ∀ b : constantResponseGrid.Being, ¬ constantResponseGrid.ResponseVariesWithCall b := by intro _b h rcases h with ⟨_c₁, _c₂, r₁, r₂, _h₁, _h₂, hne⟩ cases r₁ cases r₂ exact hne rfl theorem constantResponseWeld_no_live_share : ¬ Grid.Tier.hasLiveShare constantResponseGrid (Grid.Tier.actTime constantResponseWeld) := by intro hidx exact hidx True.intro theorem contentIntraWeldArrowRow_not_fused_constantResponse : ¬ (contentIntraWeldArrowRow constantResponseGrid).Fused (Grid.Tier.actTime constantResponseWeld) := by intro hfused have hiff := hfused constantResponseWeld_no_live_share have hdenial : (contentLayerLanguage constantResponseGrid).TrueAt (Grid.Tier.actTime constantResponseWeld) (.layerDenied .intraWeldArrow) := by dsimp [contentLayerLanguage, Grid.ClaimLanguage.TrueAt] exact constantResponseGrid_no_variation exact constantResponseWeld_no_live_share (hiff.mpr hdenial) theorem contentIntraWeldArrowRow_not_obeys_constantResponse : ¬ (contentIntraWeldArrowRow constantResponseGrid).ObeysSeparateFuse := by intro h exact contentIntraWeldArrowRow_not_fused_constantResponse (constantResponseGrid.fused_of_obeysSeparateFuse h (Grid.Tier.actTime constantResponseWeld)) end ContentNegative /- ============================================================================== §N Being-boundary freedom: designation is not grid-carried The witness is parallel in scope to `DirectionNegative`. A single grid has two fact-identical fine tags and supports both a merge and a split coarsening. They disagree on the fiber boundary at a concrete pair. This certifies freedom, not failure: naming suffices, while holding one partition as floor furniture claims a fact the grid's data does not carry. ============================================================================== -/ namespace BeingNegative open Grid.DirectedConvention.BeingConvention /-- Two fine tags with the same response, same grade, and symmetric delivery. -/ def twoBeingGrid : Grid Nat where Being := Bool Call := Unit Response := Unit respondsTo _ _ := some () grade _ _ _ := 0 conditions _ _ := True /-- Merge coarsening: both fine tags are one macro tag. -/ def κmerge : BeingCoarsening twoBeingGrid Unit where proj _ := () /-- Split coarsening: each fine tag remains its own macro tag. -/ def κsplit : BeingCoarsening twoBeingGrid Bool where proj := id theorem merge_same_fiber : κmerge.SameFiber false true := rfl theorem split_not_same_fiber : ¬ κsplit.SameFiber false true := by intro h cases h /-- The grid data visible to a would-be partition-recovery function. -/ abbrev W := RawWeld Bool Unit Unit abbrev GridData : Type := (Bool → Unit → Option Unit) × (Bool → Unit → Unit → Nat) × (W → W → Prop) def gridData : GridData := (twoBeingGrid.respondsTo, twoBeingGrid.grade, twoBeingGrid.conditions) def mergeBoundary (_p _q : Bool) : Prop := True def splitBoundary (p q : Bool) : Prop := p = q /-- No function of this grid's data recovers a unique partition: the same data supports both the merge and the split coarsenings, which disagree at `false` and `true`. -/ theorem no_partition_recovery : ¬ ∃ recover : GridData → Bool → Bool → Prop, recover gridData = mergeBoundary ∧ recover gridData = splitBoundary := by rintro ⟨recover, hmerge, hsplit⟩ have hmerged : recover gridData false true := by rw [hmerge] exact True.intro have hsplitNot : ¬ recover gridData false true := by rw [hsplit] intro h cases h exact hsplitNot hmerged end BeingNegative /- ============================================================================== Coverage countermodels Reading and motivation: Identification/Commentary.lean, C.3. The same strict pair `(0, 1)` does double duty here: it refutes carrier-wide direction-voidness after mapping, and it supplies the live tendency that the source carrier never quantified over. The `WaaFullyEnlightened` witness also gates the coverage-carrying corollaries `map_waaFullyEnlightened_iff`, `map_faith_object_eq`, and `map_waaFaithPrinciple_reflect`. ============================================================================== -/ namespace CoverageNegative open Grid.DirectedConvention def embedIntoNat : DisplayReparam Unit Nat where toFun _ := 0 le_iff _ _ := ⟨fun _ => Nat.le_refl 0, fun _ => True.intro⟩ atBot_bot := Nat.le_refl 0 theorem embedIntoNat_not_surjective (u : Unit) : embedIntoNat.toFun u ≠ 1 := by intro h cases h theorem directionVoid_unit : DirectionVoid Unit := no_strict_of_all_orderEq (fun _ _ => ⟨True.intro, True.intro⟩) theorem strict_zero_one : Strict (0 : Nat) 1 := ⟨Nat.zero_le 1, fun h => Nat.not_succ_le_zero 0 h⟩ theorem not_directionVoid_nat : ¬ DirectionVoid Nat := fun h => h 0 1 strict_zero_one /-- Packaged in the `oldEqTerminus_not_invariant` style: the reparameterization exists, coverage fails at `1`, the source is direction-void, and the target is not. -/ theorem directionVoid_needs_coverage : (∀ u : Unit, embedIntoNat.toFun u ≠ 1) ∧ DirectionVoid Unit ∧ ¬ DirectionVoid Nat := ⟨embedIntoNat_not_surjective, directionVoid_unit, not_directionVoid_nat⟩ def phantomGrid : Grid Unit where Being := Unit Call := Unit Response := Bool respondsTo _ _ := some true grade _ _ _ := () conditions _deed reception := reception.response = false def phantomDeed : phantomGrid.Weld := ⟨(), (), true⟩ def phantomReception : phantomGrid.Weld := ⟨(), (), false⟩ theorem phantom_waaFullyEnlightened : WaaFullyEnlightened phantomGrid () := by refine ⟨?_, ?_⟩ · exact ⟨fun _ => ⟨true, rfl⟩, fun _ _ _ => True.intro⟩ · intro before _deed _reception _hdeed hlive _hdel exact False.elim (hlive True.intro) theorem not_waaFullyEnlightened_map : ¬ WaaFullyEnlightened (phantomGrid.map embedIntoNat) () := by intro h let liveBefore : Config Nat := ⟨1⟩ have hlive : ¬ AtBot liveBefore.tendency := by intro hbot exact Nat.not_succ_le_zero 0 hbot have hdel : DeliveredTo (phantomGrid.map embedIntoNat) phantomDeed phantomReception := rfl have hlanding : HasShareDropLanding (phantomGrid.map embedIntoNat) liveBefore phantomDeed := h.right liveBefore phantomDeed phantomReception rfl hlive hdel rcases hlanding with ⟨reception, hland⟩ have hlands : LandsAt (phantomGrid.map embedIntoNat) phantomDeed reception := hland.left have hdelivered : reception.response = false := hlands.left have hactual : (phantomGrid.map embedIntoNat).respondsTo reception.agent reception.call = some reception.response := hlands.right cases reception with | mk agent call response => cases agent cases call cases response · cases hactual · cases hdelivered theorem waaFullyEnlightened_needs_coverage : WaaFullyEnlightened phantomGrid () ∧ ¬ WaaFullyEnlightened (phantomGrid.map embedIntoNat) () := ⟨phantom_waaFullyEnlightened, not_waaFullyEnlightened_map⟩ end CoverageNegative /- ============================================================================== §O Weld-boundary freedom: pairing is not grid-carried This is one level below the being-boundary witness. `no_partition_recovery` freed the who; this frees what counts as one act. The same field data support both a merged reading of the call-response pairings and a split reading by weld-grain. Holding one weld-grain as floor furniture claims a fact the grid's data does not carry. ============================================================================== -/ namespace WeldNegative /-- A diagnosis-time segmentation of welds into macro pairings. Kept local to the witness so weld individuation remains a reading rather than a field of `Grid`. -/ structure WeldSegmentation (G : Grid Nat) (Macro : Type) where proj : G.Weld → Macro namespace WeldSegmentation variable {G : Grid Nat} {Macro : Type} (σ : WeldSegmentation G Macro) def SamePairing (p q : G.Weld) : Prop := σ.proj p = σ.proj q end WeldSegmentation /-- Two fact-identical fine exchanges over a symmetric field. -/ def twoWeldGrid : Grid Nat where Being := Unit Call := Bool Response := Bool respondsTo _ c := some c grade _ _ _ := 0 conditions _ _ := True def wFalse : twoWeldGrid.Weld := ⟨(), false, false⟩ def wTrue : twoWeldGrid.Weld := ⟨(), true, true⟩ /-- Merged reading: both fine welds are one macro act. -/ def σmerge : WeldSegmentation twoWeldGrid Unit where proj _ := () /-- Split reading: each fine weld remains its own act-grain. -/ def σsplit : WeldSegmentation twoWeldGrid Bool where proj w := w.call theorem merge_same_pairing : σmerge.SamePairing wFalse wTrue := rfl theorem split_not_same_pairing : ¬ σsplit.SamePairing wFalse wTrue := by intro h cases h /-- The grid data visible to a would-be weld-boundary recovery function. -/ abbrev W := RawWeld Unit Bool Bool abbrev GridData : Type := (Unit → Bool → Option Bool) × (Unit → Bool → Bool → Nat) × (W → W → Prop) def gridData : GridData := (twoWeldGrid.respondsTo, twoWeldGrid.grade, twoWeldGrid.conditions) def mergedPairing (_p _q : W) : Prop := True def splitPairing (p q : W) : Prop := p.call = q.call /-- The weld's individuation is a segmentation convention over the correlational field, never recoverable from it. The same grid data support both merge and split readings, which disagree on the concrete false/true pair. -/ theorem no_weld_boundary_recovery : ¬ ∃ recover : GridData → W → W → Prop, recover gridData = mergedPairing ∧ recover gridData = splitPairing := by rintro ⟨recover, hmerge, hsplit⟩ have hmerged : recover gridData wFalse wTrue := by rw [hmerge] exact True.intro have hsplitNot : ¬ recover gridData wFalse wTrue := by rw [hsplit] intro h cases h exact hsplitNot hmerged end WeldNegative /- ============================================================================== §P Doer/deed priority freedom: priority is not grid-carried MMK 8 anchor: kāraka proceeds dependent on karman; neither side is prior or independently based. The witness keeps priority as a reading over visible grid data rather than adding a priority primitive to `Grid`. ============================================================================== -/ namespace DoerDeedNegative /-- Reuse the small two-call grid shape: one visible doer tag and two visible deeds, with no priority field in the data. -/ abbrev W := RawWeld Unit Bool Bool abbrev GridData : Type := (Unit → Bool → Option Bool) × (Unit → Bool → Bool → Nat) × (W → W → Prop) def gridData : GridData := (WeldNegative.twoWeldGrid.respondsTo, WeldNegative.twoWeldGrid.grade, WeldNegative.twoWeldGrid.conditions) /-- Priority reading: the visible being is read as standing prior to its deed. -/ def beingPriorReading (_b : Unit) (_deed : W) : Prop := True /-- Mutual-dependence reading: the same visible data are read with no prior doer standing behind the deed. -/ def mutualReading (_b : Unit) (_deed : W) : Prop := False theorem priority_readings_disagree : beingPriorReading () WeldNegative.wFalse ∧ ¬ mutualReading () WeldNegative.wFalse := by constructor · exact True.intro · intro h exact h theorem no_priority_recovery : ¬ ∃ recover : GridData → Unit → W → Prop, recover gridData = beingPriorReading ∧ recover gridData = mutualReading := by rintro ⟨recover, hprior, hmutual⟩ have hPrior : recover gridData () WeldNegative.wFalse := by rw [hprior] exact priority_readings_disagree.left have hMutualNot : ¬ recover gridData () WeldNegative.wFalse := by rw [hmutual] exact priority_readings_disagree.right exact hMutualNot hPrior end DoerDeedNegative end WAA ===== FILE: WeldAndArrow/Meta/Nishitani.lean ===== /- ================================================================================ WeldAndArrow.Meta.Nishitani Śūnyatā on the re-emptying ladder — the Nishitani/Jizang layer as a consumer of the checked ladder in WeldAndArrow.Consequences.ContentRows ================================================================================ This file is a *consumer* of the re-emptying ladder: it defines philosophical vocabulary as thin wrappers over the ladder's API and re-derives the v1/v2 results as corollaries. It introduces no new distinctions, no new ladders, and proves nothing the ladder does not already license. On placement: metaphysically upstream, import-graph downstream. The file sits in `Meta/` because it is the metaphysical reading of the whole development, but it *imports* `WeldAndArrow.Consequences.ContentRows`, since every theorem here is a one-liner over the ladder. That the direction of `import` runs opposite to the direction of philosophical priority is itself a conventional designation, and the file is content to let it fuse at the floor. Namespace placement follows the project's discipline — names are placed by what their reading presupposes, not by what their definition consumes. The śūnyatā vocabulary presupposes the innermost grid-lens reading, so it lives at `Grid.DirectedConvention.BeingConvention.GridConvention.Nishitani`. The modal appendix presupposes nothing of the grid and lives at `WAA.Nishitani`. ## What the rebase changes (relative to v2's syntactic Position ladder) v2's Part III (the syntactic `Position` ladder) is **superseded**: * **Conventionalization is now semantic.** In v2, each stated ultimate reappeared as a *subterm* of the next conventional (`rfl` on syntax). Here, rung n+1's claim `finalBelow` has as its truth-condition *the lower rung's `Freeze`*: the absolutization of level n becomes an evaluable sentence of level n+1's object language — and, given an error-free seed, is refuted at every live tier. The un-saying is a theorem, not a constructor. Meanwhile `liveBelow` preserves the lower rung's live separation: re-emptying negates only the grasping (執), never the provisional function (仮). * **言忘慮絶 lives at the floor.** v2 faced a fork: represent the fourth ultimate as a marked gap (`Option Position` / `none`) or exile it to a meta-theorem. The ladder's design is a third option superior to both: the ground tier is *in* the tier type, nothing is `Live` there, and every claim trivializes — at the floor, all words are idle and every obedient distinction fuses. Ineffability without a gap and without ascent. * **真空妙有 is a hypothesis, structurally.** The contentful-beings ladder obeys only given `∃ b, ¬ G.Stone b`: the emptiness of beings is available only where there is a being. v1's vacuity disease is not merely avoided but *excluded by the signature*. * **The Middle is two-sided.** `ObeysSeparateFuse` = separate where live (仮), fuse where not (空); `¬Freeze` rules out eternalism/absolutization, `¬Collapse` rules out annihilationism (emptiness-sickness on the other flank). 中 is the conjunction, and `ladder_obeys` says the Middle is stable under re-emptying. ## Dictionary (v1/v2 → this development) | v1/v2 | here | |-----------------------------------------|--------------------------------------------| | `Polarity.being` / `.nonbeing` | `sideA` / `sideB` of a seed distinction | | `Field.Context` | live tiers (`Tier.actTime _` with a live share) | | totality of `Field.polarity` | totality of `language.Holds` | | `SelfNature`, `AbsoluteNothingEntity` | `Distinction.Freeze` ("survives the floor") | | `no_reified_absolute_nothing` | `Grid.not_freeze_of_obeysSeparateFuse` | | `Position` ladder, `no_final_ultimate` | `ladder`, `no_final_level_of_errorFree` | | rung-4 ineffability | floor trivialization (`words_idle_at_floor`) | | `provisionally_designated_middle` | `ObeysSeparateFuse` + `ladder_obeys` | | (unguarded flank in v1/v2) | `Collapse`, `ladder_collapse_self_refuting` | ## API consumed (all from WeldAndArrow.Theory / WeldAndArrow.Theorems) At `Grid` level: `Grid Contrib`, `G.Weld`, `G.Being`, `G.Stone`, `Tier.floor`, `Tier.actTime`, `Distinction` (with `language`, `sideA`, `sideB`, `Separated`, `Freeze`, `Collapse`, `ObeysSeparateFuse`), `ClaimLanguage` (with `Claim`, `Holds`), `ErrorFree`, `Grid.not_freeze_of_obeysSeparateFuse`. At `GridConvention` level: `LadderSide`, `reEmptied`, `ladder`, `ladder_obeys`, `ladder_errorFree_of_errorFree`, `ladder_collapse_self_refuting`, `no_level_final_of_obeys`, `no_final_level_of_errorFree`, `beingsRow`, `beingsLadder_no_level_final`, `beforeAfterRow`, `beforeAfterLadder_no_level_final`, `intraWeldArrowRow`, `intraWeldArrowLadder_no_level_final`, `weldRow`, `weldLadder_no_level_final`, `doerDeedRow`, `doerDeedLadder_no_level_final`, `contentBeingsRow`, `contentBeingsLadder_no_level_final_of_being`. The two theorems the draft marked (†) — the only places a tier is mentioned explicitly — go through unchanged: `Tier` is per-grid (`Tier G`) and `actTime` is indexed by `G.Weld`, exactly as assumed. -/ import WeldAndArrow.Consequences.ContentRows namespace WAA namespace Grid namespace DirectedConvention namespace BeingConvention namespace GridConvention namespace Nishitani open LadderSide variable {Contrib : Type} [PreorderBot Contrib] variable {G : Grid Contrib} /-! ## The vocabulary, as wrappers -/ /-- 執 — absolutization, the reified Absolute Nothing generalized: a distinction freezes when it claims to survive the floor, i.e. to hold where nothing is live. v1 modeled this as an *entity* that is non-being in every context; the ladder's `Freeze` is the better rendering, since what gets absolutized is never a thing but a *distinction* — including, for the metaphysical nihilist, the Nothing/Something distinction itself. -/ abbrev Absolutized (d : Distinction G) : Prop := d.Freeze /-- 断 — the annihilationist error at a tier: a live distinction whose sides have been fused. Emptiness-sickness erases working distinctions; the Middle refuses this flank as firmly as the other. -/ abbrev Annihilated (d : Distinction G) (t : Tier G) : Prop := d.Collapse t /-- 中 — the Middle, rebased: separate exactly where live (仮, provisional validity), fuse exactly where not (空, no residue at the ground). Not a compromise between the flanks but the discipline that excludes both. -/ abbrev MiddleWay (d : Distinction G) : Prop := d.ObeysSeparateFuse /-- 空 — śūnyatā of a distinction: no level of its re-emptying ladder ever freezes. Not a property of the seed alone but a fact about the whole unbounded process of its de-absolutization: there is no final level at which the distinction — or its emptying, or the emptying of *that* — congeals into an ultimate. -/ def Sunyata (d : Distinction G) : Prop := ¬ ∃ n, (ladder d n).Freeze /-! ## The core theorems, as corollaries -/ /-- An error-free seed suffices for śūnyatā: the ladder's cumulative form, in which each level's non-freezing is supplied by the level below rather than by fresh premises. Emptying, once begun without error, propagates for free — 空空 costs nothing after the first emptying. -/ theorem sunyata_of_errorFree {d : Distinction G} (h : ErrorFree G d) : Sunyata d := no_final_level_of_errorFree (G := G) h /-- Alternatively, from full obedience of the seed. -/ theorem sunyata_of_middle {d : Distinction G} (h : d.ObeysSeparateFuse) : Sunyata d := fun ⟨n, hf⟩ => no_level_final_of_obeys (G := G) h n hf /-- 空空 — the emptiness of emptiness, rebased: every re-emptied level is itself error-free, hence itself empty-able. In v1 this was a hypothesis applied to a reified emptiness-entity; here it is *generated*: the ladder manufactures its own next emptying. -/ theorem emptiness_of_emptiness {d : Distinction G} (h : ErrorFree G d) : ∀ n, ErrorFree G (ladder d (n + 1)) := ladder_errorFree_of_errorFree (G := G) h /-- The Middle is stable under re-emptying: no rung of the ladder is anything other than the Middle. Jizang's four levels are not four positions but one discipline, iterated. -/ theorem middle_at_every_level {d : Distinction G} (h : d.ObeysSeparateFuse) : ∀ n, MiddleWay (ladder d n) := ladder_obeys (G := G) h /-- The annihilationist flank, closed at every level: no rung ever collapses a live distinction. Emptiness that erased the conventional would not be the Middle; the ladder proves it never does. -/ theorem no_annihilation_at_any_level {d : Distinction G} (h : d.ObeysSeparateFuse) : ∀ n t, ¬ Annihilated (ladder d n) t := ladder_collapse_self_refuting (G := G) h /-! ## Jizang's rungs, located on the ladder Rung n's conventional truth = the live separation of `ladder d n` (its 仮); rung n's ultimate = the fact `¬ (ladder d n).Freeze` (its 空); and rung n+1 *internalizes* rung n's ultimate: the claim `finalBelow` of level n+1's language means, at every act-time tier, exactly that level n froze. The two `Iff.rfl`s below are the philosophical heart of the rebase: the internalization is definitional, and it preserves 仮 while targeting 執. -/ /-- Rung n's absolutization is a *sentence* of rung n+1: the truth-condition of `finalBelow` at any act-time tier is definitionally the lower rung's `Freeze`. Every stated ultimate is already the next level's conventional material — conventionalization by `Iff.rfl`. -/ theorem ultimate_internalized (d : Distinction G) (n : Nat) (w : G.Weld) : (ladder d (n + 1)).language.Holds (Tier.actTime w) finalBelow ↔ (ladder d n).Freeze := Iff.rfl /-- The provisional is preserved: `liveBelow` at rung n+1 means exactly the lower rung's live separation. Re-emptying un-says the finality claim and *only* the finality claim; the working distinction passes upward intact. 色 is not consumed by 空. -/ theorem provisional_preserved (d : Distinction G) (n : Nat) (w : G.Weld) : (ladder d (n + 1)).language.Holds (Tier.actTime w) liveBelow ↔ (ladder d n).Separated (Tier.actTime w) := Iff.rfl /-- 言忘慮絶 — at the floor, every claim of a re-emptied level holds trivially: all words are idle at the ground, so no separation survives there and every obedient distinction fuses. The fourth "ultimate" is neither a gap in the language nor a meta-theorem in exile: it is the tier at which language, still present, does no work. -/ theorem words_idle_at_floor (d : Distinction G) (c : LadderSide) : (reEmptied d).language.Holds Tier.floor c := by cases c <;> exact True.intro /-! ## The metaphysical nihilist, relocated In v2, the nihilist's "there could have been Absolute Nothing instead of Something" was rung 0's ultimate, conventionalized at rung 1. On the ladder the diagnosis sharpens into three theorems: 1. The thesis is *statable*: it is `finalBelow`, a `Claim` of rung 1's language — and a claim in a language is a something. Asserting the ultimacy of Nothing manufactures the linguistic being that asserts it (v2's `nihilism_is_an_existence_proof`, now internal to the ladder). 2. The thesis is *evaluable and false* wherever anything is alive (`nihilist_refuted_at_every_rung` below): given an error-free seed, no rung freezes, so `finalBelow` fails at every live tier. 3. At the floor the thesis "holds" — but only as everything does (`words_idle_at_floor`): trivially, idly, doing no separating work. The nihilist may retreat to the ground, but at the ground their thesis says nothing that silence does not. And the nihilist is not a *position* on the ladder but a recurring *side*: at every rung n+1 they reappear as that rung's `finalBelow` — the voice claiming the previous level was final after all — and are refuted uniformly. Not wrong so much as perpetually early, at every level at once. -/ /-- The nihilist's thesis exists: rung 1's language contains it. Statability is somethinghood. -/ theorem nihilist_thesis_is_something (d : Distinction G) : Nonempty ((reEmptied d).language.Claim) := ⟨finalBelow⟩ /-- The nihilist refuted at every rung: no level of the ladder is absolute, so the claim "the level below was final" fails wherever it is live. -/ theorem nihilist_refuted_at_every_rung {d : Distinction G} (h : ErrorFree G d) : ∀ n, ¬ Absolutized (ladder d n) := fun n hf => no_final_level_of_errorFree (G := G) h ⟨n, hf⟩ /-! ## Instantiations at the concrete rows -/ /-- 有無 — śūnyatā of the beings distinction: no level of its re-emptying ladder freezes. Nishitani's central claim, at the schema's native row. -/ theorem beings_sunyata (G : Grid Contrib) : Sunyata (beingsRow G) := fun ⟨n, hf⟩ => beingsLadder_no_level_final G n hf /-- Śūnyatā of the before/after distinction: time's arrow functions where live and claims no floor — Nishitani's non-reified time, on which impermanence is neither an illusion (collapse) nor an absolute (freeze). -/ theorem time_sunyata (G : Grid Contrib) : Sunyata (beforeAfterRow G) := fun ⟨n, hf⟩ => beforeAfterLadder_no_level_final G n hf /-- Śūnyatā of the intra-weld arrow: the interior order functions where live and claims no floor. MMK 8's checked interior form joins the ladder rather than becoming hidden furniture inside a weld. -/ theorem intraWeldArrow_sunyata (G : Grid Contrib) : Sunyata (intraWeldArrowRow G) := fun ⟨n, hf⟩ => intraWeldArrowLadder_no_level_final G n hf /-- Śūnyatā of the weld-grain distinction: the weld held as svabhāva is the last unemptied level only while unnamed. Once named as a convention layer, it enters the same re-emptying ladder as the other readings. -/ theorem weld_sunyata (G : Grid Contrib) : Sunyata (weldRow G) := fun ⟨n, hf⟩ => weldLadder_no_level_final G n hf /-- Śūnyatā of doer/deed dependence: the mutual dependence itself is empty, so the row that denies a prior doer also refuses to freeze that denial as a final floor. -/ theorem doerDeed_sunyata (G : Grid Contrib) : Sunyata (doerDeedRow G) := fun ⟨n, hf⟩ => doerDeedLadder_no_level_final G n hf /-- 真空妙有 — true emptiness, wondrous being: the śūnyatā of contentful beings is available *only given a being*. The hypothesis is not a technical convenience but the doctrine itself in signature form: 色即是空 requires 色. An empty world does not model this emptiness; it fails to supply `h`. v1's vacuity disease is excluded by the type. -/ theorem wondrous_being (G : Grid Contrib) (h : ∃ b : G.Being, ¬ G.Stone b) : Sunyata (contentBeingsRow G) := fun ⟨n, hf⟩ => contentBeingsLadder_no_level_final_of_being (G := G) h n hf end Nishitani end GridConvention end BeingConvention end DirectedConvention end Grid /-! ## Appendix — the modal argument (self-contained, unchanged in substance) Part II of v2 survives the rebase intact because it never depended on the Position ladder; it is retained here as the frame-level companion to the ladder-level relocation above. Placed at `WAA.Nishitani` rather than under the grid lens because, per the naming discipline, it presupposes nothing of the grid: worlds and concreta only. The correspondence: `MetaphysicalNihilism`'s frame-relativity (`Frame → Prop`) is the external face of what `nihilist_thesis_is_something` shows internally — the thesis cannot be had without the field it was meant to escape. -/ namespace Nishitani /-- A modal frame: worlds, and the concreta each world contains. -/ structure Frame where World : Type Concreta : World → Type /-- The nihilist's candidate Absolute Nothing: a world with no concreta. -/ def IsEmptyWorld (M : Frame) (w : M.World) : Prop := ¬ Nonempty (M.Concreta w) /-- Metaphysical nihilism, as statable: some world is empty. Note the type `Frame → Prop` — no frame-free formulation exists to assert. -/ def MetaphysicalNihilism (M : Frame) : Prop := ∃ w : M.World, IsEmptyWorld M w /-- Asserting the possibility of Nothing is an existence proof of Something: the thesis's truth requires a witness, and a possibility is a something. -/ theorem nihilism_is_an_existence_proof (M : Frame) (h : MetaphysicalNihilism M) : Nonempty M.World := h.elim fun w _ => ⟨w⟩ /-- The absolute reading — nothing at all, not even the possibility — is unassertible: with no worlds, the thesis is unavailable, not true. -/ theorem no_worlds_no_thesis (M : Frame) (h : ¬ Nonempty M.World) : ¬ MetaphysicalNihilism M := fun hn => h (nihilism_is_an_existence_proof M hn) end Nishitani /-! Closing caveat, one rung higher than before: `Sunyata` above is a name, `sunyata_of_errorFree` a stated theorem, and by `ultimate_internalized` the ladder is already prepared to treat this file's own conclusions as the `finalBelow` of a level it has not yet built. It was built to climb through this file too — and, this time, that is a theorem about *its* ladder rather than mine. -/ end WAA ===== FILE: WeldAndArrow/Meta/ReflexivityWitness.lean ===== /- ================================================================================ WeldAndArrow.Meta.ReflexivityWitness One rung-indexed grid witnessing the ladder over its own labels ================================================================================ Jizang's fourfold two-truths are re-emptied here over their own rung labels. This is a single legal grid instantiating the opaque `Being` parameter with `Nat`; it is not a definition of `Being`, and it does not disturb the boundary-freedom witnessed by `BeingNegative`. -/ import WeldAndArrow.Meta.Nishitani namespace WAA namespace Grid namespace DirectedConvention namespace BeingConvention namespace GridConvention /-- A concrete grid whose being carrier is read as ladder-rung labels. This is one legal instantiation of the signature parameter, not a recovered being boundary or a claim that beings are numbers. -/ def ladderRungGrid : Grid Nat where Being := Nat Call := Unit Response := Unit respondsTo _ _ := some () grade b _ _ := b conditions _ _ := True theorem ladderRungGrid_beings_sunyata : Nishitani.Sunyata (beingsRow ladderRungGrid) := Nishitani.beings_sunyata ladderRungGrid theorem ladderRungGrid_no_level_final : ∀ n, ¬ (beingsLadder ladderRungGrid n).Freeze := beingsLadder_no_level_final ladderRungGrid end GridConvention end BeingConvention end DirectedConvention end Grid end WAA ===== FILE: WeldAndArrow/Meta/VerdictLedger.lean ===== /- ================================================================================ WeldAndArrow.Meta.VerdictLedger The verdict history as inspectable data ================================================================================ The theorem-file history paragraph is inductive testimony at the outer edge: Lean cannot prove that the episodes happened, that the retypes were forced rather than chosen, that they were recorded before later objections, or that a future decline-and-retype rate will not shrink. What this module can check is the office discipline around that testimony. The ledger stores episode-grained entries, then derives the paragraph's aggregate claims from the list: the number of retypes, the six displayed restraint kinds, anchor cross-references, and the structural half of the falsifier. In particular, the four retypes are four entries, not one entry carrying a multiplicity field. -/ import WeldAndArrow.Consequences.Taxonomy import WeldAndArrow.Meta.InvarianceNegative import WeldAndArrow.Identification.Residues namespace WAA /- ============================================================================== Verdict history data ============================================================================== -/ /-- The four public verdict-shapes named by the theorem-file generator paragraph, as a small ledger vocabulary. The semantic `GeneratorOutcome` over concrete distinctions remains in `Signature/Claims.lean`; this type is only the history paragraph's record code. -/ inductive Verdict | landed | newCell | declined | retype deriving DecidableEq, Repr, BEq /-- The cases listed in the verdict-history paragraph, in paragraph order. -/ inductive LedgerCaseName | zahavi | dispositionActCell | arrow | intraWeldArrow | terminusQuestion | foxQuestion | deafBlind | openDeliveryQuestions | seriesQuestions deriving DecidableEq, Repr, BEq /-- Outcomes recorded by the ledger. `noVerdict` and `ceded` are not generator verdicts; they are ledger postures for open delivery questions and ceded series questions. -/ inductive Outcome | verdict (v : Verdict) | noVerdict | ceded deriving DecidableEq, Repr, BEq /-- Prose anchors carried at episode grain. -/ inductive ProseAnchor | proofsZahavi | theoryAttainmentDispositionAct | theoryDeafBlindDecline | openDeliveryQuestions | seriesQuestions deriving DecidableEq, Repr, BEq /-- Lean anchors carried at episode grain. Separate examples below mention the declarations by name so ordinary renames break this module. -/ inductive LeanAnchor | directionNegative | interiorDirectionNegative | transpositionPair | foxLiveOffer | misFeedFenceGate deriving DecidableEq, Repr, BEq /-- The anchoring situation for one ledger episode. -/ inductive RecordAnchor | prose (anchor : ProseAnchor) | lean (anchor : LeanAnchor) deriving DecidableEq, Repr, BEq /-- One entry in the generator's self-ledger. The decomposition booleans are deliberately light data. They let the structural falsifier fail when a future mis-feed verdict is entered without its decomposition, but they do not prove that an author tagged the future case honestly. -/ structure RecordEntry where name : LedgerCaseName outcome : Outcome anchors : List RecordAnchor requiresDecomposition : Bool decompositionCarried : Bool deriving DecidableEq, Repr, BEq /-- The verdict-history paragraph as episode-grained data. -/ def generatorRecord : List RecordEntry := [ { name := .zahavi outcome := .verdict .retype anchors := [.prose .proofsZahavi] requiresDecomposition := false decompositionCarried := false }, { name := .dispositionActCell outcome := .verdict .retype anchors := [.prose .theoryAttainmentDispositionAct] requiresDecomposition := false decompositionCarried := false }, { name := .arrow outcome := .verdict .retype anchors := [.lean .directionNegative] requiresDecomposition := false decompositionCarried := false }, { name := .intraWeldArrow outcome := .verdict .retype anchors := [.lean .interiorDirectionNegative] requiresDecomposition := false decompositionCarried := false }, { name := .terminusQuestion outcome := .verdict .landed anchors := [.lean .transpositionPair, .lean .misFeedFenceGate] requiresDecomposition := true decompositionCarried := true }, { name := .foxQuestion outcome := .verdict .landed anchors := [.lean .foxLiveOffer] requiresDecomposition := true decompositionCarried := true }, { name := .deafBlind outcome := .verdict .declined anchors := [.prose .theoryDeafBlindDecline] requiresDecomposition := false decompositionCarried := false }, { name := .openDeliveryQuestions outcome := .noVerdict anchors := [.prose .openDeliveryQuestions] requiresDecomposition := false decompositionCarried := false }, { name := .seriesQuestions outcome := .ceded anchors := [.prose .seriesQuestions] requiresDecomposition := false decompositionCarried := false } ] example : generatorRecord.length = 9 := rfl example : generatorRecord.map RecordEntry.name = [.zahavi, .dispositionActCell, .arrow, .intraWeldArrow, .terminusQuestion, .foxQuestion, .deafBlind, .openDeliveryQuestions, .seriesQuestions] := rfl /-- The paragraph's "four retypes" claim is derived from the episode list. -/ theorem generatorRecord_retype_count : (generatorRecord.filter (fun e => e.outcome == Outcome.verdict Verdict.retype)).length = 4 := rfl /-- No current episode forces a new row; the ledger adds no `RowTag`. -/ theorem generatorRecord_newCell_count : (generatorRecord.filter (fun e => e.outcome == Outcome.verdict Verdict.newCell)).length = 0 := rfl /- ============================================================================== Restraint-kind projection ============================================================================== -/ /-- The six displayed kinds of restraint are a projection from entries, not the ledger's stored grain. -/ inductive RestraintKind | forcedRetype | answeredAtCheapDissolution | answeredAvyakataShaped | declinedNoError | standingNoVerdict | cededWholesale deriving DecidableEq, Repr, BEq /-- Coarsen an episode to the six-kind display view. -/ def restraintKind (e : RecordEntry) : RestraintKind := match e.name with | .zahavi => .forcedRetype | .dispositionActCell => .forcedRetype | .arrow => .forcedRetype | .intraWeldArrow => .forcedRetype | .terminusQuestion => .answeredAtCheapDissolution | .foxQuestion => .answeredAvyakataShaped | .deafBlind => .declinedNoError | .openDeliveryQuestions => .standingNoVerdict | .seriesQuestions => .cededWholesale /-- The universe of restraint-kind display labels. -/ def allRestraintKinds : List RestraintKind := [ .forcedRetype, .answeredAtCheapDissolution, .answeredAvyakataShaped, .declinedNoError, .standingNoVerdict, .cededWholesale ] /-- A display kind is seen when some episode projects to it. -/ def restraintKindSeen (k : RestraintKind) : Bool := generatorRecord.any (fun e => restraintKind e == k) example : allRestraintKinds.length = 6 := rfl /-- The paragraph's "six kinds" is checked on the image of `generatorRecord`. -/ theorem generatorRecord_restraintKind_seen_count : (allRestraintKinds.filter restraintKindSeen).length = 6 := rfl /-- Every restraint-kind constructor occurs as the image of some ledger entry. -/ theorem restraintKind_exhaustive_on_record : ∀ k : RestraintKind, restraintKindSeen k = true := by intro k cases k <;> rfl /- ============================================================================== Anchor pins ============================================================================== -/ example := @DirectionNegative.no_direction_recovery_from_conditionsEither example := @InteriorDirectionNegative.no_interior_direction_recovery example := @Grid.DirectedConvention.BeingConvention.GridConvention.exit_collapse_self_refuting example := @Grid.DirectedConvention.BeingConvention.GridConvention.transposition_erased_downward_collapse_self_refuting example := @Grid.DirectedConvention.BeingConvention.GridConvention.fox_utterance_misfits_live_offer example := @MisFeedNegative.fence_and_gate /- ============================================================================== Structural falsifier pin ============================================================================== -/ /-- One entry discharges the structural half of the falsifier exactly when it either is not a mis-feed verdict or carries the decomposition the prose says such verdicts owe. -/ def decompositionDutyDischarged (e : RecordEntry) : Bool := (!e.requiresDecomposition) || e.decompositionCarried /-- Checkable half of the falsifier: current mis-feed verdicts in the ledger carry their decompositions. The rate-trend half quantifies over future entries and remains prose. -/ theorem misFeed_entries_carry_decomposition : generatorRecord.all decompositionDutyDischarged = true := rfl end WAA ===== FILE: WeldAndArrow/Signature.lean ===== import WeldAndArrow.Signature.Order import WeldAndArrow.Signature.Grid import WeldAndArrow.Signature.BeingConvention import WeldAndArrow.Signature.DirectionConvention import WeldAndArrow.Signature.Models import WeldAndArrow.Signature.Claims import WeldAndArrow.Signature.Assumptions ===== FILE: WeldAndArrow/Signature/Assumptions.lean ===== import WeldAndArrow.Signature.Order import WeldAndArrow.Signature.Grid import WeldAndArrow.Signature.BeingConvention import WeldAndArrow.Signature.DirectionConvention import WeldAndArrow.Signature.Models import WeldAndArrow.Signature.Claims /-! Input-side assumption pins for the `Signature` layer. This file is the compile-time tripwire for the system's input surface: the `#check` pins and definitional examples below keep existence and type shape close to the declarations they name, so rename or type drift becomes a build failure. The canonical prose and anchor metadata live in `WeldAndArrow/Meta/AssumptionLedger.lean`, rendered for readers at `Exposition/Assumptions.md`. -/ namespace WAA namespace AssumptionLocalWitnesses /- Direction witness kept local so `Signature.Assumptions` does not import downstream `Meta` modules. -/ abbrev DirectionW := RawWeld Unit Bool Unit def directionFalse : DirectionW := ⟨(), false, ()⟩ def directionTrue : DirectionW := ⟨(), true, ()⟩ def directionForwardGrid : Grid Nat where Being := Unit Call := Bool Response := Unit respondsTo _ _ := some () grade _ _ _ := 0 conditions w₁ w₂ := w₁.call = false ∧ w₂.call = true def directionBackwardGrid : Grid Nat where Being := Unit Call := Bool Response := Unit respondsTo _ _ := some () grade _ _ _ := 0 conditions w₁ w₂ := w₁.call = true ∧ w₂.call = false theorem direction_conditionsEither_agrees (w₁ w₂ : DirectionW) : directionForwardGrid.ConditionsEither w₁ w₂ ↔ directionBackwardGrid.ConditionsEither w₁ w₂ := ⟨fun h => h.elim (fun ⟨h1, h2⟩ => Or.inr ⟨h2, h1⟩) (fun ⟨h1, h2⟩ => Or.inl ⟨h2, h1⟩), fun h => h.elim (fun ⟨h1, h2⟩ => Or.inr ⟨h2, h1⟩) (fun ⟨h1, h2⟩ => Or.inl ⟨h2, h1⟩)⟩ theorem direction_conditions_disagree : directionForwardGrid.conditions directionFalse directionTrue ∧ ¬ directionBackwardGrid.conditions directionFalse directionTrue := by constructor · exact ⟨rfl, rfl⟩ · intro h cases h.left theorem no_direction_recovery_from_conditionsEither : ¬ ∃ recover : (DirectionW → DirectionW → Prop) → (DirectionW → DirectionW → Prop), recover directionForwardGrid.ConditionsEither = directionForwardGrid.conditions ∧ recover directionBackwardGrid.ConditionsEither = directionBackwardGrid.conditions := by rintro ⟨recover, hf, hb⟩ have hsame : directionForwardGrid.ConditionsEither = directionBackwardGrid.ConditionsEither := by funext w₁ w₂ exact propext (direction_conditionsEither_agrees w₁ w₂) have hcond : directionForwardGrid.conditions = directionBackwardGrid.conditions := by rw [← hf, hsame, hb] exact direction_conditions_disagree.right (hcond ▸ direction_conditions_disagree.left) open Grid.DirectedConvention.BeingConvention def partitionGrid : Grid Nat where Being := Bool Call := Unit Response := Unit respondsTo _ _ := some () grade _ _ _ := 0 conditions _ _ := True def partitionMerge : BeingCoarsening partitionGrid Unit where proj _ := () def partitionSplit : BeingCoarsening partitionGrid Bool where proj := id theorem partition_merge_split_disagree : partitionMerge.SameFiber false true ∧ ¬ partitionSplit.SameFiber false true := by constructor · rfl · intro h cases h theorem nat_preorderBot_has_no_top : ¬ ∃ t : Nat, ∀ x : Nat, x ≼ t := by rintro ⟨t, htop⟩ exact Nat.not_succ_le_self t (htop (Nat.succ t)) theorem signature_self_line_permitted : ∃ w : backslideGrid.Weld, Grid.DirectedConvention.LandsAt backslideGrid w w := by exact ⟨⟨(), Cue.gentle, ()⟩, True.intro, rfl⟩ end AssumptionLocalWitnesses namespace InteriorDirectionNegative /-- A one-being carrier where call and response use the same two-point display type, so the two faces can be transposed without changing their raw unordered content. -/ abbrev W := RawWeld Unit Bool Bool def callThenResponse : W := ⟨(), false, true⟩ def responseThenCall : W := callThenResponse.transposeCR /-- The unordered residue of the two faces: either orientation of the same false/true pair counts as the same displayed content. -/ def unorderedCRContent (w : W) : Prop := w = callThenResponse ∨ w = responseThenCall def callResponseReading (w : W) : Prop := w = callThenResponse def responseCallReading (w : W) : Prop := w = responseThenCall theorem transposeCR_involutive : ∀ w : W, w.transposeCR.transposeCR = w := fun w => RawWeld.transposeCR_transposeCR w theorem unorderedCRContent_transpose_invariant : ∀ w, unorderedCRContent w ↔ unorderedCRContent w.transposeCR := by intro w cases w with | mk agent call response => cases agent cases call <;> cases response <;> simp [unorderedCRContent, callThenResponse, responseThenCall, RawWeld.transposeCR] theorem transpose_swaps_readings : callResponseReading callThenResponse ∧ responseCallReading (callThenResponse.transposeCR) := by constructor <;> rfl theorem call_response_readings_disagree : callResponseReading callThenResponse ∧ ¬ responseCallReading callThenResponse := by constructor · rfl · intro h cases h /-- No recovery function from unordered call/response content can determine which face is the call. Reading "something arrives, then something answers" is already a direction-projection at the smallest grain: by the MMK 8 discipline, doer and deed are mutually dependent, neither prior. The `RawWeld` field names remain useful display labels, not a recovered before-and-after inside the weld. -/ theorem no_interior_direction_recovery : ¬ ∃ recover : (W → Prop) → W → Prop, recover unorderedCRContent = callResponseReading ∧ recover unorderedCRContent = responseCallReading := by rintro ⟨recover, hcall, hresponse⟩ have hcallHolds : recover unorderedCRContent callThenResponse := by rw [hcall] exact call_response_readings_disagree.left have hresponseNot : ¬ recover unorderedCRContent callThenResponse := by rw [hresponse] exact call_response_readings_disagree.right exact hresponseNot hcallHolds end InteriorDirectionNegative section AssumptionAnchors variable {Contrib : Type} [PreorderBot Contrib] variable (G : Grid Contrib) /- A.1 No prior agent. -/ #check RawWeld -- proof #check Grid.index -- proof #check Grid.share -- proof #check no_agent_recovery_of_field_collision -- witness example (w : G.Weld) : G.index w = w.agent := rfl -- proof example (w : G.Weld) : G.share w = G.grade w.agent w.call w.response := rfl -- proof /- A.2 Nothing self-indexed is stored. -/ #check Config -- proof #check Config.tendency -- proof #check Grid.rePitch -- proof example (c : Config Contrib) : c = ⟨c.tendency⟩ := rfl -- proof example (before before' : Config Contrib) (received : G.Weld) : G.rePitch before received = G.rePitch before' received := rfl -- proof example (before : Config Contrib) (received : G.Weld) : (G.rePitch before received).tendency = G.share received := rfl -- proof /- A.3 Self-pole index as live share. -/ #check Grid.HasSelfPoleIndex -- proof #check Grid.selfPoleIndex_eq_agent_of_hasSelfPoleIndex -- proof #check Grid.no_self_pole_index_of_atBot -- proof example (w : G.Weld) : G.HasSelfPoleIndex w ↔ ¬ AtBot (G.share w) := Iff.rfl -- proof example (w : G.Weld) (h : G.HasSelfPoleIndex w) : G.selfPoleIndex w h = G.index w := rfl -- proof /- A.4 Stone / terminus function-share split. -/ #check Grid.Stone -- proof #check Grid.Terminus -- proof #check Grid.AtPoleClass -- proof #check Grid.stone_is_terminus_vacuously -- proof #check clockGrid_function_share_split_witness -- witness /- A.5 Self-lines are permitted. -/ #check Grid.conditions -- proof #check Grid.DirectedConvention.DeliveredTo -- proof #check Grid.DirectedConvention.LandsAt -- proof #check AssumptionLocalWitnesses.signature_self_line_permitted -- witness -- Downstream elaboration recorded in `Meta.AssumptionLedger` (entry A.5). /- B.1 No arrow in conditions. -/ #check Grid.ConditionsEither -- proof #check Grid.conditionsEither_symm -- proof #check Grid.DirectedConvention.TimeDirection -- proof #check Grid.transpose -- witness #check Grid.transpose_conditionsEither_iff -- witness #check Grid.DirectedConvention.transpose_deliveredTo_iff -- witness #check RawWeld.transposeCR -- witness #check AssumptionLocalWitnesses.no_direction_recovery_from_conditionsEither -- witness #check InteriorDirectionNegative.no_interior_direction_recovery -- witness -- Downstream elaboration recorded in `Meta.AssumptionLedger` (entry B.1). /- B.2 No PreorderTop. -/ #check PreorderBot -- proof #check AtBot -- proof -- The strong self-conditioning tag is shelved here as the no-top asymptote. #check Grid.DirectedConvention.BeingConvention.BeingCoarsening.StrongSelfConditioningTag -- comment #check AssumptionLocalWitnesses.nat_preorderBot_has_no_top -- witness /- B.3 No privileged person-partition. -/ #check Grid.DirectedConvention.BeingConvention.BeingCoarsening -- proof #check Grid.DirectedConvention.BeingConvention.BeingCoarsening.InFiber -- proof #check Grid.DirectedConvention.BeingConvention.BeingCoarsening.SameFiber -- proof #check Grid.DirectedConvention.BeingConvention.BeingCoarsening.id -- witness #check Grid.DirectedConvention.BeingConvention.BeingCoarsening.total -- witness #check Grid.DirectedConvention.BeingConvention.BeingCoarsening.total_sameFiber -- witness #check Grid.DirectedConvention.BeingConvention.BeingCoarsening.id_not_sameFiber_of_ne -- witness #check AssumptionLocalWitnesses.partition_merge_split_disagree -- witness -- Downstream elaboration recorded in `Meta.AssumptionLedger` (entry B.3). /- B.4 Direction resolution is display, not signature furniture. -/ #check Grid.DirectedConvention.DirectionCoarsening -- proof #check Grid.DirectedConvention.DirectionCoarsening.SameTick -- proof #check Grid.DirectedConvention.DirectionCoarsening.ResolutionBounded -- proof #check Grid.DirectedConvention.DirectionCoarsening.no_timeDirection_within_tick -- proof #check Grid.DirectedConvention.DirectionCoarsening.no_timeDirection_of_resolutionBounded_subsingleton -- proof #check Grid.DirectedConvention.DirectionCoarsening.transpose_subTickDelivery -- witness -- Downstream elaboration recorded in `Meta.AssumptionLedger` (entry B.4). /- B.5 Contribution values are display, not operational tokens. -/ #check Grid.share_eq_grade_check -- proof #check AtBot -- proof #check OrderEq -- proof #check Grid.Terminus -- proof -- Downstream elaboration recorded in `Meta.AssumptionLedger` (entry B.5). /- C.1 Hand-rolled order classes. -/ #check Preorder -- proof #check PreorderBot -- proof #check shareBot -- proof #check shareBot_le -- proof /- C.2 `_before` is retained but currently ignored by `rePitch`. -/ #check Grid.rePitch -- proof example (before before' : Config Contrib) (received : G.Weld) : G.rePitch before received = G.rePitch before' received := rfl -- proof /- C.3 Scalar display over partial order. -/ #check Grid.share -- proof #check Grid.share_eq_grade_check -- proof -- Downstream elaboration recorded in `Meta.AssumptionLedger` (entry C.3). /- C.4 Model witnesses are illustrative. -/ #check clockGrid -- witness #check registerClockGrid -- witness #check registerClock_macro_sentient -- witness #check registerClock_macro_selfConditioning -- witness /-- info: 'WAA.no_agent_recovery_of_field_collision' does not depend on any axioms -/ #guard_msgs in #print axioms no_agent_recovery_of_field_collision /-- info: 'WAA.Grid.DirectedConvention.DirectionCoarsening.no_timeDirection_within_tick' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.DirectionCoarsening.no_timeDirection_within_tick /-- info: 'WAA.Grid.DirectedConvention.DirectionCoarsening.no_timeDirection_of_resolutionBounded_subsingleton' does not depend on any axioms -/ #guard_msgs in #print axioms Grid.DirectedConvention.DirectionCoarsening.no_timeDirection_of_resolutionBounded_subsingleton end AssumptionAnchors end WAA ===== FILE: WeldAndArrow/Signature/BeingConvention.lean ===== /- ================================================================================ WeldAndArrow.Signature.BeingConvention Being-convention vocabulary and diagnosis-time coarsenings ================================================================================ Reading and motivation: Identification/Commentary.lean, C.1. -/ import WeldAndArrow.Signature.Grid namespace WAA namespace Grid variable {Contrib : Type} [PreorderBot Contrib] variable (G : Grid Contrib) namespace DirectedConvention namespace BeingConvention /- Reading and motivation: Identification/Commentary.lean, C.1. -/ abbrev MountsAt (b : G.Being) (c : G.Call) : Prop := G.MountsAt b c /-- Re-rooted name for mounting at some call. -/ abbrev MountsSomewhere (b : G.Being) : Prop := G.MountsSomewhere b /-- Re-rooted name for call-entire response. -/ abbrev RespondsToEveryCall (b : G.Being) : Prop := G.RespondsToEveryCall b /- Reading and motivation: Identification/Commentary.lean, C.1. -/ abbrev Stone (b : G.Being) : Prop := G.Stone b /-- Re-rooted name for the pole-class responder. -/ abbrev Terminus (b : G.Being) : Prop := G.Terminus b /-- Re-rooted name for non-vacuous terminus response. -/ abbrev LiveTerminus (b : G.Being) : Prop := G.LiveTerminus b /-- Re-rooted name for call-entire terminus response. -/ abbrev ResponsiveTerminus (b : G.Being) : Prop := G.ResponsiveTerminus b /-- Re-rooted name for the two attested arrivals at the pole-class. -/ abbrev AtPoleClass (b : G.Being) : Prop := G.AtPoleClass b /-- Re-rooted name for the probe, because the probe reads a being's composition rather than adding a field to the signature. -/ abbrev ProbeConstant (b : G.Being) (cs : G.Call → Prop) : Prop := G.ProbeConstant b cs /- Reading and motivation: Identification/Commentary.lean, C.1. -/ structure BeingCoarsening (G : Grid Contrib) (Macro : Type) where proj : G.Being → Macro namespace BeingCoarsening variable {G : Grid Contrib} {Macro : Type} (κ : BeingCoarsening G Macro) /-- The identity being coarsening: every fine tag remains its own macro tag. -/ protected def id (G : Grid Contrib) : BeingCoarsening G G.Being where proj := id @[simp] theorem id_proj (p : G.Being) : (BeingCoarsening.id G).proj p = p := rfl /-- The total being coarsening: all fine tags are read as one macro tag. -/ def total (G : Grid Contrib) : BeingCoarsening G Unit where proj _ := () @[simp] theorem total_proj (p : G.Being) : (BeingCoarsening.total G).proj p = () := rfl /-- Post-compose a being coarsening with a macro-tag map. -/ def comp {Macro' : Type} (κ : BeingCoarsening G Macro) (f : Macro → Macro') : BeingCoarsening G Macro' where proj := fun p => f (κ.proj p) @[simp] theorem comp_proj {Macro' : Type} (κ : BeingCoarsening G Macro) (f : Macro → Macro') (p : G.Being) : (κ.comp f).proj p = f (κ.proj p) := rfl /-- A weld lies in a macro tag's fiber when its fine agent projects there. -/ def InFiber (b : Macro) (w : G.Weld) : Prop := κ.proj w.agent = b /- Reading and motivation: Identification/Commentary.lean, C.1. -/ def SameFiber (p q : G.Being) : Prop := κ.proj p = κ.proj q theorem total_sameFiber (p q : G.Being) : (BeingCoarsening.total G).SameFiber p q := rfl theorem id_not_sameFiber_of_ne {p q : G.Being} (h : p ≠ q) : ¬ (BeingCoarsening.id G).SameFiber p q := fun hsame => h hsame /-- A fiber has at least one fine tag under it. -/ def FiberInhabited (b : Macro) : Prop := ∃ p : G.Being, κ.proj p = b /-- A fiber has at least one actual weld under it. This is the live/vacuity guard needed for exclusivity facts below. -/ def ActualFiberInhabited (b : Macro) : Prop := ∃ w : G.Weld, G.Actual w ∧ κ.InFiber b w /-- Some fine tag in the fiber mounts a response somewhere. -/ def SentientTag (b : Macro) : Prop := ∃ p : G.Being, κ.proj p = b ∧ G.MountsSomewhere p /-- A tag is not sentient exactly when every fine tag in its fiber is stone-typed. -/ theorem not_sentientTag_iff_fiber_all_stone (b : Macro) : ¬ κ.SentientTag b ↔ ∀ p : G.Being, κ.proj p = b → G.Stone p := by constructor · intro hnot p hp c hmount exact hnot ⟨p, hp, ⟨c, hmount⟩⟩ · intro hall hsent rcases hsent with ⟨p, hp, c, hmount⟩ exact hall p hp c hmount /-- A sentient macro tag is exactly a fiber with an actual weld. The forward direction turns mounted response-function into the corresponding weld; the reverse direction reads function from an actual weld's response equation. -/ theorem sentientTag_iff_actualFiberInhabited (b : Macro) : κ.SentientTag b ↔ κ.ActualFiberInhabited b := by constructor · rintro ⟨p, hp, c, r, hresp⟩ exact ⟨⟨p, c, r⟩, hresp, hp⟩ · rintro ⟨w, hactual, hfiber⟩ exact ⟨w.agent, hfiber, ⟨w.call, ⟨w.response, hactual⟩⟩⟩ /- Reading and motivation: Identification/Commentary.lean, C.1. -/ def FiberAtPole (b : Macro) : Prop := ∀ w : G.Weld, G.Actual w → κ.InFiber b w → AtBot (G.share w) /-- The live, non-vacuous fiber-at-pole predicate. -/ def LiveFiberAtPole (b : Macro) : Prop := κ.ActualFiberInhabited b ∧ κ.FiberAtPole b /-- A fiber reads at the pole on a supplied call-class. This is neutral fiber vocabulary: downstream doctrines supply the class predicate. -/ def FiberAtPoleOn (b : Macro) (cs : G.Call → Prop) : Prop := ∀ w : G.Weld, G.Actual w → κ.InFiber b w → cs w.call → AtBot (G.share w) /-- Fiber-at-pole restricted on both axes: over a call-class `cs` and a fine tag-class `ts`. The single-axis restrictions and plain fiber reading are its specializations. -/ def FiberAtPoleOnWithin (b : Macro) (cs : G.Call → Prop) (ts : G.Being → Prop) : Prop := ∀ w : G.Weld, G.Actual w → κ.InFiber b w → cs w.call → ts w.agent → AtBot (G.share w) /-- A fiber reads at the pole within a supplied fine tag-class. -/ def FiberAtPoleWithin (b : Macro) (ts : G.Being → Prop) : Prop := κ.FiberAtPoleOnWithin b (fun _ => True) ts /-- A fiber has an actual weld in the supplied call-class. -/ def ActualFiberInhabitedOn (b : Macro) (cs : G.Call → Prop) : Prop := ∃ w : G.Weld, G.Actual w ∧ κ.InFiber b w ∧ cs w.call /-- A fiber has an actual weld whose agent lies in the supplied tag-class. -/ def ActualFiberInhabitedWithin (b : Macro) (ts : G.Being → Prop) : Prop := ∃ w : G.Weld, G.Actual w ∧ κ.InFiber b w ∧ ts w.agent /-- The live, non-vacuous class-restricted fiber-at-pole predicate. -/ def LiveFiberAtPoleOn (b : Macro) (cs : G.Call → Prop) : Prop := κ.ActualFiberInhabitedOn b cs ∧ κ.FiberAtPoleOn b cs /-- The live, non-vacuous tag-restricted fiber-at-pole predicate. -/ def LiveFiberAtPoleWithin (b : Macro) (ts : G.Being → Prop) : Prop := κ.ActualFiberInhabitedWithin b ts ∧ κ.FiberAtPoleWithin b ts /-- Every actual weld in the fiber carries a live self-pole index. Vacuous on empty or no-actual fibers; use `LiveSelfAptTag` when inhabitation matters. -/ def SelfAptTag (b : Macro) : Prop := ∀ w : G.Weld, G.Actual w → κ.InFiber b w → G.HasSelfPoleIndex w /-- Every actual weld in the supplied tag-class carries a live self-pole index. Vacuous unless paired with a live/inhabited hypothesis. -/ def SelfAptTagWithin (b : Macro) (ts : G.Being → Prop) : Prop := ∀ w : G.Weld, G.Actual w → κ.InFiber b w → ts w.agent → G.HasSelfPoleIndex w /-- The live, non-vacuous self-apt predicate. -/ def LiveSelfAptTag (b : Macro) : Prop := κ.ActualFiberInhabited b ∧ κ.SelfAptTag b /-- Patchy fiber: neither all actual welds are at the pole nor all actual welds are self-apt. No middling scalar is smuggled in. -/ def Patchy (b : Macro) : Prop := ¬ κ.FiberAtPole b ∧ ¬ κ.SelfAptTag b /-- If every fine tag in the fiber is terminus-typed, the whole actual fiber reads at the pole. -/ theorem fiberAtPole_of_fiber_termini {b : Macro} (h : ∀ p : G.Being, κ.proj p = b → G.Terminus p) : κ.FiberAtPole b := by intro w hactual hfiber exact G.atBot_of_terminus_response (h w.agent hfiber) hactual /-- If every fine tag in the fiber and supplied tag-class is terminus-typed, the tag-restricted actual fiber reads at the pole. -/ theorem fiberAtPoleWithin_of_class_termini {b : Macro} {ts : G.Being → Prop} (h : ∀ p : G.Being, κ.proj p = b → ts p → G.Terminus p) : κ.FiberAtPoleWithin b ts := by intro w hactual hfiber _hclass htag exact G.atBot_of_terminus_response (h w.agent hfiber htag) hactual /-- Under a fiber-at-pole reading, no actual weld in the fiber has a live self-pole index. -/ theorem no_live_index_under_fiberAtPole {b : Macro} (h : κ.FiberAtPole b) {w : G.Weld} (hactual : G.Actual w) (hfiber : κ.InFiber b w) : ¬ G.HasSelfPoleIndex w := G.no_self_pole_index_of_atBot w (h w hactual hfiber) theorem fiberAtPoleOn_mono {b : Macro} {cs ds : G.Call → Prop} (h : κ.FiberAtPoleOn b cs) (hsub : ∀ c : G.Call, ds c → cs c) : κ.FiberAtPoleOn b ds := fun w hactual hfiber hds => h w hactual hfiber (hsub w.call hds) theorem fiberAtPoleOnWithin_mono_call {b : Macro} {cs ds : G.Call → Prop} {ts : G.Being → Prop} (h : κ.FiberAtPoleOnWithin b cs ts) (hsub : ∀ c : G.Call, ds c → cs c) : κ.FiberAtPoleOnWithin b ds ts := fun w hactual hfiber hds htag => h w hactual hfiber (hsub w.call hds) htag theorem fiberAtPoleOnWithin_mono_tag {b : Macro} {cs : G.Call → Prop} {ts us : G.Being → Prop} (h : κ.FiberAtPoleOnWithin b cs ts) (hsub : ∀ p : G.Being, us p → ts p) : κ.FiberAtPoleOnWithin b cs us := fun w hactual hfiber hclass hus => h w hactual hfiber hclass (hsub w.agent hus) theorem fiberAtPoleOn_univ_iff (b : Macro) : κ.FiberAtPoleOn b (fun _ => True) ↔ κ.FiberAtPole b := by constructor · intro h w hactual hfiber exact h w hactual hfiber True.intro · intro h w hactual hfiber _hclass exact h w hactual hfiber theorem fiberAtPoleOnWithin_univTags_iff (b : Macro) (cs : G.Call → Prop) : κ.FiberAtPoleOnWithin b cs (fun _ => True) ↔ κ.FiberAtPoleOn b cs := by constructor · intro h w hactual hfiber hclass exact h w hactual hfiber hclass True.intro · intro h w hactual hfiber hclass _htag exact h w hactual hfiber hclass theorem fiberAtPoleOnWithin_univCalls_iff (b : Macro) (ts : G.Being → Prop) : κ.FiberAtPoleOnWithin b (fun _ => True) ts ↔ κ.FiberAtPoleWithin b ts := Iff.rfl theorem fiberAtPoleOnWithin_univ_univ_iff (b : Macro) : κ.FiberAtPoleOnWithin b (fun _ => True) (fun _ => True) ↔ κ.FiberAtPole b := by constructor · intro h w hactual hfiber exact h w hactual hfiber True.intro True.intro · intro h w hactual hfiber _hclass _htag exact h w hactual hfiber theorem fiberAtPoleWithin_of_fiberAtPole {b : Macro} {ts : G.Being → Prop} (h : κ.FiberAtPole b) : κ.FiberAtPoleWithin b ts := by intro w hactual hfiber _hclass _htag exact h w hactual hfiber theorem no_live_index_under_fiberAtPoleOn {b : Macro} {cs : G.Call → Prop} (h : κ.FiberAtPoleOn b cs) {w : G.Weld} (hactual : G.Actual w) (hfiber : κ.InFiber b w) (hclass : cs w.call) : ¬ G.HasSelfPoleIndex w := G.no_self_pole_index_of_atBot w (h w hactual hfiber hclass) theorem no_live_index_under_fiberAtPoleOnWithin {b : Macro} {cs : G.Call → Prop} {ts : G.Being → Prop} (h : κ.FiberAtPoleOnWithin b cs ts) {w : G.Weld} (hactual : G.Actual w) (hfiber : κ.InFiber b w) (hclass : cs w.call) (htag : ts w.agent) : ¬ G.HasSelfPoleIndex w := G.no_self_pole_index_of_atBot w (h w hactual hfiber hclass htag) /-- Fiber soul-guard: even where the self-convention is apt, the index is only the per-weld agent tag. No macro owner is produced. -/ theorem selfAptTag_indices_are_per_weld_only {b : Macro} (h : κ.SelfAptTag b) {w : G.Weld} (hactual : G.Actual w) (hfiber : κ.InFiber b w) : G.selfPoleIndex w (h w hactual hfiber) = w.agent := rfl /-- The empty-fiber vacuity guard: fiber-at-pole and self-apt are exclusive only once an actual weld in the fiber is supplied. -/ theorem fiberAtPole_selfAptTag_exclusive {b : Macro} (hinh : κ.ActualFiberInhabited b) (hpole : κ.FiberAtPole b) (hself : κ.SelfAptTag b) : False := by rcases hinh with ⟨w, hactual, hfiber⟩ exact hself w hactual hfiber (hpole w hactual hfiber) theorem liveFiberAtPole_not_selfAptTag {b : Macro} (h : κ.LiveFiberAtPole b) : ¬ κ.SelfAptTag b := fun hself => κ.fiberAtPole_selfAptTag_exclusive h.left h.right hself theorem liveFiberAtPoleWithin_not_selfAptTagWithin {b : Macro} {ts : G.Being → Prop} (h : κ.LiveFiberAtPoleWithin b ts) : ¬ κ.SelfAptTagWithin b ts := by intro hself rcases h.left with ⟨w, hactual, hfiber, htag⟩ exact hself w hactual hfiber htag (h.right w hactual hfiber True.intro htag) theorem liveSelfAptTag_not_fiberAtPole {b : Macro} (h : κ.LiveSelfAptTag b) : ¬ κ.FiberAtPole b := fun hpole => κ.fiberAtPole_selfAptTag_exclusive h.left hpole h.right /-- Internal refinement within sentience: the fiber carries at least one internal delivery line. Any persistence theorem built from this owes a model-supplied asymmetry or irreflexivity hypothesis on `conditions`. -/ def SelfConditioningTag (b : Macro) : Prop := ∃ deed reception : G.Weld, κ.InFiber b deed ∧ κ.InFiber b reception ∧ G.Actual reception ∧ DeliveredTo G deed reception /-- A stronger asymptote: every actual reception in the fiber is internally fed. It is named and shelved because treating it as the default would turn internal conditioning into causal solipsism. -/ def StrongSelfConditioningTag (b : Macro) : Prop := ∀ reception : G.Weld, κ.InFiber b reception → G.Actual reception → ∃ deed : G.Weld, κ.InFiber b deed ∧ DeliveredTo G deed reception /- Reading and motivation: Identification/Commentary.lean, C.1. -/ structure Delegation (b : Macro) where weld : G.Weld actual : G.Actual weld delegate_in_fiber : κ.InFiber b weld namespace Delegation /- Reading and motivation: Identification/Commentary.lean, C.1. -/ def share {b : Macro} (d : κ.Delegation b) : Contrib := G.share d.weld @[simp] theorem share_eq_delegate_share {b : Macro} (d : κ.Delegation b) : d.share = G.share d.weld := rfl end Delegation /-- Transpose a being-coarsening across the condition-transpose operation. Fine tags are unchanged; only delivery order reverses. -/ def transpose (κ : BeingCoarsening G Macro) : BeingCoarsening G.transpose Macro where proj := κ.proj theorem transpose_inFiber_iff (κ : BeingCoarsening G Macro) (b : Macro) (w : G.Weld) : κ.transpose.InFiber b w ↔ κ.InFiber b w := Iff.rfl theorem transpose_sentientTag_iff (κ : BeingCoarsening G Macro) (b : Macro) : κ.transpose.SentientTag b ↔ κ.SentientTag b := Iff.rfl /-- Direction-smuggling detector for the directed refinement: transposition reverses the delivery line while leaving fiber membership and actuality untouched. -/ theorem transpose_selfConditioningTag (κ : BeingCoarsening G Macro) (b : Macro) : κ.transpose.SelfConditioningTag b ↔ ∃ deed reception : G.Weld, κ.InFiber b deed ∧ κ.InFiber b reception ∧ G.Actual reception ∧ DeliveredTo G reception deed := by constructor · rintro ⟨deed, reception, hdeed, hreception, hactual, hdel⟩ exact ⟨deed, reception, hdeed, hreception, hactual, (DirectedConvention.transpose_deliveredTo_iff G deed reception).mp hdel⟩ · rintro ⟨deed, reception, hdeed, hreception, hactual, hdel⟩ exact ⟨deed, reception, hdeed, hreception, hactual, (DirectedConvention.transpose_deliveredTo_iff G deed reception).mpr hdel⟩ end BeingCoarsening /- The innermost `GridConvention` namespace is opened in the Consequences files for the concrete claim-language rows. Keeping the abstract machinery at `Grid` level for now avoids a churn-only migration of structure fields whose eventual home may simply remain signature rather than reading. -/ end BeingConvention end DirectedConvention end Grid end WAA ===== FILE: WeldAndArrow/Signature/Claims.lean ===== /- ================================================================================ WeldAndArrow.Signature.Claims Separate/fuse claim interface ================================================================================ Reading and motivation: Identification/Commentary.lean, C.1. -/ import WeldAndArrow.Signature.Grid namespace WAA /- ============================================================================== §4 The separate/fuse rule The rule is stated against a deliberately small deep interface. The object language itself is abstract: future files choose a concrete `Claim` type and a tier-indexed satisfaction relation. What Theory fixes is the shape that later work needs: distinctions are pairs of claim objects, and recorded utterances carry enough inspectable information for a taxonomy generator to ask which call was answered, at which tier the utterance was offered, and whether the content is satisfied there. ============================================================================== -/ namespace Grid variable {Contrib : Type} [PreorderBot Contrib] /- Reading and motivation: Identification/Commentary.lean, C.1. -/ inductive Tier (G : Grid Contrib) | floor | actTime (w : G.Weld) variable (G : Grid Contrib) /- Reading and motivation: Identification/Commentary.lean, C.1. -/ def Tier.hasLiveShare : Tier G → Prop | .floor => False | .actTime w => G.HasSelfPoleIndex w /-- An abstract object language of claims, together with its tier-indexed satisfaction relation. This is intentionally only an interface: later files can instantiate `Claim` with the concrete syntax their theorem or taxonomy needs, while Theory can already state the separate/fuse rule over inspectable claim-objects rather than over anonymous predicates. -/ structure ClaimLanguage (G : Grid Contrib) where Claim : Type Holds : Tier G → Claim → Prop namespace ClaimLanguage /-- The judgement form a later file can read as `⊢_t P`: claim `p` is satisfied at tier `t` in language `L`. It is still a `Prop`, but it is not merely a free-floating `Tier → Prop`; the claim being judged is an object of the chosen language. -/ def TrueAt {G : Grid Contrib} (L : ClaimLanguage G) (t : Tier G) (p : L.Claim) : Prop := L.Holds t p end ClaimLanguage /-- A recorded utterance, typed as data the taxonomy can inspect. The `weld` records who answered which call with which response; this architecturally enforces the gradeability rule's positive half, since every utterance the taxonomy inspects carries its call. `offeredAt` records the tier at which the utterance was made; `content` is a claim-object in the chosen language. The proof of `actual` keeps this type for actual recorded utterances rather than hypothetical ones. The severed case is handled in `Doctrines/Gradeability.lean`. -/ structure RecordedUtterance (G : Grid Contrib) (L : ClaimLanguage G) where weld : G.Weld actual : G.Actual weld offeredAt : Tier G content : L.Claim namespace RecordedUtterance /-- The call this utterance answers, exposed as a projection so classifiers can respect the gradeability rule without unpacking the weld by hand. -/ def answersCall {G : Grid Contrib} {L : ClaimLanguage G} (u : RecordedUtterance G L) : G.Call := u.weld.call /-- Whether the utterance's content is satisfied at the tier at which it was offered. Fox-style tier-errors are expected to fail this test; the taxonomy that classifies such failures belongs downstream. -/ def FitsOfferedTier {G : Grid Contrib} {L : ClaimLanguage G} (u : RecordedUtterance G L) : Prop := L.TrueAt u.offeredAt u.content end RecordedUtterance /-- A distinction: two claim-objects a diagnosis might hold apart. -/ structure Distinction (G : Grid Contrib) where language : ClaimLanguage G sideA : language.Claim sideB : language.Claim /- Reading and motivation: Identification/Commentary.lean, C.1. -/ def Distinction.Fused {G : Grid Contrib} (d : Distinction G) (t : Tier G) : Prop := ¬ Tier.hasLiveShare G t → (d.language.TrueAt t d.sideA ↔ d.language.TrueAt t d.sideB) /- Reading and motivation: Identification/Commentary.lean, C.1. -/ def Distinction.Collapse {G : Grid Contrib} (d : Distinction G) (t : Tier G) : Prop := Tier.hasLiveShare G t ∧ (d.language.TrueAt t d.sideA ↔ d.language.TrueAt t d.sideB) /-- Freeze: the rule's other violation — holding a distinction SEPARATE at the floor, where it should fuse. -/ def Distinction.Freeze {G : Grid Contrib} (d : Distinction G) : Prop := ¬ (d.language.TrueAt Tier.floor d.sideA ↔ d.language.TrueAt Tier.floor d.sideB) /-- Separation: at a live act-time tier, the two sides are not interchangeable. -/ def Distinction.Separated {G : Grid Contrib} (d : Distinction G) (t : Tier G) : Prop := Tier.hasLiveShare G t ∧ ¬ (d.language.TrueAt t d.sideA ↔ d.language.TrueAt t d.sideB) /- Reading and motivation: Identification/Commentary.lean, C.1. -/ def Distinction.ObeysSeparateFuse {G : Grid Contrib} (d : Distinction G) : Prop := (∀ t, Tier.hasLiveShare G t → ¬ (d.language.TrueAt t d.sideA ↔ d.language.TrueAt t d.sideB)) ∧ (∀ t, ¬ Tier.hasLiveShare G t → (d.language.TrueAt t d.sideA ↔ d.language.TrueAt t d.sideB)) /-- The two voices of the system's diagnostics. -/ inductive VerdictVoice | assertable | displayable /-- The two grades of error described in the theorem file. -/ inductive ErrorGrade | verdict | shortfall namespace ErrorGrade /-- Grade 1 verdicts are asserted inside the lens; Grade 2 verdicts are displayed without adding a value-command. -/ def voice : ErrorGrade → VerdictVoice | .verdict => .assertable | .shortfall => .displayable end ErrorGrade /-- The generator's four possible public outcomes: the two violations of a distinction, a declined classification, or a retyping that redraws the distinction itself. -/ inductive GeneratorOutcome (G : Grid Contrib) | collapse (d : Distinction G) (t : Tier G) (h : d.Collapse t) | freeze (d : Distinction G) (h : d.Freeze) | declined | retype (oldDistinction newDistinction : Distinction G) theorem not_collapse_of_obeysSeparateFuse {G : Grid Contrib} {d : Distinction G} (h : d.ObeysSeparateFuse) (t : Tier G) : ¬ d.Collapse t := fun hc => (h.left t hc.left) hc.right theorem not_freeze_of_obeysSeparateFuse {G : Grid Contrib} {d : Distinction G} (h : d.ObeysSeparateFuse) : ¬ d.Freeze := fun hf => hf (h.right Tier.floor (fun hfloor => hfloor)) /- Reading and motivation: Identification/Commentary.lean, C.1. -/ theorem not_freeze_of_same_claim (L : ClaimLanguage G) (p : L.Claim) : ¬ ({ language := L, sideA := p, sideB := p } : Distinction G).Freeze := fun h => h Iff.rfl end Grid namespace Grid namespace DirectedConvention namespace BeingConvention namespace GridConvention variable {Contrib : Type} [PreorderBot Contrib] /- The abstract separate/fuse machinery remains defined at `Grid` level for compatibility; these aliases expose its innermost reading-home. -/ abbrev Tier (G : Grid Contrib) := Grid.Tier G abbrev ClaimLanguage (G : Grid Contrib) := Grid.ClaimLanguage G abbrev RecordedUtterance (G : Grid Contrib) (L : Grid.ClaimLanguage G) := Grid.RecordedUtterance G L abbrev Distinction (G : Grid Contrib) := Grid.Distinction G abbrev VerdictVoice := Grid.VerdictVoice abbrev ErrorGrade := Grid.ErrorGrade abbrev GeneratorOutcome (G : Grid Contrib) := Grid.GeneratorOutcome G end GridConvention end BeingConvention end DirectedConvention end Grid end WAA ===== FILE: WeldAndArrow/Signature/DirectionConvention.lean ===== /- ================================================================================ WeldAndArrow.Signature.DirectionConvention Direction-coarsening vocabulary over the delivery axis ================================================================================ Reading and motivation: Identification/Commentary.lean, C.1. -/ import WeldAndArrow.Signature.Grid namespace WAA namespace Grid namespace DirectedConvention variable {Contrib : Type} [PreorderBot Contrib] /- Reading and motivation: Identification/Commentary.lean, C.1. -/ /-- A diagnosis-time projection on the delivery axis. Finite clock speed is represented by the supplied tick carrier; the projection is not a field of `Grid`. -/ structure DirectionCoarsening (G : Grid Contrib) (Tick : Type) where tick : G.Weld -> Tick namespace DirectionCoarsening variable {G : Grid Contrib} {Tick : Type} (ρ : DirectionCoarsening G Tick) /- Reading and motivation: Identification/Commentary.lean, C.1. -/ /-- Two welds lie inside the same clock tick. This is direction-neutral. -/ def SameTick (w₁ w₂ : G.Weld) : Prop := ρ.tick w₁ = ρ.tick w₂ theorem sameTick_symm {w₁ w₂ : G.Weld} (h : ρ.SameTick w₁ w₂) : ρ.SameTick w₂ w₁ := h.symm /- Reading and motivation: Identification/Commentary.lean, C.1. -/ /-- Delivery the clock can resolve. -/ def ResolvedDelivery (deed reception : G.Weld) : Prop := DeliveredTo G deed reception ∧ ρ.tick deed ≠ ρ.tick reception /- Reading and motivation: Identification/Commentary.lean, C.1. -/ /-- Delivery below resolution: the coarse-direction residue. -/ def SubTickDelivery (deed reception : G.Weld) : Prop := DeliveredTo G deed reception ∧ ρ.SameTick deed reception /- Reading and motivation: Identification/Commentary.lean, C.1. -/ /-- A model-supplied coherence condition for the display. It is not a legitimacy, pole, or typing condition. -/ def ResolutionBounded : Prop := ∀ w₁ w₂ : G.Weld, ρ.SameTick w₁ w₂ -> OrderEq (G.share w₁) (G.share w₂) /-- Sub-tick delivery carries no strict share-direction. -/ theorem no_timeDirection_within_tick (h : ρ.ResolutionBounded) {deed reception : G.Weld} (hsub : ρ.SubTickDelivery deed reception) : ¬ TimeDirection (G.share deed) (G.share reception) := not_strict_of_orderEq (h deed reception hsub.right) /-- Weld-restricted fully coarse limit: one tick gives no directed share-pair among welds. -/ theorem no_timeDirection_of_resolutionBounded_subsingleton (h : ρ.ResolutionBounded) (hone : ∀ w₁ w₂ : G.Weld, ρ.SameTick w₁ w₂) (w₁ w₂ : G.Weld) : ¬ TimeDirection (G.share w₁) (G.share w₂) := not_strict_of_orderEq (h w₁ w₂ (hone w₁ w₂)) /-- Transpose a direction-coarsening across the condition-transpose operation. Ticks are unchanged; only delivery order reverses. -/ def transpose (ρ : DirectionCoarsening G Tick) : DirectionCoarsening G.transpose Tick where tick := ρ.tick theorem transpose_sameTick_iff (b₁ b₂ : G.Weld) : ρ.transpose.SameTick b₁ b₂ ↔ ρ.SameTick b₁ b₂ := Iff.rfl theorem transpose_resolutionBounded_iff : ρ.transpose.ResolutionBounded ↔ ρ.ResolutionBounded := Iff.rfl /-- Direction-smuggling detector for sub-tick delivery: transposition reverses the delivery line while leaving tick equality untouched. -/ theorem transpose_subTickDelivery (deed reception : G.Weld) : ρ.transpose.SubTickDelivery deed reception ↔ DeliveredTo G reception deed ∧ ρ.SameTick deed reception := by constructor · intro h exact ⟨(transpose_deliveredTo_iff G deed reception).mp h.left, h.right⟩ · intro h exact ⟨(transpose_deliveredTo_iff G deed reception).mpr h.left, h.right⟩ end DirectionCoarsening end DirectedConvention end Grid end WAA ===== FILE: WeldAndArrow/Signature/Grid.lean ===== /- ================================================================================ WeldAndArrow.Signature.Grid Primitive grid signature and directed-convention primitives ================================================================================ Reading and motivation: Identification/Commentary.lean, C.1. -/ import WeldAndArrow.Signature.Order namespace WAA /- Reading and motivation: Identification/Commentary.lean, C.1. -/ @[ext] structure RawWeld (Being Call Response : Type) where agent : Being call : Call response : Response namespace RawWeld /-- Swap the call and response faces of a weld when they use the same carrier. This changes no signature fields; it is a display-side involution for checking whether an interior call→response arrow has been smuggled in. -/ def transposeCR {Being CR : Type} (w : RawWeld Being CR CR) : RawWeld Being CR CR := ⟨w.agent, w.response, w.call⟩ @[simp] theorem transposeCR_agent {Being CR : Type} (w : RawWeld Being CR CR) : w.transposeCR.agent = w.agent := rfl @[simp] theorem transposeCR_call {Being CR : Type} (w : RawWeld Being CR CR) : w.transposeCR.call = w.response := rfl @[simp] theorem transposeCR_response {Being CR : Type} (w : RawWeld Being CR CR) : w.transposeCR.response = w.call := rfl @[simp] theorem transposeCR_transposeCR {Being CR : Type} (w : RawWeld Being CR CR) : w.transposeCR.transposeCR = w := rfl end RawWeld /-- The whole signature, bundled. -/ structure Grid (Contrib : Type) [PreorderBot Contrib] where /- Reading and motivation: Identification/Commentary.lean, C.1. -/ Being : Type /-- The input component of an occurrence. -/ Call : Type /-- what a mounted response produces. -/ Response : Type /- Reading and motivation: Identification/Commentary.lean, C.1. -/ respondsTo : Being → Call → Option Response /-- The contribution value assigned to a mounted response. -/ grade : Being → Call → Response → Contrib /- Reading and motivation: Identification/Commentary.lean, C.1. -/ conditions : RawWeld Being Call Response → RawWeld Being Call Response → Prop namespace Grid variable {Contrib : Type} [PreorderBot Contrib] /-- Shorthand: an occurrence for a specific `Grid`. -/ abbrev Weld (G : Grid Contrib) := RawWeld G.Being G.Call G.Response variable (G : Grid Contrib) /-- A weld is *actual* when it witnesses something the being in fact does. Self-anchoring is enforced structurally, not by a fancier dependent index type: nothing in this file ever produces a `Being` "as an index" except by first supplying a `Weld` whose `response` is witnessed here. There is no route from `Config` (§2) or from field-facts alone to an `Actual` weld — see `no_agent_recovery_of_field_collision` in the Preview section for the internal version of that claim. -/ def Actual (w : G.Weld) : Prop := G.respondsTo w.agent w.call = some w.response /-- The agent-index — token-reflexive because it is nothing but a projection out of the very weld that carries it: there is no route to "this act's agent" that does not pass through a completed `Weld`. -/ def index (w : G.Weld) : G.Being := w.agent /- Reading and motivation: Identification/Commentary.lean, C.1. -/ def share (w : G.Weld) : Contrib := G.grade w.agent w.call w.response /-- Whether this occurrence makes a live self-pole index. The raw `index` projection above is still useful as the causal-series tag of a weld; this predicate is the theorem-facing notion that disappears at the pole-class. -/ def HasSelfPoleIndex (w : G.Weld) : Prop := ¬ AtBot (G.share w) /- Reading and motivation: Identification/Commentary.lean, C.1. -/ def selfPoleIndex (w : G.Weld) (_h : G.HasSelfPoleIndex w) : G.Being := w.agent /-- A live self-pole index gives a strict contribution witness above the designated bottom. -/ theorem strict_shareBot_of_hasSelfPoleIndex (w : G.Weld) (h : G.HasSelfPoleIndex w) : Strict (shareBot : Contrib) (G.share w) := ⟨shareBot_le (G.share w), h⟩ /- Reading and motivation: Identification/Commentary.lean, C.1. -/ def WaaAppropriates (reception : G.Weld) : Prop := G.HasSelfPoleIndex reception /-- At the pole-class, no self-pole index is live. -/ theorem no_self_pole_index_of_atBot (w : G.Weld) (h : AtBot (G.share w)) : ¬ G.HasSelfPoleIndex w := fun hidx => hidx h /-- Literal equality with the designated bottom is a thin bridge into the order-class pole vocabulary. -/ theorem no_self_pole_index_of_eq_shareBot (w : G.Weld) (h : G.share w = shareBot) : ¬ G.HasSelfPoleIndex w := G.no_self_pole_index_of_atBot w (atBot_of_eq_shareBot h) /-- The evidence-carried index is the agent tag when the self-pole is live. -/ theorem selfPoleIndex_eq_agent_of_hasSelfPoleIndex (w : G.Weld) (h : G.HasSelfPoleIndex w) : G.selfPoleIndex w h = w.agent := rfl /-- At the pole-class there is no WAA-appropriation. -/ theorem not_waaAppropriates_of_atBot (w : G.Weld) (h : AtBot (G.share w)) : ¬ G.WaaAppropriates w := G.no_self_pole_index_of_atBot w h /-- Literal equality with the designated bottom rules out WAA-appropriation by first entering the pole-class. -/ theorem not_waaAppropriates_of_eq_shareBot (w : G.Weld) (h : G.share w = shareBot) : ¬ G.WaaAppropriates w := G.not_waaAppropriates_of_atBot w (atBot_of_eq_shareBot h) /- Reading and motivation: Identification/Commentary.lean, C.1. -/ theorem share_eq_grade_check (w : G.Weld) : G.share w = G.grade w.agent w.call w.response := rfl /- Reading and motivation: Identification/Commentary.lean, C.1. -/ def ProbeConstant (b : G.Being) (cs : G.Call → Prop) : Prop := ∀ c₁ c₂, cs c₁ → cs c₂ → ∀ r₁ r₂, G.respondsTo b c₁ = some r₁ → G.respondsTo b c₂ = some r₂ → OrderEq (G.grade b c₁ r₁) (G.grade b c₂ r₂) /- Reading and motivation: Identification/Commentary.lean, C.1. -/ /-- Mounting a response at all — the subject-function. Phrased with an existential rather than `Option.isSome` so this stays `Prop`-valued without leaning on the `Bool → Prop` coercion. -/ def MountsAt (b : G.Being) (c : G.Call) : Prop := ∃ r, G.respondsTo b c = some r /-- A being that mounts some response somewhere. This is the weakest positive-function predicate, useful for separating a live responder from a stone without requiring total response to every call. -/ def MountsSomewhere (b : G.Being) : Prop := ∃ c, G.MountsAt b c /-- Function-entire in the formal sense: every call in the model receives some response. Downstream files can weaken this to a regime-indexed version when modelling deaf-blind limits or partial delivery. -/ def RespondsToEveryCall (b : G.Being) : Prop := ∀ c, G.MountsAt b c /- Reading and motivation: Identification/Commentary.lean, C.1. -/ def Stone (b : G.Being) : Prop := ∀ c, ¬ G.MountsAt b c /- Reading and motivation: Identification/Commentary.lean, C.1. -/ def AllStone : Prop := ∀ b : G.Being, G.Stone b /- Reading and motivation: Identification/Commentary.lean, C.1. -/ def Terminus (b : G.Being) : Prop := ∀ c r, G.respondsTo b c = some r → AtBot (G.grade b c r) /-- The non-vacuous terminus: function is present somewhere and every mounted response is at the pole-class. This is often the right formal analogue of the "responsive stone" when the model's call-domain is intentionally sparse. -/ def LiveTerminus (b : G.Being) : Prop := G.MountsSomewhere b ∧ G.Terminus b /- Reading and motivation: Identification/Commentary.lean, C.1. -/ def ResponsiveTerminus (b : G.Being) : Prop := G.RespondsToEveryCall b ∧ G.Terminus b /-- A response by a terminus-typed being lies in the pole-class. -/ theorem atBot_of_terminus_response {b : G.Being} {c : G.Call} {r : G.Response} (hterm : G.Terminus b) (hresp : G.respondsTo b c = some r) : AtBot (G.share ⟨b, c, r⟩) := hterm c r hresp /-- A terminus response carries no self-pole index. -/ theorem no_self_pole_index_of_terminus_response {b : G.Being} {c : G.Call} {r : G.Response} (hterm : G.Terminus b) (hresp : G.respondsTo b c = some r) : ¬ G.HasSelfPoleIndex ⟨b, c, r⟩ := G.no_self_pole_index_of_atBot ⟨b, c, r⟩ (G.atBot_of_terminus_response hterm hresp) /-- A terminus response does not WAA-appropriate. -/ theorem not_waaAppropriates_of_terminus_response {b : G.Being} {c : G.Call} {r : G.Response} (hterm : G.Terminus b) (hresp : G.respondsTo b c = some r) : ¬ G.WaaAppropriates ⟨b, c, r⟩ := G.not_waaAppropriates_of_atBot ⟨b, c, r⟩ (G.atBot_of_terminus_response hterm hresp) /- Reading and motivation: Identification/Commentary.lean, C.1. -/ def AtPoleClass (b : G.Being) : Prop := G.Stone b ∨ G.Terminus b /- Reading and motivation: Identification/Commentary.lean, C.1. -/ theorem stone_is_terminus_vacuously (b : G.Being) (h : G.Stone b) : G.Terminus b := fun c r hr => absurd ⟨r, hr⟩ (h c) /-- Positive function at even one call rules out stone-typing. -/ theorem not_stone_of_mountsSomewhere (b : G.Being) (h : G.MountsSomewhere b) : ¬ G.Stone b := fun hs => h.elim (fun c hc => hs c hc) /-- A live terminus is not a stone. -/ theorem liveTerminus_not_stone (b : G.Being) (h : G.LiveTerminus b) : ¬ G.Stone b := G.not_stone_of_mountsSomewhere b h.left /-- A responsive terminus is live whenever the call-domain has a witness. -/ theorem responsiveTerminus_live_of_call (b : G.Being) (c : G.Call) (h : G.ResponsiveTerminus b) : G.LiveTerminus b := ⟨⟨c, h.left c⟩, h.right⟩ end Grid /- Reading and motivation: Identification/Commentary.lean, C.1. -/ /-- A carried contribution tendency. It stores no weld or being component. -/ @[ext] structure Config (Contrib : Type) where tendency : Contrib namespace Grid variable {Contrib : Type} [PreorderBot Contrib] (G : Grid Contrib) /- Reading and motivation: Identification/Commentary.lean, C.1. -/ def rePitch (_before : Config Contrib) (received : G.Weld) : Config Contrib := { tendency := G.share received } /- Reading and motivation: Identification/Commentary.lean, C.1. -/ def IsShareDrop (before : Config Contrib) (received : G.Weld) : Prop := Strict (G.share received) before.tendency /- -------------------------------------------------------------------------- Delivery structure and symmetric closure -------------------------------------------------------------------------- -/ /- Reading and motivation: Identification/Commentary.lean, C.1. -/ def ConditionsEither (w₁ w₂ : G.Weld) : Prop := G.conditions w₁ w₂ ∨ G.conditions w₂ w₁ /-- Symmetry, definitional to the closure. -/ theorem conditionsEither_symm {w₁ w₂ : G.Weld} (h : G.ConditionsEither w₁ w₂) : G.ConditionsEither w₂ w₁ := h.elim Or.inr Or.inl /-- Reflexive-transitive closure of `ConditionsEither`. -/ inductive ConditionsEitherChain : G.Weld → G.Weld → Prop | refl (w : G.Weld) : ConditionsEitherChain w w | step {w₁ w₂ w₃ : G.Weld} : G.ConditionsEither w₁ w₂ → ConditionsEitherChain w₂ w₃ → ConditionsEitherChain w₁ w₃ /- -------------------------------------------------------------------------- Direction-smuggling detector: reverse only `conditions` -------------------------------------------------------------------------- -/ /-- Reverse the argument order of `conditions`, leaving every other part of the grid untouched. Direction-neutral facts should transport across this; delivery-facing facts should either reverse or declare the model-side asymmetry hypothesis they need. -/ def transpose (G : Grid Contrib) : Grid Contrib where Being := G.Being Call := G.Call Response := G.Response respondsTo := G.respondsTo grade := G.grade conditions := fun w₁ w₂ => G.conditions w₂ w₁ theorem transpose_conditions (w₁ w₂ : G.Weld) : G.transpose.conditions w₁ w₂ = G.conditions w₂ w₁ := rfl theorem transpose_transpose : G.transpose.transpose = G := rfl theorem transpose_conditionsEither_iff (w₁ w₂ : G.Weld) : G.transpose.ConditionsEither w₁ w₂ ↔ G.ConditionsEither w₁ w₂ := ⟨fun h => h.elim Or.inr Or.inl, fun h => h.elim Or.inr Or.inl⟩ namespace DirectedConvention /-- The strictness relation, exposed under the name used by this namespace. -/ abbrev TimeDirection {α : Type} [Preorder α] (a b : α) : Prop := Strict a b /-- Re-rooted arrow reading of the neutral bottom-to-live-share witness. -/ theorem timeDirection_of_hasSelfPoleIndex (w : G.Weld) (h : G.HasSelfPoleIndex w) : TimeDirection (shareBot : Contrib) (G.share w) := G.strict_shareBot_of_hasSelfPoleIndex w h /- Reading and motivation: Identification/Commentary.lean, C.1. -/ /- -------------------------------------------------------------------------- The reception-weld: reach-back -------------------------------------------------------------------------- -/ /- Reading and motivation: Identification/Commentary.lean, C.1. -/ def WaaReachBackFull (deed reception : G.Weld) : Prop := G.conditions deed reception /- Reading and motivation: Identification/Commentary.lean, C.1. -/ /-- A delivery-line from one occurrence to another, stated in field vocabulary. This is definitionally the same relation as `WaaReachBackFull`; the different name is for theorem statements where the field-side role matters more than the reception-side appropriation. -/ def DeliveredTo (deed reception : G.Weld) : Prop := G.conditions deed reception /-- A delivery-line whose deed and reception carry the same agent tag. This is only a fact about the supplied delivery relation and weld fields; see `Identification/Commentary.lean`, C.9. -/ def SameAgentDelivery (deed reception : G.Weld) : Prop := DeliveredTo G deed reception ∧ deed.agent = reception.agent /-- A delivery-line whose deed and reception carry different agent tags. This is only a fact about the supplied delivery relation and weld fields; see `Identification/Commentary.lean`, C.9. -/ def CrossAgentDelivery (deed reception : G.Weld) : Prop := DeliveredTo G deed reception ∧ deed.agent ≠ reception.agent theorem transpose_deliveredTo_iff (deed reception : G.Weld) : DeliveredTo G.transpose deed reception ↔ DeliveredTo G reception deed := Iff.rfl /-- Non-delivery: the relation does not hold from this deed to this reception. -/ def NotDeliveredTo (deed reception : G.Weld) : Prop := ¬ G.conditions deed reception /-- When a concrete model gives a decision procedure for delivery, delivery or non-delivery is exhaustive. Abstractly, the theory keeps only the predicates: asserting this disjunction for every proposition would be excluded middle. -/ theorem deliveredTo_or_not (deed reception : G.Weld) [hdec : Decidable (G.conditions deed reception)] : DeliveredTo G deed reception ∨ NotDeliveredTo G deed reception := match hdec with | isTrue h => Or.inl h | isFalse h => Or.inr h /-- A fruit has landed when delivery reaches an actual reception. -/ def LandsAt (deed reception : G.Weld) : Prop := DeliveredTo G deed reception ∧ G.Actual reception /-- Object-axis standing: the occurrence is available to be received somewhere. No self-pole index is implied for the occurrence pointed at. -/ def ObjectAxisStanding (deed : G.Weld) : Prop := ∃ reception, DeliveredTo G deed reception /- Reading and motivation: Identification/Commentary.lean, C.1. -/ def LandsWithShareDrop (before : Config Contrib) (deed reception : G.Weld) : Prop := LandsAt G deed reception ∧ G.IsShareDrop before reception /- Reading and motivation: Identification/Commentary.lean, C.1. -/ def HasShareDropLanding (before : Config Contrib) (deed : G.Weld) : Prop := ∃ reception, LandsWithShareDrop G before deed reception /- Reading and motivation: Identification/Commentary.lean, C.1. -/ /-- A standing line of the web incident on a being: an actual deed that the field delivers to one of the being's candidate receptions. The reception need NOT be actual — the lens reads over the family of receptions the being might make (the same hypothetical variation `RawWeld` is closed under for the probe). Field-side and tenseless: a relational fact of the web, never a potency carried by the being. -/ def EnvironsLine (b : G.Being) (deed reception : G.Weld) : Prop := G.Actual deed ∧ reception.agent = b ∧ G.conditions deed reception /- Reading and motivation: Identification/Commentary.lean, C.1. -/ def ShareDropLine (before : Config Contrib) (b : G.Being) (deed reception : G.Weld) : Prop := EnvironsLine G b deed reception ∧ G.IsShareDrop before reception end DirectedConvention /-- A fixed/static responder gives the same response whenever it responds. This is only the response-shape; a clock that never responds to the listener at all is still handled by `Stone`. -/ def ResponseInvariant (b : G.Being) : Prop := ∀ c₁ c₂ r₁ r₂, G.respondsTo b c₁ = some r₁ → G.respondsTo b c₂ = some r₂ → r₁ = r₂ /-- A minimal adaptivity witness: two calls receive different responses from the same being. This is deliberately weak and extensional. -/ def ResponseVariesWithCall (b : G.Being) : Prop := ∃ c₁ c₂ r₁ r₂, G.respondsTo b c₁ = some r₁ ∧ G.respondsTo b c₂ = some r₂ ∧ r₁ ≠ r₂ namespace DirectedConvention /-- Sowing-side aiming, in the thin extensional sense the glossary licenses: the deed counts as aimed at this landing exactly when the field in fact delivers it there. No intention-primitive is introduced; stronger causal or intentional stories belong in downstream models. -/ def WaaAimedAt (deed reception : G.Weld) : Prop := DeliveredTo G deed reception theorem deliveredTo_iff_waaReachBackFull (deed reception : G.Weld) : DeliveredTo G deed reception ↔ WaaReachBackFull G deed reception := Iff.rfl theorem objectAxisStanding_of_landsAt (deed reception : G.Weld) (h : LandsAt G deed reception) : ObjectAxisStanding G deed := ⟨reception, h.left⟩ theorem objectAxisStanding_of_hasShareDropLanding (before : Config Contrib) (deed : G.Weld) (h : HasShareDropLanding G before deed) : ObjectAxisStanding G deed := h.elim (fun reception hland => ⟨reception, hland.left.left⟩) end DirectedConvention /-- An actual weld packaged with its actuality proof. This is the small carrier downstream files need when they reason about remembered deeds, future receptions, or paired receptions without repeatedly passing the same `Actual` hypotheses around by hand. -/ structure ActualWeld (G : Grid Contrib) where weld : G.Weld actual : G.Actual weld /- Reading and motivation: Identification/Commentary.lean, C.1. -/ structure ReceptionPair (G : Grid Contrib) where first : ActualWeld G second : ActualWeld G namespace ReceptionPair /-- Reach-back from the first reception in the pair to the second, phrased through the existing delivery relation. Whether this is the relation a downstream prudence theorem needs is a theorem-level choice; the carrier merely makes the relevant actual pair available. -/ def FirstConditionsSecond {G : Grid Contrib} (p : ReceptionPair G) : Prop := DirectedConvention.WaaReachBackFull G p.first.weld p.second.weld /-- The pair's sequential re-pitched configurations, exposed for future two-step arguments. No ordering or privilege between them is asserted here. -/ def rePitchSequence {G : Grid Contrib} (before : Config Contrib) (p : ReceptionPair G) : Config Contrib × Config Contrib := let afterFirst := G.rePitch before p.first.weld (afterFirst, G.rePitch afterFirst p.second.weld) end ReceptionPair end Grid /- ============================================================================== Preview: the two outside wrinkles Neither item below is Theory content proper — both anticipate later proof/theorem files and provide checked witnesses that the definitions above actually support what those files will need. Nothing above this point depends on anything below it. ============================================================================== -/ section Preview variable {Contrib : Type} [PreorderBot Contrib] (G : Grid Contrib) /- -------------------------------------------------------------------------- Wrinkle 1 — field residue under-determines the agent: internal version Outside note this responds to: "Non-typeability is demonstrated by failed elaboration, not proved. The internal alternative is to model a universe of designations and prove ¬∃ f : FieldFact → Index ... under your assumptions." The internal route is used here, with the modest scope made explicit. -------------------------------------------------------------------------- -/ /-- The field-side residue of a weld: everything left once the agent is not part of the data. The honest field-fact for recovering an index is `Call × Response`, never `Being`. -/ def Grid.fieldOf (w : G.Weld) : G.Call × G.Response := (w.call, w.response) /-- Naively, "no function `Call × Response → Being` exists" is false whenever `Being` is nonempty: a constant function typechecks. What matters is the correctness-carrying version, a function claimed to recover, for every actual weld, the agent that in fact produced its field residue. The theorem below therefore has the honest scope of the claim: no such recovery can be correct when two different beings can actually produce the same response to the same call. It is not a blanket claim about every `Grid`; it is the internal witness that field residues under-determine who acted. -/ theorem no_agent_recovery_of_field_collision (a₁ a₂ : G.Being) (c : G.Call) (r : G.Response) (h1 : G.Actual ⟨a₁, c, r⟩) (h2 : G.Actual ⟨a₂, c, r⟩) (hne : a₁ ≠ a₂) : ¬ ∃ recover : G.Call × G.Response → G.Being, ∀ w : G.Weld, G.Actual w → recover (G.fieldOf w) = G.index w := fun hex => hne (hex.elim (fun _recover hrec => (hrec ⟨a₁, c, r⟩ h1).symm.trans (hrec ⟨a₂, c, r⟩ h2))) end Preview end WAA ===== FILE: WeldAndArrow/Signature/Models.lean ===== /- ================================================================================ WeldAndArrow.Signature.Models Concrete signature-level grids used as witnesses ================================================================================ Reading and motivation: Identification/Commentary.lean, C.1. -/ import WeldAndArrow.Signature.BeingConvention namespace WAA section Preview /- Reading and motivation: Identification/Commentary.lean, C.1. -/ /-- Two devices, differing only in whether their chime is a function of who is listening. -/ inductive Clock | rigid | adaptive /-- The one call in play: whether a listener is actually present to hear the chime. -/ inductive Listener | present | absent /-- The chime itself; its content is immaterial, only whether it occurs and what drove it matters. -/ inductive Chime | chime instance : PreorderBot Nat where le := Nat.le le_refl := Nat.le_refl le_trans := fun h1 h2 => Nat.le_trans h1 h2 bot := 0 bot_le := Nat.zero_le /- Reading and motivation: Identification/Commentary.lean, C.1. -/ def clockGrid : Grid Nat where Being := Clock Call := Listener Response := Chime respondsTo b c := match b, c with | .rigid, _ => none | .adaptive, .present => some .chime | .adaptive, .absent => none grade _ _ _ := 0 conditions _ _ := False theorem rigid_is_stone : clockGrid.Stone Clock.rigid := fun _c ⟨_r, hr⟩ => by cases hr theorem adaptive_is_terminus : clockGrid.Terminus Clock.adaptive := fun _c _r _h => Nat.le_refl 0 theorem adaptive_not_stone : ¬ clockGrid.Stone Clock.adaptive := fun h => h Listener.present ⟨Chime.chime, rfl⟩ /- Reading and motivation: Identification/Commentary.lean, C.1. -/ theorem clockGrid_function_share_split_witness : clockGrid.Stone Clock.rigid ∧ clockGrid.Terminus Clock.adaptive ∧ ¬ clockGrid.Stone Clock.adaptive := ⟨rigid_is_stone, adaptive_is_terminus, adaptive_not_stone⟩ /- -------------------------------------------------------------------------- Second concrete display — integer registers with diagnosis-time κ The adaptive register clock builds its fine tags as integer-like registers. The macro designation is still supplied outside the signature, by a `BeingCoarsening`: the model may implement stable internal registers, but the standing partition is not stored as "the" being-boundary. -------------------------------------------------------------------------- -/ /-- A register clock whose fine tags are natural-numbered registers. Each register answers the tick by handing off to the next register, and delivery follows that hand-off. -/ def registerClockGrid : Grid Nat where Being := Nat Call := Unit Response := Nat respondsTo n _ := some (n + 1) grade n _ _ := n conditions deed reception := reception.agent = deed.response /-- A macro coarsening that sends all fine registers to one macro tag. -/ def registerClockCoarsening : Grid.DirectedConvention.BeingConvention.BeingCoarsening registerClockGrid Unit where proj _ := () theorem registerClock_macro_sentient : registerClockCoarsening.SentientTag () := ⟨(0 : Nat), rfl, ⟨(), ⟨(1 : Nat), rfl⟩⟩⟩ theorem registerClock_macro_selfConditioning : registerClockCoarsening.SelfConditioningTag () := by refine ⟨⟨(0 : Nat), (), (1 : Nat)⟩, ⟨(1 : Nat), (), (2 : Nat)⟩, rfl, rfl, rfl, ?_⟩ rfl /- -------------------------------------------------------------------------- Third concrete display — backsliding in one grid A single being answers both calls. The gentle call drops to the pole-class; the harsh call later carries live share again. Nothing in the grid stores the prior drop as an attainment. -------------------------------------------------------------------------- -/ inductive Cue | gentle | harsh def backslideGrid : Grid Nat where Being := Unit Call := Cue Response := Unit respondsTo _ _ := some () grade _ c _ := match c with | .gentle => 0 | .harsh => 5 conditions _ _ := True /- -------------------------------------------------------------------------- Fourth concrete display — grading is weld-side, not field-residue side The two actual welds share the same call-response residue while receiving different shares. The event residue alone therefore cannot carry the grade. -------------------------------------------------------------------------- -/ inductive GradingCollisionBeing | left | right def gradingCollisionGrid : Grid Nat where Being := GradingCollisionBeing Call := Unit Response := Unit respondsTo _ _ := some () grade b _ _ := match b with | .left => 5 | .right => 0 conditions _ _ := True def gradingCollisionLeft : gradingCollisionGrid.Weld := ⟨GradingCollisionBeing.left, (), ()⟩ def gradingCollisionRight : gradingCollisionGrid.Weld := ⟨GradingCollisionBeing.right, (), ()⟩ /- `clockGrid` is a genuine, finite, computable term of type `Grid Nat` — direct evidence that "a model of the theory" is a buildable Lean object, and that facts about a concrete instance are provable at `rfl`-level once the instance is fixed. The prudential-privilege construction this scaffolding anticipated is carried out in `Identification/Ownership.lean`, under `Grid.DirectedConvention.PrudentialPrivilegeNegative`: an actual `ReceptionPair`, the relevant `Config`/`rePitch` steps, and a named `PrudentialPrivilege` recovery proposition are fixed there and the proposition is shown to fail. This section checks only that the model scaffolding does not get in the way. -/ end Preview end WAA ===== FILE: WeldAndArrow/Signature/Order.lean ===== /- ================================================================================ WeldAndArrow.Signature.Order Dependency-free preorder infrastructure ================================================================================ Reading and motivation: Identification/Commentary.lean, C.1. -/ namespace WAA /- ============================================================================== §0 Dependency-free preorder infrastructure ============================================================================== -/ /-- A bare preorder, rolled by hand and not assumed total or antisymmetric. -/ class Preorder (α : Type) where /-- The display-order relation: `a ≼ b` means `a` is no more self-driven than `b` in the ordinal Row-2 sense. -/ le : α → α → Prop le_refl : ∀ a, le a a le_trans : ∀ {a b c : α}, le a b → le b c → le a c @[inherit_doc] infix:50 " ≼ " => Preorder.le instance instTransPreorderLe [Preorder α] : Trans (fun a b : α => a ≼ b) (fun a b : α => a ≼ b) (fun a b : α => a ≼ b) where trans := fun h₁ h₂ => Preorder.le_trans h₁ h₂ /- Reading and motivation: Identification/Commentary.lean, C.1. -/ def Incomparable [Preorder α] (a b : α) : Prop := ¬ a ≼ b ∧ ¬ b ≼ a /-- Order-equivalence: neither more nor less self-driven. -/ def OrderEq [Preorder α] (a b : α) : Prop := a ≼ b ∧ b ≼ a /-- Strict comparability in a preorder: `a` is below `b`, with no return comparison. -/ def Strict [Preorder α] (a b : α) : Prop := a ≼ b ∧ ¬ b ≼ a theorem orderEq_refl [Preorder α] (a : α) : OrderEq a a := ⟨Preorder.le_refl a, Preorder.le_refl a⟩ theorem orderEq_symm [Preorder α] {a b : α} (h : OrderEq a b) : OrderEq b a := ⟨h.right, h.left⟩ theorem orderEq_trans [Preorder α] {a b c : α} (hab : OrderEq a b) (hbc : OrderEq b c) : OrderEq a c := ⟨Preorder.le_trans hab.left hbc.left, Preorder.le_trans hbc.right hab.right⟩ theorem strict_irrefl [Preorder α] (a : α) : ¬ Strict a a := fun h => h.right h.left theorem strict_asymm [Preorder α] {a b : α} (h : Strict a b) : ¬ Strict b a := fun hba => h.right hba.left theorem strict_trans [Preorder α] {a b c : α} (hab : Strict a b) (hbc : Strict b c) : Strict a c := ⟨Preorder.le_trans hab.left hbc.left, fun hca => hab.right (Preorder.le_trans hbc.left hca)⟩ theorem strict_of_le_of_strict [Preorder α] {a b c : α} (hab : a ≼ b) (hbc : Strict b c) : Strict a c := ⟨Preorder.le_trans hab hbc.left, fun hca => hbc.right (Preorder.le_trans hca hab)⟩ theorem strict_of_strict_of_le [Preorder α] {a b c : α} (hab : Strict a b) (hbc : b ≼ c) : Strict a c := ⟨Preorder.le_trans hab.left hbc, fun hca => hab.right (Preorder.le_trans hbc hca)⟩ theorem not_strict_of_orderEq [Preorder α] {a b : α} (h : OrderEq a b) : ¬ Strict a b := fun hs => hs.right h.right theorem no_strict_of_all_orderEq [Preorder α] (h : ∀ a b : α, OrderEq a b) (a b : α) : ¬ Strict a b := not_strict_of_orderEq (h a b) /- Reading and motivation: Identification/Commentary.lean, C.1. -/ def DirectionVoid (α : Type) [Preorder α] : Prop := ∀ a b : α, ¬ Strict a b /- Reading and motivation: Identification/Commentary.lean, C.1. -/ class PreorderBot (α : Type) extends Preorder α where bot : α bot_le : ∀ a, le bot a /-- Shorthand for the bottom of whatever `Contrib` is in scope. -/ def shareBot [PreorderBot α] : α := PreorderBot.bot /-- The designated bottom is below every display value. -/ theorem shareBot_le [PreorderBot α] (a : α) : (shareBot : α) ≼ a := PreorderBot.bot_le a /- Reading and motivation: Identification/Commentary.lean, C.1. -/ def AtBot [PreorderBot α] (a : α) : Prop := a ≼ shareBot theorem atBot_shareBot [PreorderBot α] : AtBot (shareBot : α) := Preorder.le_refl shareBot theorem atBot_of_eq_shareBot [PreorderBot α] {a : α} (h : a = shareBot) : AtBot a := h ▸ atBot_shareBot theorem orderEq_shareBot_of_atBot [PreorderBot α] {a : α} (h : AtBot a) : OrderEq a shareBot := ⟨h, shareBot_le a⟩ theorem atBot_of_orderEq_shareBot [PreorderBot α] {a : α} (h : OrderEq a shareBot) : AtBot a := h.left theorem orderEq_shareBot_iff_atBot [PreorderBot α] (a : α) : OrderEq a shareBot ↔ AtBot a := ⟨atBot_of_orderEq_shareBot, orderEq_shareBot_of_atBot⟩ theorem strict_shareBot_iff_not_atBot [PreorderBot α] (a : α) : Strict (shareBot : α) a ↔ ¬ AtBot a := by constructor · intro h exact h.right · intro h exact ⟨shareBot_le a, h⟩ end WAA ===== FILE: lakefile.toml ===== name = "WeldAndArrow" version = "0.1.0" defaultTargets = ["WeldAndArrow"] [[lean_lib]] name = "WeldAndArrow" [[lean_exe]] name = "glossary_gen" root = "WeldAndArrow.Gen.Glossary" [[lean_exe]] name = "assumptions_gen" root = "WeldAndArrow.Gen.Assumptions" [[lean_exe]] name = "exposition_gen" root = "WeldAndArrow.Gen.Exposition" [[lean_exe]] name = "exposition_generation_full" root = "WeldAndArrow.Gen.FullExpositionGeneration" ===== FILE: LICENSE ===== Copyright (C) [year] [author] Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted. THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.