Kannō-Sōe Mutual Dependence (KSMD) context snapshot Source commit: db5cdd2 Built at: 2026-07-28T22:53:23.074Z Frozen snapshot of https://github.com/kanno-soe/kanno-soe. Selected modules: Code, Exposition Files: - KannoSoe/Signature/Assumptions.lean - KannoSoe/Signature/BeingConvention.lean - KannoSoe/Signature/Claims.lean - KannoSoe/Signature/DirectionConvention.lean - KannoSoe/Signature/Grid.lean - KannoSoe/Signature/Models.lean - KannoSoe/Signature/Order.lean - KannoSoe/Signature/Readings.lean - KannoSoe/Signature/SentienceConvention.lean - KannoSoe/Signature/V2.lean - KannoSoe/Consequences/Basic.lean - KannoSoe/Consequences/Compounds.lean - KannoSoe/Consequences/ContentRows.lean - KannoSoe/Consequences/FoxCase.lean - KannoSoe/Consequences/Ladder.lean - KannoSoe/Consequences/ModelWitnesses.lean - KannoSoe/Consequences/Taxonomy.lean - KannoSoe/Doctrines/Correlations.lean - KannoSoe/Doctrines/CorrelationsNegative.lean - KannoSoe/Doctrines/Deliberation.lean - KannoSoe/Doctrines/Doors.lean - KannoSoe/Doctrines/DoorsNegative.lean - KannoSoe/Doctrines/EffectiveTerminusNegative.lean - KannoSoe/Doctrines/Ethics.lean - KannoSoe/Doctrines/EthicsNegative.lean - KannoSoe/Doctrines/Factors.lean - KannoSoe/Doctrines/FactorsNegative.lean - KannoSoe/Doctrines/Faith.lean - KannoSoe/Doctrines/FaithNegative.lean - KannoSoe/Doctrines/Fetters.lean - KannoSoe/Doctrines/FettersNegative.lean - KannoSoe/Doctrines/FourTruths.lean - KannoSoe/Doctrines/FoxCase.lean - KannoSoe/Doctrines/Gradeability.lean - KannoSoe/Doctrines/Icchantika.lean - KannoSoe/Doctrines/Ledger.lean - KannoSoe/Doctrines/OtherPower.lean - KannoSoe/Doctrines/OtherPowerNegative.lean - KannoSoe/Doctrines/Shusho.lean - KannoSoe/Doctrines/Sraddha.lean - KannoSoe/Doctrines/SraddhaNegative.lean - KannoSoe/Doctrines/SuddenGradual.lean - KannoSoe/Doctrines/SuddenGradualNegative.lean - KannoSoe/Identification/Absences.lean - KannoSoe/Identification/Commentary.lean - KannoSoe/Identification/Disclaimers.lean - KannoSoe/Identification/Ownership.lean - KannoSoe/Identification/Placements.lean - KannoSoe/Identification/Registers.lean - KannoSoe/Identification/Residues.lean - KannoSoe/Meta/AssumptionLedger.lean - KannoSoe/Meta/Audit.lean - KannoSoe/Meta/AxiomAudit.lean - KannoSoe/Meta/Examples.lean - KannoSoe/Meta/Invariance.lean - KannoSoe/Meta/InvarianceNegative.lean - KannoSoe/Meta/Metaphysics.lean - KannoSoe/Meta/ReflexivityWitness.lean - KannoSoe/Meta/VerdictLedger.lean - KannoSoe/Consequences.lean - KannoSoe/Doctrines.lean - KannoSoe/Exposition.lean - KannoSoe/Identification.lean - KannoSoe/Meta.lean - KannoSoe/Signature.lean - Exposition/Preamble.md - Exposition/Contents.md - Exposition/Theory.md - Exposition/Theorems.md - Exposition/Identification.md - Exposition/Assumptions.md ===== CONTEXT ===== ===== FILE: KannoSoe/Signature/Assumptions.lean ===== import KannoSoe.Signature.Readings import KannoSoe.Signature.Grid import KannoSoe.Signature.SentienceConvention import KannoSoe.Signature.BeingConvention import KannoSoe.Signature.DirectionConvention import KannoSoe.Signature.Models import KannoSoe.Signature.Claims /-! Input-side assumption pins for the `Signature` layer. This file is the compile-time tripwire for the system's input surface. -/ namespace KannoSoe namespace AssumptionLocalWitnesses inductive DirectionCase | agent | falseCall | trueCall | response | falseOccurrence | trueOccurrence deriving DecidableEq def directionOccurrence : OccurrenceReading DirectionCase where occurrence | .falseOccurrence | .trueOccurrence => True | _ => False isBeing d := d = .agent isCall d := d = .falseCall ∨ d = .trueCall isResponse d := d = .response agent | .falseOccurrence | .trueOccurrence => .agent | d => d call | .falseOccurrence => .falseCall | .trueOccurrence => .trueCall | d => d response | .falseOccurrence | .trueOccurrence => .response | d => d abbrev DirectionW := directionOccurrence.Weld def directionFalse : DirectionW := ⟨.falseOccurrence, True.intro⟩ def directionTrue : DirectionW := ⟨.trueOccurrence, True.intro⟩ def directionResponse : RespondsToReading DirectionCase where respondsTo b c := match b, c with | .agent, .falseCall | .agent, .trueCall => some .response | _, _ => none def directionPlacement : PlacementReading DirectionCase Nat where grade _ := 0 def directionForwardGrid : CoreReadings DirectionCase Nat where occurrence := directionOccurrence response := directionResponse placement := directionPlacement conditioning := { conditions := fun d₁ d₂ => d₁ = .falseOccurrence ∧ d₂ = .trueOccurrence } def directionBackwardGrid : CoreReadings DirectionCase Nat where occurrence := directionOccurrence response := directionResponse placement := directionPlacement conditioning := { conditions := fun d₁ d₂ => d₁ = .trueOccurrence ∧ d₂ = .falseOccurrence } 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 partitionOccurrence : OccurrenceReading Bool where occurrence _ := True isBeing _ := True isCall _ := True isResponse _ := True agent := id call := id response := id def partitionGrid : CoreReadings Bool Nat where occurrence := partitionOccurrence response := { respondsTo := fun _ c => some c } placement := { grade := fun _ => 0 } conditioning := { conditions := fun _ _ => 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 ⟨backslideWeld .gentle, True.intro, rfl⟩ end AssumptionLocalWitnesses namespace InteriorDirectionNegative inductive InteriorCase | agent | low | high | occurrence deriving DecidableEq def occurrenceReading : OccurrenceReading InteriorCase where occurrence d := d = .occurrence isBeing d := d = .agent isCall d := d = .low isResponse d := d = .high agent | .occurrence => .agent | d => d call | .occurrence => .low | d => d response | .occurrence => .high | d => d abbrev W := occurrenceReading.Weld def callThenResponse : W := ⟨.occurrence, rfl⟩ def unorderedCRContent (_w : W) : Prop := True def callResponseReading (w : W) : Prop := w.call = .low def responseCallReading (w : W) : Prop := w.response = .low theorem transposeCR_involutive : occurrenceReading.transposeCR.transposeCR = occurrenceReading := OccurrenceReading.transposeCR_transposeCR occurrenceReading theorem unorderedCRContent_transpose_invariant : unorderedCRContent callThenResponse ↔ unorderedCRContent callThenResponse.transposeCR := Iff.rfl theorem transpose_swaps_readings : callThenResponse.transposeCR.call = callThenResponse.response := rfl theorem call_response_readings_disagree : callResponseReading callThenResponse ∧ ¬ responseCallReading callThenResponse := by constructor · rfl · intro h cases h 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 {Designatum Contrib : Type} [PreorderBot Contrib] variable (G : CoreReadings Designatum Contrib) /- A.1 One carrier; occurrence and roles are readings. -/ #check OccurrenceReading -- proof #check OccurrenceReading.Weld -- proof #check RespondsToReading -- proof #check PlacementReading -- proof #check ConditionsReading -- proof #check CoreReadings -- convenience #check Grid.index -- proof #check Grid.share -- proof #check Grid.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.1 := 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 /- A.4 Sentience and share are orthogonal per occurrence. -/ #check SentienceReading -- proof #check Grid.SentienceReading -- compatibility #check Grid.SentientAct -- proof #check Grid.InsentientAct -- proof #check Grid.OrdinaryAct -- proof #check Grid.TerminusAct -- proof #check Grid.InsentientAppropriation -- proof #check Grid.StoneAct -- proof #check sentience_share_square_inhabited -- 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 /- B.1 Direction is supplied by readings. -/ #check ConditionsReading.transpose -- witness #check OccurrenceReading.transposeCR -- witness #check OccurrenceReading.Weld.transposeCR -- witness #check Grid.ConditionsEither -- proof #check Grid.conditionsEither_symm -- proof #check Grid.transpose -- witness #check Grid.transpose_conditionsEither_iff -- witness #check AssumptionLocalWitnesses.no_direction_recovery_from_conditionsEither -- witness #check InteriorDirectionNegative.no_interior_direction_recovery -- witness /- B.2 No PreorderTop. -/ #check PreorderBot -- proof #check AtBot -- proof #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 AssumptionLocalWitnesses.partition_merge_split_disagree -- witness /- 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 /- 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 /- B.11 No sentience recovery from the other readings. -/ #check Grid.actual_weld_readings_split -- proof #check Grid.no_sentience_recovery -- witness #check Grid.SentienceReading.allSentient -- witness #check Grid.SentienceReading.allInsentient -- witness /- C.1 Hand-rolled order classes. -/ #check Preorder -- proof #check PreorderBot -- proof #check shareBot -- proof #check shareBot_le -- proof /- C.4 Model witnesses are illustrative. -/ #check clockGrid -- witness #check registerClockGrid -- witness #check registerClock_insentient_proficient -- witness #check clock_pole_readings_split -- witness #check registerClock_rung_readings_split -- witness #check rigid_terminus_vacuous -- witness #check adaptive_liveTerminus -- witness #check sentience_share_square_inhabited -- witness #check registerClock_macro_selfConditioning -- witness end AssumptionAnchors end KannoSoe ===== FILE: KannoSoe/Signature/BeingConvention.lean ===== /- ================================================================================ KannoSoe.Signature.BeingConvention Being-convention vocabulary and diagnosis-time coarsenings ================================================================================ Reading and motivation: Identification/Commentary.lean, C.1. -/ import KannoSoe.Signature.SentienceConvention namespace KannoSoe namespace Grid variable {Designatum Contrib : Type} [PreorderBot Contrib] variable (G : CoreReadings Designatum Contrib) namespace DirectedConvention namespace BeingConvention /- Reading and motivation: Identification/Commentary.lean, C.1. -/ abbrev MountsAt (b : Designatum) (c : Designatum) : Prop := G.MountsAt b c /-- Re-rooted name for call-entire response. -/ abbrev RespondsToEveryCall (b : Designatum) : Prop := G.RespondsToEveryCall b /-- Re-rooted name for the pole-class responder. -/ abbrev Terminus (b : Designatum) : Prop := G.Terminus b /-- Re-rooted name for non-vacuous terminus response. -/ abbrev LiveTerminus (b : Designatum) : Prop := G.LiveTerminus b /-- Re-rooted name for call-entire terminus response. -/ abbrev ResponsiveTerminus (b : Designatum) : Prop := G.ResponsiveTerminus b /-- Re-rooted name for terminus typing at the pole-class. -/ abbrev AtPoleClass (b : Designatum) : 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 : Designatum) (cs : Designatum → Prop) : Prop := G.ProbeConstant b cs /- Reading and motivation: Identification/Commentary.lean, C.1. -/ structure BeingCoarsening (G : CoreReadings Designatum Contrib) (Macro : Type) where proj : Designatum → Macro namespace BeingCoarsening variable {G : CoreReadings Designatum Contrib} {Macro : Type} (κ : BeingCoarsening G Macro) /-- The identity being coarsening: every fine tag remains its own macro tag. -/ protected def id (G : CoreReadings Designatum Contrib) : BeingCoarsening G Designatum where proj := id omit [PreorderBot Contrib] in @[simp] theorem id_proj (p : Designatum) : (BeingCoarsening.id G).proj p = p := rfl /-- The total being coarsening: all fine tags are read as one macro tag. -/ def total (G : CoreReadings Designatum Contrib) : BeingCoarsening G Unit where proj _ := () omit [PreorderBot Contrib] in @[simp] theorem total_proj (p : Designatum) : (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) omit [PreorderBot Contrib] in @[simp] theorem comp_proj {Macro' : Type} (κ : BeingCoarsening G Macro) (f : Macro → Macro') (p : Designatum) : (κ.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 : Designatum) : Prop := κ.proj p = κ.proj q omit [PreorderBot Contrib] in theorem total_sameFiber (p q : Designatum) : (BeingCoarsening.total G).SameFiber p q := rfl omit [PreorderBot Contrib] in theorem id_not_sameFiber_of_ne {p q : Designatum} (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 : Designatum, κ.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 /-- A macro tag has at least one actual weld marked sentient by the supplied reading. This is quantified display over acts, not a standing property. -/ def SentientTag (S : SentienceReading G) (b : Macro) : Prop := ∃ w : G.Weld, G.SentientAct S w ∧ κ.InFiber b w /-- A nonempty macro tag all of whose actual welds occupy the insentient pole-share cell. -/ def StoneTag (S : SentienceReading G) (b : Macro) : Prop := κ.ActualFiberInhabited b ∧ ∀ w : G.Weld, G.Actual w → κ.InFiber b w → G.StoneAct S w /-- A macro tag with both marked and unmarked actual welds. No scalar degree of sentience is inferred from this patchiness. -/ def Intermittent (S : SentienceReading G) (b : Macro) : Prop := (∃ w : G.Weld, G.SentientAct S w ∧ κ.InFiber b w) ∧ (∃ w : G.Weld, G.InsentientAct S w ∧ κ.InFiber b w) omit [PreorderBot Contrib] in theorem actualFiberInhabited_of_sentientTag (S : SentienceReading G) {b : Macro} (h : κ.SentientTag S b) : κ.ActualFiberInhabited b := by rcases h with ⟨w, hsentient, hfiber⟩ exact ⟨w, hsentient.left, hfiber⟩ omit [PreorderBot Contrib] in theorem allSentient_sentientTag_iff_actualFiberInhabited (b : Macro) : κ.SentientTag (SentienceReading.allSentient G) b ↔ κ.ActualFiberInhabited b := by constructor · exact κ.actualFiberInhabited_of_sentientTag (SentienceReading.allSentient G) · rintro ⟨w, hactual, hfiber⟩ exact ⟨w, ⟨hactual, True.intro⟩, hfiber⟩ omit [PreorderBot Contrib] in theorem allInsentient_not_sentientTag (b : Macro) : ¬ κ.SentientTag (SentienceReading.allInsentient G) b := by rintro ⟨w, hsentient, _hfiber⟩ exact hsentient.right /- 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 : Designatum → 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 : Designatum → Prop) (ts : Designatum → 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 : Designatum → Prop) : Prop := κ.FiberAtPoleOnWithin b (fun _ => True) ts /-- A fiber has an actual weld in the supplied call-class. -/ def ActualFiberInhabitedOn (b : Macro) (cs : Designatum → 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 : Designatum → 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 : Designatum → Prop) : Prop := κ.ActualFiberInhabitedOn b cs ∧ κ.FiberAtPoleOn b cs /-- The live, non-vacuous tag-restricted fiber-at-pole predicate. -/ def LiveFiberAtPoleWithin (b : Macro) (ts : Designatum → 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 : Designatum → 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 : Designatum, κ.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 : Designatum → Prop} (h : ∀ p : Designatum, κ.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 : Designatum → Prop} (h : κ.FiberAtPoleOn b cs) (hsub : ∀ c : Designatum, 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 : Designatum → Prop} {ts : Designatum → Prop} (h : κ.FiberAtPoleOnWithin b cs ts) (hsub : ∀ c : Designatum, 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 : Designatum → Prop} {ts us : Designatum → Prop} (h : κ.FiberAtPoleOnWithin b cs ts) (hsub : ∀ p : Designatum, 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 : Designatum → 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 : Designatum → 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 : Designatum → 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 : Designatum → 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 : Designatum → Prop} {ts : Designatum → 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 : Designatum → 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 omit [PreorderBot Contrib] in @[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 omit [PreorderBot Contrib] in theorem transpose_inFiber_iff (κ : BeingCoarsening G Macro) (b : Macro) (w : G.Weld) : κ.transpose.InFiber b w ↔ κ.InFiber b w := Iff.rfl omit [PreorderBot Contrib] in theorem transpose_sentientTag_iff (κ : BeingCoarsening G Macro) (S : SentienceReading G) (b : Macro) : κ.transpose.SentientTag S.transpose b ↔ κ.SentientTag S b := Iff.rfl omit [PreorderBot Contrib] in /-- 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 KannoSoe ===== FILE: KannoSoe/Signature/Claims.lean ===== /- ================================================================================ KannoSoe.Signature.Claims Separate/fuse claim interface ================================================================================ Reading and motivation: Identification/Commentary.lean, C.1. -/ import KannoSoe.Signature.Grid namespace KannoSoe /- ============================================================================== §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 {Designatum Contrib : Type} [PreorderBot Contrib] /- Reading and motivation: Identification/Commentary.lean, C.1. -/ inductive Tier (G : CoreReadings Designatum Contrib) | floor | actTime (w : G.Weld) variable (G : CoreReadings Designatum 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 : CoreReadings Designatum 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 : CoreReadings Designatum 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 : CoreReadings Designatum 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 : CoreReadings Designatum Contrib} {L : ClaimLanguage G} (u : RecordedUtterance G L) : Designatum := 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 : CoreReadings Designatum Contrib} {L : ClaimLanguage G} (u : RecordedUtterance G L) : Prop := L.TrueAt u.offeredAt u.content /-- A recorded utterance misfits its offered tier exactly when it makes an act-time offer whose content is not satisfied there. Floor offers do not count as errors: at the floor the claim-language has run out rather than issued a false conventional assertion. -/ def MisfitsOfferedTier {G : CoreReadings Designatum Contrib} {L : ClaimLanguage G} (u : RecordedUtterance G L) : Prop := ∃ w : G.Weld, u.offeredAt = Tier.actTime w ∧ ¬ L.TrueAt u.offeredAt u.content end RecordedUtterance /-- A distinction: two claim-objects a diagnosis might hold apart. -/ structure Distinction (G : CoreReadings Designatum Contrib) where language : ClaimLanguage G sideA : language.Claim sideB : language.Claim /- Reading and motivation: Identification/Commentary.lean, C.1. -/ def Distinction.Fused {G : CoreReadings Designatum 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 : CoreReadings Designatum 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 : CoreReadings Designatum 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 : CoreReadings Designatum 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 : CoreReadings Designatum 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 : CoreReadings Designatum 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 : CoreReadings Designatum 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 : CoreReadings Designatum 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. -/ omit [PreorderBot Contrib] in 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 {Designatum 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 : CoreReadings Designatum Contrib) := Grid.Tier G abbrev ClaimLanguage (G : CoreReadings Designatum Contrib) := Grid.ClaimLanguage G abbrev RecordedUtterance (G : CoreReadings Designatum Contrib) (L : Grid.ClaimLanguage G) := Grid.RecordedUtterance G L abbrev Distinction (G : CoreReadings Designatum Contrib) := Grid.Distinction G abbrev VerdictVoice := Grid.VerdictVoice abbrev ErrorGrade := Grid.ErrorGrade abbrev GeneratorOutcome (G : CoreReadings Designatum Contrib) := Grid.GeneratorOutcome G end GridConvention end BeingConvention end DirectedConvention end Grid end KannoSoe ===== FILE: KannoSoe/Signature/DirectionConvention.lean ===== /- ================================================================================ KannoSoe.Signature.DirectionConvention Direction-coarsening vocabulary over the delivery axis ================================================================================ Reading and motivation: Identification/Commentary.lean, C.1. -/ import KannoSoe.Signature.Grid namespace KannoSoe namespace Grid namespace DirectedConvention variable {Designatum 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 : CoreReadings Designatum Contrib) (Tick : Type) where tick : G.Weld -> Tick namespace DirectionCoarsening variable {G : CoreReadings Designatum 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₂ omit [PreorderBot Contrib] in 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 omit [PreorderBot Contrib] in 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 omit [PreorderBot Contrib] in /-- 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 KannoSoe ===== FILE: KannoSoe/Signature/Grid.lean ===== /- ================================================================================ KannoSoe.Signature.Grid Compatibility namespace for independent readings ================================================================================ `Grid` is retained only as a namespace while the library migrates its public vocabulary. There is no `Grid` structure and no primitive agent/call/response triple. Concrete models package independent readings in `CoreReadings`; a weld is the occurrence-reading-generated subtype. -/ import KannoSoe.Signature.Readings namespace KannoSoe universe u v /-- A carried contribution tendency. It stores no occurrence or designatum. -/ @[ext] structure Config (Contrib : Type v) where tendency : Contrib namespace Grid variable {Designatum : Type u} {Contrib : Type v} variable [PreorderBot Contrib] /- -------------------------------------------------------------------------- Compatibility projections from a `CoreReadings` package -------------------------------------------------------------------------- -/ /-- Occurrences selected by the package's occurrence reading. -/ abbrev Weld (G : CoreReadings Designatum Contrib) := G.occurrence.Weld /-- The independently supplied response rule. -/ abbrev respondsTo (G : CoreReadings Designatum Contrib) : Designatum → Designatum → Option Designatum := G.response.respondsTo /-- Direct placement of a designatum in the contribution display. -/ abbrev grade (G : CoreReadings Designatum Contrib) : Designatum → Contrib := G.placement.grade /-- Conditioning restricted to occurrence designata for compatibility with the established theorem vocabulary. -/ def conditions (G : CoreReadings Designatum Contrib) (deed reception : Weld G) : Prop := G.conditioning.conditions deed.1 reception.1 variable (G : CoreReadings Designatum Contrib) /- -------------------------------------------------------------------------- Actuality, placement, and self-pole vocabulary -------------------------------------------------------------------------- -/ def Actual (w : Weld G) : Prop := KannoSoe.Actual G.occurrence G.response w def index (w : Weld G) : Designatum := w.agent def share (w : Weld G) : Contrib := KannoSoe.share G.occurrence G.placement w def HasSelfPoleIndex (w : Weld G) : Prop := ¬ AtBot (share G w) def selfPoleIndex (w : Weld G) (_h : HasSelfPoleIndex G w) : Designatum := w.agent theorem strict_shareBot_of_hasSelfPoleIndex (w : Weld G) (h : HasSelfPoleIndex G w) : Strict (shareBot : Contrib) (share G w) := ⟨shareBot_le (share G w), h⟩ def KsmdAppropriates (reception : Weld G) : Prop := HasSelfPoleIndex G reception theorem no_self_pole_index_of_atBot (w : Weld G) (h : AtBot (share G w)) : ¬ HasSelfPoleIndex G w := fun hidx => hidx h theorem no_self_pole_index_of_eq_shareBot (w : Weld G) (h : share G w = shareBot) : ¬ HasSelfPoleIndex G w := no_self_pole_index_of_atBot G w (atBot_of_eq_shareBot h) theorem selfPoleIndex_eq_agent_of_hasSelfPoleIndex (w : Weld G) (h : HasSelfPoleIndex G w) : selfPoleIndex G w h = w.agent := rfl theorem not_ksmdAppropriates_of_atBot (w : Weld G) (h : AtBot (share G w)) : ¬ KsmdAppropriates G w := no_self_pole_index_of_atBot G w h theorem not_ksmdAppropriates_of_eq_shareBot (w : Weld G) (h : share G w = shareBot) : ¬ KsmdAppropriates G w := not_ksmdAppropriates_of_atBot G w (atBot_of_eq_shareBot h) omit [PreorderBot Contrib] in theorem share_eq_grade_check (w : Weld G) : share G w = grade G w.1 := rfl /-- Constancy of placement over actual occurrences of one agent in a supplied call class. The predicate now ranges over occurrence designata instead of hypothetical primitive triples. -/ def ProbeConstant (b : Designatum) (cs : Designatum → Prop) : Prop := ∀ w₁ w₂ : Weld G, Actual G w₁ → Actual G w₂ → w₁.agent = b → w₂.agent = b → cs w₁.call → cs w₂.call → OrderEq (share G w₁) (share G w₂) /- -------------------------------------------------------------------------- Response and terminus vocabulary -------------------------------------------------------------------------- -/ def MountsAt (b c : Designatum) : Prop := KannoSoe.MountsAt G.response b c /-- Every designatum marked as a call receives a response. -/ def RespondsToEveryCall (b : Designatum) : Prop := ∀ c, G.occurrence.isCall c → MountsAt G b c /-- Every actual occurrence by the designatum lies at the pole. -/ def Terminus (b : Designatum) : Prop := ∀ w : Weld G, Actual G w → w.agent = b → AtBot (share G w) def ActualAgentInhabited (b : Designatum) : Prop := ∃ w : Weld G, Actual G w ∧ w.agent = b def LiveTerminus (b : Designatum) : Prop := ActualAgentInhabited G b ∧ Terminus G b def ResponsiveTerminus (b : Designatum) : Prop := RespondsToEveryCall G b ∧ Terminus G b /-- Every selected occurrence by the designatum lies at the pole, whether or not the response reading makes that occurrence actual. This is the explicit hypothetical counterpart to `Terminus`. -/ def HypotheticalTerminus (b : Designatum) : Prop := ∀ w : Weld G, w.agent = b → AtBot (share G w) /-- A selected occurrence realizes a response-rule triple when its three role faces are that agent, call, and response. -/ def OccurrenceRealizes (b c r : Designatum) : Prop := ∃ w : Weld G, w.agent = b ∧ w.call = c ∧ w.response = r theorem terminus_of_hypotheticalTerminus {b : Designatum} (h : HypotheticalTerminus G b) : Terminus G b := fun w _hactual hagent => h w hagent theorem atBot_of_terminus_response {w : Weld G} (hterm : Terminus G w.agent) (hactual : Actual G w) : AtBot (share G w) := hterm w hactual rfl theorem no_self_pole_index_of_terminus_response {w : Weld G} (hterm : Terminus G w.agent) (hactual : Actual G w) : ¬ HasSelfPoleIndex G w := no_self_pole_index_of_atBot G w (atBot_of_terminus_response G hterm hactual) theorem not_ksmdAppropriates_of_terminus_response {w : Weld G} (hterm : Terminus G w.agent) (hactual : Actual G w) : ¬ KsmdAppropriates G w := not_ksmdAppropriates_of_atBot G w (atBot_of_terminus_response G hterm hactual) def AtPoleClass (b : Designatum) : Prop := Terminus G b /-- A responsive terminus is live once an actual occurrence by it is supplied. -/ theorem responsiveTerminus_live_of_actual (b : Designatum) (h : ResponsiveTerminus G b) (w : Weld G) (hactual : Actual G w) (hagent : w.agent = b) : LiveTerminus G b := ⟨⟨w, hactual, hagent⟩, h.right⟩ /-- A call makes a responsive terminus live only when response-rule outputs are explicitly realized by selected occurrences. `RespondsToEveryCall` supplies the output; `hrealize` supplies the occurrence token. -/ theorem responsiveTerminus_live_of_call (b c : Designatum) (h : ResponsiveTerminus G b) (hcall : G.occurrence.isCall c) (hrealize : ∀ r, G.response.respondsTo b c = some r → OccurrenceRealizes G b c r) : LiveTerminus G b := by rcases h.left c hcall with ⟨r, hresponse⟩ rcases hrealize r hresponse with ⟨w, hagent, hwcall, hwresponse⟩ apply responsiveTerminus_live_of_actual G b h w · unfold Actual KannoSoe.Actual rw [hagent, hwcall, hwresponse] exact hresponse · exact hagent /- -------------------------------------------------------------------------- Configuration and delivery structure -------------------------------------------------------------------------- -/ def rePitch (_before : Config Contrib) (received : Weld G) : Config Contrib := { tendency := share G received } def IsShareDrop (before : Config Contrib) (received : Weld G) : Prop := Strict (share G received) before.tendency def ConditionsEither (w₁ w₂ : Weld G) : Prop := conditions G w₁ w₂ ∨ conditions G w₂ w₁ omit [PreorderBot Contrib] in theorem conditionsEither_symm {w₁ w₂ : Weld G} (h : ConditionsEither G w₁ w₂) : ConditionsEither G w₂ w₁ := h.elim Or.inr Or.inl inductive ConditionsEitherChain : Weld G → Weld G → Prop | refl (w : Weld G) : ConditionsEitherChain w w | step {w₁ w₂ w₃ : Weld G} : ConditionsEither G w₁ w₂ → ConditionsEitherChain w₂ w₃ → ConditionsEitherChain w₁ w₃ /-- Reverse only the independently supplied conditioning reading. -/ def transpose (G : CoreReadings Designatum Contrib) : CoreReadings Designatum Contrib where occurrence := G.occurrence response := G.response placement := G.placement conditioning := G.conditioning.transpose omit [PreorderBot Contrib] in theorem transpose_conditions (w₁ w₂ : Weld G) : conditions (transpose G) w₁ w₂ ↔ conditions G w₂ w₁ := Iff.rfl omit [PreorderBot Contrib] in theorem transpose_transpose : transpose (transpose G) = G := rfl omit [PreorderBot Contrib] in theorem transpose_conditionsEither_iff (w₁ w₂ : Weld G) : ConditionsEither (transpose G) w₁ w₂ ↔ ConditionsEither G w₁ w₂ := ⟨fun h => h.elim Or.inr Or.inl, fun h => h.elim Or.inr Or.inl⟩ namespace DirectedConvention abbrev TimeDirection {α : Type u} [Preorder α] (a b : α) : Prop := Strict a b theorem timeDirection_of_hasSelfPoleIndex (w : Weld G) (h : HasSelfPoleIndex G w) : TimeDirection (shareBot : Contrib) (share G w) := strict_shareBot_of_hasSelfPoleIndex G w h def KsmdReachBackFull (deed reception : Weld G) : Prop := KannoSoe.DeliveredTo G.occurrence G.conditioning deed reception def DeliveredTo (deed reception : Weld G) : Prop := KannoSoe.DeliveredTo G.occurrence G.conditioning deed reception def SameAgentDelivery (deed reception : Weld G) : Prop := DeliveredTo G deed reception ∧ deed.agent = reception.agent def CrossAgentDelivery (deed reception : Weld G) : Prop := DeliveredTo G deed reception ∧ deed.agent ≠ reception.agent omit [PreorderBot Contrib] in theorem transpose_deliveredTo_iff (deed reception : Weld G) : DeliveredTo (transpose G) deed reception ↔ DeliveredTo G reception deed := Iff.rfl def NotDeliveredTo (deed reception : Weld G) : Prop := ¬ conditions G deed reception omit [PreorderBot Contrib] in theorem deliveredTo_or_not (deed reception : Weld G) [hdec : Decidable (conditions G deed reception)] : DeliveredTo G deed reception ∨ NotDeliveredTo G deed reception := match hdec with | isTrue h => Or.inl h | isFalse h => Or.inr h def LandsAt (deed reception : Weld G) : Prop := DeliveredTo G deed reception ∧ Actual G reception def ObjectAxisStanding (deed : Weld G) : Prop := ∃ reception, DeliveredTo G deed reception def LandsWithShareDrop (before : Config Contrib) (deed reception : Weld G) : Prop := LandsAt G deed reception ∧ IsShareDrop G before reception def HasShareDropLanding (before : Config Contrib) (deed : Weld G) : Prop := ∃ reception, LandsWithShareDrop G before deed reception def EnvironsLine (b : Designatum) (deed reception : Weld G) : Prop := Actual G deed ∧ reception.agent = b ∧ conditions G deed reception def ShareDropLine (before : Config Contrib) (b : Designatum) (deed reception : Weld G) : Prop := EnvironsLine G b deed reception ∧ IsShareDrop G before reception def KsmdAimedAt (deed reception : Weld G) : Prop := DeliveredTo G deed reception omit [PreorderBot Contrib] in theorem deliveredTo_iff_ksmdReachBackFull (deed reception : Weld G) : DeliveredTo G deed reception ↔ KsmdReachBackFull G deed reception := Iff.rfl omit [PreorderBot Contrib] in theorem objectAxisStanding_of_landsAt (deed reception : Weld G) (h : LandsAt G deed reception) : ObjectAxisStanding G deed := ⟨reception, h.left⟩ theorem objectAxisStanding_of_hasShareDropLanding (before : Config Contrib) (deed : Weld G) (h : HasShareDropLanding G before deed) : ObjectAxisStanding G deed := h.elim fun reception hland => ⟨reception, hland.left.left⟩ end DirectedConvention /- -------------------------------------------------------------------------- Response-shape vocabulary -------------------------------------------------------------------------- -/ def ResponseInvariant (b : Designatum) : Prop := ∀ c₁ c₂ r₁ r₂, respondsTo G b c₁ = some r₁ → respondsTo G b c₂ = some r₂ → r₁ = r₂ def ResponseVariesWithCall (b : Designatum) : Prop := ∃ c₁ c₂ r₁ r₂, respondsTo G b c₁ = some r₁ ∧ respondsTo G b c₂ = some r₂ ∧ r₁ ≠ r₂ /- -------------------------------------------------------------------------- Packaged actual occurrences and reception pairs -------------------------------------------------------------------------- -/ structure ActualWeld (G : CoreReadings Designatum Contrib) where weld : Weld G actual : Actual G weld structure ReceptionPair (G : CoreReadings Designatum Contrib) where first : ActualWeld G second : ActualWeld G namespace ReceptionPair def FirstConditionsSecond {G : CoreReadings Designatum Contrib} (p : ReceptionPair G) : Prop := DirectedConvention.KsmdReachBackFull G p.first.weld p.second.weld def rePitchSequence {G : CoreReadings Designatum Contrib} (before : Config Contrib) (p : ReceptionPair G) : Config Contrib × Config Contrib := let afterFirst := rePitch G before p.first.weld (afterFirst, rePitch G afterFirst p.second.weld) end ReceptionPair /- -------------------------------------------------------------------------- Field-residue underdetermination -------------------------------------------------------------------------- -/ def fieldOf (w : Weld G) : Designatum × Designatum := (w.call, w.response) omit [PreorderBot Contrib] in theorem no_agent_recovery_of_field_collision (w₁ w₂ : Weld G) (h₁ : Actual G w₁) (h₂ : Actual G w₂) (hfield : fieldOf G w₁ = fieldOf G w₂) (hne : w₁.agent ≠ w₂.agent) : ¬ ∃ recover : Designatum × Designatum → Designatum, ∀ w : Weld G, Actual G w → recover (fieldOf G w) = index G w := by rintro ⟨recover, hrec⟩ apply hne calc w₁.agent = recover (fieldOf G w₁) := (hrec w₁ h₁).symm _ = recover (fieldOf G w₂) := congrArg recover hfield _ = w₂.agent := hrec w₂ h₂ end Grid /- Field-notation bridge for packages. The declarations themselves remain in the temporary `Grid` compatibility namespace, preserving established public names while `G.foo` continues to elaborate for a `CoreReadings` package. -/ namespace CoreReadings variable {Designatum : Type u} {Contrib : Type v} variable [PreorderBot Contrib] abbrev Weld (G : CoreReadings Designatum Contrib) := Grid.Weld G abbrev respondsTo (G : CoreReadings Designatum Contrib) := Grid.respondsTo G abbrev grade (G : CoreReadings Designatum Contrib) := Grid.grade G abbrev conditions (G : CoreReadings Designatum Contrib) := Grid.conditions G abbrev Actual (G : CoreReadings Designatum Contrib) := Grid.Actual G abbrev index (G : CoreReadings Designatum Contrib) := Grid.index G abbrev share (G : CoreReadings Designatum Contrib) := Grid.share G abbrev HasSelfPoleIndex (G : CoreReadings Designatum Contrib) := Grid.HasSelfPoleIndex G abbrev selfPoleIndex (G : CoreReadings Designatum Contrib) := Grid.selfPoleIndex G abbrev strict_shareBot_of_hasSelfPoleIndex (G : CoreReadings Designatum Contrib) := Grid.strict_shareBot_of_hasSelfPoleIndex G abbrev KsmdAppropriates (G : CoreReadings Designatum Contrib) := Grid.KsmdAppropriates G abbrev no_self_pole_index_of_atBot (G : CoreReadings Designatum Contrib) := Grid.no_self_pole_index_of_atBot G abbrev no_self_pole_index_of_eq_shareBot (G : CoreReadings Designatum Contrib) := Grid.no_self_pole_index_of_eq_shareBot G abbrev selfPoleIndex_eq_agent_of_hasSelfPoleIndex (G : CoreReadings Designatum Contrib) := Grid.selfPoleIndex_eq_agent_of_hasSelfPoleIndex G abbrev not_ksmdAppropriates_of_atBot (G : CoreReadings Designatum Contrib) := Grid.not_ksmdAppropriates_of_atBot G abbrev not_ksmdAppropriates_of_eq_shareBot (G : CoreReadings Designatum Contrib) := Grid.not_ksmdAppropriates_of_eq_shareBot G abbrev share_eq_grade_check (G : CoreReadings Designatum Contrib) := Grid.share_eq_grade_check G abbrev ProbeConstant (G : CoreReadings Designatum Contrib) := Grid.ProbeConstant G abbrev MountsAt (G : CoreReadings Designatum Contrib) := Grid.MountsAt G abbrev RespondsToEveryCall (G : CoreReadings Designatum Contrib) := Grid.RespondsToEveryCall G abbrev Terminus (G : CoreReadings Designatum Contrib) := Grid.Terminus G abbrev ActualAgentInhabited (G : CoreReadings Designatum Contrib) := Grid.ActualAgentInhabited G abbrev LiveTerminus (G : CoreReadings Designatum Contrib) := Grid.LiveTerminus G abbrev ResponsiveTerminus (G : CoreReadings Designatum Contrib) := Grid.ResponsiveTerminus G abbrev HypotheticalTerminus (G : CoreReadings Designatum Contrib) := Grid.HypotheticalTerminus G abbrev OccurrenceRealizes (G : CoreReadings Designatum Contrib) := Grid.OccurrenceRealizes G abbrev terminus_of_hypotheticalTerminus (G : CoreReadings Designatum Contrib) {b : Designatum} (h : G.HypotheticalTerminus b) := Grid.terminus_of_hypotheticalTerminus G h abbrev atBot_of_terminus_response (G : CoreReadings Designatum Contrib) {w : G.Weld} (hterm : G.Terminus w.agent) (hactual : G.Actual w) := Grid.atBot_of_terminus_response G hterm hactual abbrev no_self_pole_index_of_terminus_response (G : CoreReadings Designatum Contrib) {w : G.Weld} (hterm : G.Terminus w.agent) (hactual : G.Actual w) := Grid.no_self_pole_index_of_terminus_response G hterm hactual abbrev not_ksmdAppropriates_of_terminus_response (G : CoreReadings Designatum Contrib) {w : G.Weld} (hterm : G.Terminus w.agent) (hactual : G.Actual w) := Grid.not_ksmdAppropriates_of_terminus_response G hterm hactual abbrev AtPoleClass (G : CoreReadings Designatum Contrib) := Grid.AtPoleClass G abbrev responsiveTerminus_live_of_actual (G : CoreReadings Designatum Contrib) := Grid.responsiveTerminus_live_of_actual G abbrev responsiveTerminus_live_of_call (G : CoreReadings Designatum Contrib) := Grid.responsiveTerminus_live_of_call G abbrev rePitch (G : CoreReadings Designatum Contrib) := Grid.rePitch G abbrev IsShareDrop (G : CoreReadings Designatum Contrib) := Grid.IsShareDrop G abbrev ConditionsEither (G : CoreReadings Designatum Contrib) := Grid.ConditionsEither G abbrev ConditionsEitherChain (G : CoreReadings Designatum Contrib) := Grid.ConditionsEitherChain G abbrev conditionsEither_symm (G : CoreReadings Designatum Contrib) {w₁ w₂ : G.Weld} (h : G.ConditionsEither w₁ w₂) := Grid.conditionsEither_symm G h abbrev transpose (G : CoreReadings Designatum Contrib) := Grid.transpose G abbrev transpose_conditions (G : CoreReadings Designatum Contrib) := Grid.transpose_conditions G abbrev transpose_transpose (G : CoreReadings Designatum Contrib) := Grid.transpose_transpose G abbrev transpose_conditionsEither_iff (G : CoreReadings Designatum Contrib) := Grid.transpose_conditionsEither_iff G abbrev ResponseInvariant (G : CoreReadings Designatum Contrib) := Grid.ResponseInvariant G abbrev ResponseVariesWithCall (G : CoreReadings Designatum Contrib) := Grid.ResponseVariesWithCall G abbrev ActualWeld (G : CoreReadings Designatum Contrib) := Grid.ActualWeld G abbrev ReceptionPair (G : CoreReadings Designatum Contrib) := Grid.ReceptionPair G abbrev fieldOf (G : CoreReadings Designatum Contrib) := Grid.fieldOf G abbrev no_agent_recovery_of_field_collision (G : CoreReadings Designatum Contrib) := Grid.no_agent_recovery_of_field_collision G end CoreReadings end KannoSoe ===== FILE: KannoSoe/Signature/Models.lean ===== /- ================================================================================ KannoSoe.Signature.Models Concrete one-carrier reading packages ================================================================================ -/ import KannoSoe.Signature.BeingConvention namespace KannoSoe section Preview 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 /- -------------------------------------------------------------------------- Clock case -------------------------------------------------------------------------- -/ /-- One carrier for the clock display. -/ inductive ClockCase | rigid | adaptive | present | absent | chime | adaptivePresentOccurrence deriving DecidableEq namespace Clock abbrev rigid : ClockCase := .rigid abbrev adaptive : ClockCase := .adaptive end Clock namespace Listener abbrev present : ClockCase := .present abbrev absent : ClockCase := .absent end Listener namespace Chime abbrev chime : ClockCase := .chime end Chime def clockOccurrence : OccurrenceReading ClockCase where occurrence d := d = .adaptivePresentOccurrence isBeing d := d = .rigid ∨ d = .adaptive isCall d := d = .present ∨ d = .absent isResponse d := d = .chime agent | .adaptivePresentOccurrence => .adaptive | d => d call | .adaptivePresentOccurrence => .present | d => d response | .adaptivePresentOccurrence => .chime | d => d def clockRespondsTo : RespondsToReading ClockCase where respondsTo b c := match b, c with | .adaptive, .present => some .chime | _, _ => none def clockPlacement : PlacementReading ClockCase Nat where grade _ := 0 def clockConditioning : ConditionsReading ClockCase where conditions _ _ := False def clockGrid : CoreReadings ClockCase Nat where occurrence := clockOccurrence response := clockRespondsTo placement := clockPlacement conditioning := clockConditioning def clockAdaptivePresent : clockGrid.Weld := ⟨.adaptivePresentOccurrence, rfl⟩ theorem adaptive_is_terminus : clockGrid.Terminus Clock.adaptive := by intro w _hactual _hagent exact Nat.le_refl 0 theorem rigid_terminus_vacuous : clockGrid.Terminus Clock.rigid ∧ ¬ clockGrid.ActualAgentInhabited Clock.rigid := by constructor · intro w _hactual _hagent exact Nat.le_refl 0 · rintro ⟨w, _hactual, hagent⟩ rcases w with ⟨d, hd⟩ change clockOccurrence.agent d = Clock.rigid at hagent change clockOccurrence.occurrence d at hd subst d cases hagent theorem adaptive_liveTerminus : clockGrid.LiveTerminus Clock.adaptive := ⟨⟨clockAdaptivePresent, rfl, rfl⟩, adaptive_is_terminus⟩ theorem clock_pole_readings_split : clockGrid.StoneAct (Grid.SentienceReading.allInsentient clockGrid) clockAdaptivePresent ∧ clockGrid.TerminusAct (Grid.SentienceReading.allSentient clockGrid) clockAdaptivePresent := by have hsplit := clockGrid.actual_weld_readings_split clockAdaptivePresent rfl have hbot : AtBot (clockGrid.share clockAdaptivePresent) := clockGrid.atBot_of_terminus_response adaptive_is_terminus rfl exact ⟨⟨hsplit.right, hbot⟩, ⟨hsplit.left, hbot⟩⟩ /- -------------------------------------------------------------------------- Inhabited sentience/share square -------------------------------------------------------------------------- -/ inductive SquareCase | agent | ordinary | terminus | insentientAppropriation | stone | response | ordinaryOccurrence | terminusOccurrence | insentientAppropriationOccurrence | stoneOccurrence deriving DecidableEq abbrev SquareCall := SquareCase def squareOccurrenceOfCall : SquareCase → SquareCase | .ordinary => .ordinaryOccurrence | .terminus => .terminusOccurrence | .insentientAppropriation => .insentientAppropriationOccurrence | .stone => .stoneOccurrence | _ => .ordinaryOccurrence def squareCallOfOccurrence : SquareCase → SquareCase | .ordinaryOccurrence => .ordinary | .terminusOccurrence => .terminus | .insentientAppropriationOccurrence => .insentientAppropriation | .stoneOccurrence => .stone | d => d def squareOccurrence : OccurrenceReading SquareCase where occurrence | .ordinaryOccurrence | .terminusOccurrence | .insentientAppropriationOccurrence | .stoneOccurrence => True | _ => False isBeing d := d = .agent isCall d := d = .ordinary ∨ d = .terminus ∨ d = .insentientAppropriation ∨ d = .stone isResponse d := d = .response agent | .ordinaryOccurrence | .terminusOccurrence | .insentientAppropriationOccurrence | .stoneOccurrence => .agent | d => d call := squareCallOfOccurrence response | .ordinaryOccurrence | .terminusOccurrence | .insentientAppropriationOccurrence | .stoneOccurrence => .response | d => d def sentienceSquareGrid : CoreReadings SquareCase Nat where occurrence := squareOccurrence response := { respondsTo := fun b c => match b, c with | .agent, .ordinary | .agent, .terminus | .agent, .insentientAppropriation | .agent, .stone => some .response | _, _ => none } placement := { grade := fun d => match d with | .ordinaryOccurrence | .insentientAppropriationOccurrence => 1 | _ => 0 } conditioning := { conditions := fun _ _ => True } def sentienceSquareReading : sentienceSquareGrid.SentienceReading where sentient d := match d with | .ordinaryOccurrence | .terminusOccurrence => True | _ => False def squareWeld (c : SquareCall) : sentienceSquareGrid.Weld := by refine ⟨squareOccurrenceOfCall c, ?_⟩ cases c <;> trivial theorem square_ordinary : sentienceSquareGrid.OrdinaryAct sentienceSquareReading (squareWeld .ordinary) := by refine ⟨⟨rfl, True.intro⟩, ?_⟩ exact Nat.not_succ_le_zero 0 theorem square_terminus : sentienceSquareGrid.TerminusAct sentienceSquareReading (squareWeld .terminus) := ⟨⟨rfl, True.intro⟩, Nat.le_refl 0⟩ theorem square_insentientAppropriation : sentienceSquareGrid.InsentientAppropriation sentienceSquareReading (squareWeld .insentientAppropriation) := by refine ⟨⟨rfl, fun h => h⟩, ?_⟩ exact Nat.not_succ_le_zero 0 theorem square_stone : sentienceSquareGrid.StoneAct sentienceSquareReading (squareWeld .stone) := ⟨⟨rfl, fun h => h⟩, Nat.le_refl 0⟩ theorem sentience_share_square_inhabited : (∃ w, sentienceSquareGrid.OrdinaryAct sentienceSquareReading w) ∧ (∃ w, sentienceSquareGrid.TerminusAct sentienceSquareReading w) ∧ (∃ w, sentienceSquareGrid.InsentientAppropriation sentienceSquareReading w) ∧ (∃ w, sentienceSquareGrid.StoneAct sentienceSquareReading w) := ⟨⟨squareWeld .ordinary, square_ordinary⟩, ⟨squareWeld .terminus, square_terminus⟩, ⟨squareWeld .insentientAppropriation, square_insentientAppropriation⟩, ⟨squareWeld .stone, square_stone⟩⟩ /- -------------------------------------------------------------------------- Register clock -------------------------------------------------------------------------- -/ inductive RegisterCase | register (n : Nat) | tick | result (n : Nat) | occurrence (n : Nat) deriving DecidableEq def registerOccurrence : OccurrenceReading RegisterCase where occurrence | .occurrence _ => True | _ => False isBeing | .register _ => True | _ => False isCall d := d = .tick isResponse | .result _ => True | _ => False agent | .occurrence n => .register n | d => d call | .occurrence _ => .tick | d => d response | .occurrence n => .result (n + 1) | d => d def registerClockGrid : CoreReadings RegisterCase Nat where occurrence := registerOccurrence response := { respondsTo := fun b c => match b, c with | .register n, .tick => some (.result (n + 1)) | _, _ => none } placement := { grade := fun d => match d with | .occurrence n => n | _ => 0 } conditioning := { conditions := fun deed reception => match deed, reception with | .occurrence n, .occurrence m => m = n + 1 | _, _ => False } def registerWeld (n : Nat) : registerClockGrid.Weld := ⟨.occurrence n, True.intro⟩ def registerClockCoarsening : Grid.DirectedConvention.BeingConvention.BeingCoarsening registerClockGrid Unit where proj _ := () theorem registerClock_macro_actualFiberInhabited : registerClockCoarsening.ActualFiberInhabited () := ⟨registerWeld 0, rfl, rfl⟩ theorem registerClock_macro_not_sentientTag_insentient : ¬ registerClockCoarsening.SentientTag (Grid.SentienceReading.allInsentient registerClockGrid) () := registerClockCoarsening.allInsentient_not_sentientTag () theorem registerClock_macro_not_stoneTag_insentient : ¬ registerClockCoarsening.StoneTag (Grid.SentienceReading.allInsentient registerClockGrid) () := by intro hstone have hbot := (hstone.right (registerWeld 2) rfl rfl).right exact (by decide : ¬ (2 : Nat) ≤ 0) hbot theorem registerClock_macro_patchy : registerClockCoarsening.Patchy () := by constructor · intro hpole have hbot := hpole (registerWeld 2) rfl rfl exact (by decide : ¬ (2 : Nat) ≤ 0) hbot · intro hselfApt have hlive := hselfApt (registerWeld 0) rfl rfl exact hlive (Nat.le_refl 0) theorem registerClock_macro_selfConditioning : registerClockCoarsening.SelfConditioningTag () := by refine ⟨registerWeld 0, registerWeld 1, rfl, rfl, rfl, ?_⟩ rfl theorem registerClock_insentient_proficient : ¬ registerClockCoarsening.SentientTag (Grid.SentienceReading.allInsentient registerClockGrid) () ∧ registerClockCoarsening.ActualFiberInhabited () ∧ registerClockCoarsening.SelfConditioningTag () ∧ registerClockCoarsening.Patchy () := ⟨registerClock_macro_not_sentientTag_insentient, registerClock_macro_actualFiberInhabited, registerClock_macro_selfConditioning, registerClock_macro_patchy⟩ theorem registerClock_rung_readings_split : registerClockGrid.InsentientAppropriation (Grid.SentienceReading.allInsentient registerClockGrid) (registerWeld 2) ∧ registerClockGrid.OrdinaryAct (Grid.SentienceReading.allSentient registerClockGrid) (registerWeld 2) := by have hsplit := registerClockGrid.actual_weld_readings_split (registerWeld 2) rfl have hlive : registerClockGrid.HasSelfPoleIndex (registerWeld 2) := by exact (by decide : ¬ (2 : Nat) ≤ 0) exact ⟨⟨hsplit.right, hlive⟩, ⟨hsplit.left, hlive⟩⟩ /- -------------------------------------------------------------------------- Source and receiver -------------------------------------------------------------------------- -/ inductive SourceReceiverCase | clock | receiver | call | response | clockOccurrence | receiverOccurrence deriving DecidableEq abbrev SourceReceiver := SourceReceiverCase namespace SourceReceiver abbrev clock : SourceReceiverCase := .clock abbrev receiver : SourceReceiverCase := .receiver end SourceReceiver def sourceReceiverOccurrence : OccurrenceReading SourceReceiverCase where occurrence | .clockOccurrence | .receiverOccurrence => True | _ => False isBeing d := d = .clock ∨ d = .receiver isCall d := d = .call isResponse d := d = .response agent | .clockOccurrence => .clock | .receiverOccurrence => .receiver | d => d call | .clockOccurrence | .receiverOccurrence => .call | d => d response | .clockOccurrence | .receiverOccurrence => .response | d => d def sourceReceiverGrid : CoreReadings SourceReceiverCase Nat where occurrence := sourceReceiverOccurrence response := { respondsTo := fun b c => if (b = .clock ∨ b = .receiver) ∧ c = .call then some .response else none } placement := { grade := fun d => match d with | .receiverOccurrence => 1 | _ => 0 } conditioning := { conditions := fun deed reception => deed = .clockOccurrence ∧ reception = .receiverOccurrence } def sourceReceiverCoarsening : Grid.DirectedConvention.BeingConvention.BeingCoarsening sourceReceiverGrid SourceReceiver := Grid.DirectedConvention.BeingConvention.BeingCoarsening.id sourceReceiverGrid def sourceReceiverReading : sourceReceiverGrid.SentienceReading where sentient d := d = .receiverOccurrence def sourceReceiverDeed : sourceReceiverGrid.Weld := ⟨.clockOccurrence, True.intro⟩ def sourceReceiverReception : sourceReceiverGrid.Weld := ⟨.receiverOccurrence, True.intro⟩ def sourceReceiverBefore : Config Nat := { tendency := 5 } theorem insentient_source_shareDropLanding : ¬ sourceReceiverCoarsening.SentientTag sourceReceiverReading SourceReceiver.clock ∧ sourceReceiverCoarsening.SentientTag sourceReceiverReading SourceReceiver.receiver ∧ Grid.DirectedConvention.LandsWithShareDrop sourceReceiverGrid sourceReceiverBefore sourceReceiverDeed sourceReceiverReception := by constructor · rintro ⟨w, ⟨_hactual, hmarked⟩, hfiber⟩ rcases w with ⟨d, hd⟩ change d = SourceReceiverCase.receiverOccurrence at hmarked subst d cases hfiber · constructor · exact ⟨sourceReceiverReception, ⟨rfl, rfl⟩, rfl⟩ · refine ⟨⟨?_, rfl⟩, ?_⟩ · exact ⟨rfl, rfl⟩ · exact ⟨(by decide : (1 : Nat) ≤ 5), (by decide : ¬ (5 : Nat) ≤ 1)⟩ /- -------------------------------------------------------------------------- Backsliding -------------------------------------------------------------------------- -/ inductive BackslideCase | agent | gentle | harsh | response | gentleOccurrence | harshOccurrence deriving DecidableEq abbrev Cue := BackslideCase def backslideOccurrence : OccurrenceReading BackslideCase where occurrence | .gentleOccurrence | .harshOccurrence => True | _ => False isBeing d := d = .agent isCall d := d = .gentle ∨ d = .harsh isResponse d := d = .response agent | .gentleOccurrence | .harshOccurrence => .agent | d => d call | .gentleOccurrence => .gentle | .harshOccurrence => .harsh | d => d response | .gentleOccurrence | .harshOccurrence => .response | d => d def backslideGrid : CoreReadings BackslideCase Nat where occurrence := backslideOccurrence response := { respondsTo := fun b c => if b = .agent ∧ (c = .gentle ∨ c = .harsh) then some .response else none } placement := { grade := fun d => match d with | .harshOccurrence => 5 | _ => 0 } conditioning := { conditions := fun _ _ => True } def backslideWeld (c : Cue) : backslideGrid.Weld := by cases c with | gentle => exact ⟨.gentleOccurrence, True.intro⟩ | harsh => exact ⟨.harshOccurrence, True.intro⟩ | _ => exact ⟨.gentleOccurrence, True.intro⟩ /- -------------------------------------------------------------------------- Placement and share collisions -------------------------------------------------------------------------- -/ inductive GradingCollisionCase | left | right | call | response | leftOccurrence | rightOccurrence deriving DecidableEq abbrev GradingCollisionBeing := GradingCollisionCase def gradingCollisionOccurrence : OccurrenceReading GradingCollisionCase where occurrence | .leftOccurrence | .rightOccurrence => True | _ => False isBeing d := d = .left ∨ d = .right isCall d := d = .call isResponse d := d = .response agent | .leftOccurrence => .left | .rightOccurrence => .right | d => d call | .leftOccurrence | .rightOccurrence => .call | d => d response | .leftOccurrence | .rightOccurrence => .response | d => d def gradingCollisionGrid : CoreReadings GradingCollisionCase Nat where occurrence := gradingCollisionOccurrence response := { respondsTo := fun b c => if (b = .left ∨ b = .right) ∧ c = .call then some .response else none } placement := { grade := fun d => match d with | .leftOccurrence => 5 | _ => 0 } conditioning := { conditions := fun _ _ => True } def gradingCollisionLeft : gradingCollisionGrid.Weld := ⟨.leftOccurrence, True.intro⟩ def gradingCollisionRight : gradingCollisionGrid.Weld := ⟨.rightOccurrence, True.intro⟩ inductive ShareCollisionCase | left | right | call | response | leftOccurrence | rightOccurrence deriving DecidableEq abbrev ShareCollisionBeing := ShareCollisionCase def shareCollisionOccurrence : OccurrenceReading ShareCollisionCase where occurrence | .leftOccurrence | .rightOccurrence => True | _ => False isBeing d := d = .left ∨ d = .right isCall d := d = .call isResponse d := d = .response agent | .leftOccurrence => .left | .rightOccurrence => .right | d => d call | .leftOccurrence | .rightOccurrence => .call | d => d response | .leftOccurrence | .rightOccurrence => .response | d => d def shareCollisionGrid : CoreReadings ShareCollisionCase Nat where occurrence := shareCollisionOccurrence response := { respondsTo := fun b c => if (b = .left ∨ b = .right) ∧ c = .call then some .response else none } placement := { grade := fun d => match d with | .leftOccurrence | .rightOccurrence => 3 | _ => 0 } conditioning := { conditions := fun _ _ => True } def shareCollisionLeft : shareCollisionGrid.Weld := ⟨.leftOccurrence, True.intro⟩ def shareCollisionRight : shareCollisionGrid.Weld := ⟨.rightOccurrence, True.intro⟩ end Preview end KannoSoe ===== FILE: KannoSoe/Signature/Order.lean ===== /- ================================================================================ KannoSoe.Signature.Order Dependency-free preorder infrastructure ================================================================================ Reading and motivation: Identification/Commentary.lean, C.1. -/ namespace KannoSoe universe u variable {α : Type u} /- ============================================================================== §0 Dependency-free preorder infrastructure ============================================================================== -/ /-- A bare preorder, rolled by hand and not assumed total or antisymmetric. -/ class Preorder (α : Type u) 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 u) [Preorder α] : Prop := ∀ a b : α, ¬ Strict a b /- Reading and motivation: Identification/Commentary.lean, C.1. -/ class PreorderBot (α : Type u) 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 KannoSoe ===== FILE: KannoSoe/Signature/Readings.lean ===== /- ================================================================================ KannoSoe.Signature.Readings Independent readings over a common designatum carrier ================================================================================ This module is the draft-3c substrate. A model supplies one carrier of designata. Occurrences are selected from that carrier, and their agent, call, and response faces are readings of the occurrence designatum rather than primitive carrier coordinates. Actuality, placement, conditioning, and sentience remain independent readings. -/ import KannoSoe.Signature.Order namespace KannoSoe universe u v variable {Designatum : Type u} {Contrib : Type v} /-- The occurrence and role reading over a common carrier of designata. -/ @[ext] structure OccurrenceReading (Designatum : Type u) where occurrence : Designatum → Prop isBeing : Designatum → Prop isCall : Designatum → Prop isResponse : Designatum → Prop agent : Designatum → Designatum call : Designatum → Designatum response : Designatum → Designatum namespace OccurrenceReading /-- A weld is a designatum selected by an occurrence reading. -/ abbrev Weld (O : OccurrenceReading Designatum) := { d : Designatum // O.occurrence d } /- `OccurrenceReading.Weld` is intentionally a subtype. Field notation for a subtype is resolved through the root `Subtype` namespace, so these narrowly typed helpers make `w.agent`, `w.call`, and `w.response` available without turning weld back into a primitive record. -/ def _root_.Subtype.agent {Designatum : Type u} {O : OccurrenceReading Designatum} (w : O.Weld) : Designatum := O.agent w.1 def _root_.Subtype.call {Designatum : Type u} {O : OccurrenceReading Designatum} (w : O.Weld) : Designatum := O.call w.1 def _root_.Subtype.response {Designatum : Type u} {O : OccurrenceReading Designatum} (w : O.Weld) : Designatum := O.response w.1 namespace Weld variable {Designatum : Type u} {O : OccurrenceReading Designatum} /-- The agent face read from an occurrence designatum. -/ def agent (w : O.Weld) : Designatum := O.agent w.1 /-- The call face read from an occurrence designatum. -/ def call (w : O.Weld) : Designatum := O.call w.1 /-- The response face read from an occurrence designatum. -/ def response (w : O.Weld) : Designatum := O.response w.1 @[simp] theorem coe_mk (d : Designatum) (h : O.occurrence d) : ((⟨d, h⟩ : O.Weld) : Designatum) = d := rfl @[simp] theorem agent_mk (d : Designatum) (h : O.occurrence d) : (⟨d, h⟩ : O.Weld).agent = O.agent d := rfl @[simp] theorem call_mk (d : Designatum) (h : O.occurrence d) : (⟨d, h⟩ : O.Weld).call = O.call d := rfl @[simp] theorem response_mk (d : Designatum) (h : O.occurrence d) : (⟨d, h⟩ : O.Weld).response = O.response d := rfl end Weld /-- Swap the call and response readings while retaining the occurrence carrier, occurrence predicate, and agent reading. -/ def transposeCR (O : OccurrenceReading Designatum) : OccurrenceReading Designatum where occurrence := O.occurrence isBeing := O.isBeing isCall := O.isResponse isResponse := O.isCall agent := O.agent call := O.response response := O.call @[simp] theorem transposeCR_occurrence (O : OccurrenceReading Designatum) (d : Designatum) : O.transposeCR.occurrence d ↔ O.occurrence d := Iff.rfl @[simp] theorem transposeCR_agent (O : OccurrenceReading Designatum) (d : Designatum) : O.transposeCR.agent d = O.agent d := rfl @[simp] theorem transposeCR_call (O : OccurrenceReading Designatum) (d : Designatum) : O.transposeCR.call d = O.response d := rfl @[simp] theorem transposeCR_response (O : OccurrenceReading Designatum) (d : Designatum) : O.transposeCR.response d = O.call d := rfl @[simp] theorem transposeCR_transposeCR (O : OccurrenceReading Designatum) : O.transposeCR.transposeCR = O := rfl /-- Re-read a weld under call/response transposition. The occurrence designatum itself is unchanged. -/ def Weld.transposeCR {O : OccurrenceReading Designatum} (w : O.Weld) : O.transposeCR.Weld := ⟨w.1, w.2⟩ @[simp] theorem Weld.transposeCR_agent {O : OccurrenceReading Designatum} (w : O.Weld) : w.transposeCR.agent = w.agent := rfl @[simp] theorem Weld.transposeCR_call {O : OccurrenceReading Designatum} (w : O.Weld) : w.transposeCR.call = w.response := rfl @[simp] theorem Weld.transposeCR_response {O : OccurrenceReading Designatum} (w : O.Weld) : w.transposeCR.response = w.call := rfl @[simp] theorem Weld.transposeCR_transposeCR {O : OccurrenceReading Designatum} (w : O.Weld) : w.transposeCR.transposeCR = w := rfl end OccurrenceReading /-- The supplied response rule. `Option` keeps partial response semantics independent from the carrier migration. -/ @[ext] structure RespondsToReading (Designatum : Type u) where respondsTo : Designatum → Designatum → Option Designatum /-- A supplied placement of every designatum in the contribution display. -/ @[ext] structure PlacementReading (Designatum : Type u) (Contrib : Type v) where grade : Designatum → Contrib /-- A supplied conditioning relation between designata. -/ @[ext] structure ConditionsReading (Designatum : Type u) where conditions : Designatum → Designatum → Prop namespace ConditionsReading /-- Reverse only the conditioning relation. -/ def transpose (C : ConditionsReading Designatum) : ConditionsReading Designatum where conditions d₁ d₂ := C.conditions d₂ d₁ @[simp] theorem transpose_conditions (C : ConditionsReading Designatum) (d₁ d₂ : Designatum) : C.transpose.conditions d₁ d₂ ↔ C.conditions d₂ d₁ := Iff.rfl @[simp] theorem transpose_transpose (C : ConditionsReading Designatum) : C.transpose.transpose = C := rfl end ConditionsReading /-- A supplied sentience marking on designata. Occurrence-level definitions apply it to the occurrence designatum itself. -/ @[ext] structure SentienceReading (Designatum : Type u) where sentient : Designatum → Prop namespace SentienceReading def allSentient (Designatum : Type u) : SentienceReading Designatum where sentient _ := True def allInsentient (Designatum : Type u) : SentienceReading Designatum where sentient _ := False end SentienceReading /-- A convenience package for concrete models. The readings remain independently usable, and derived definitions below accept only their actual dependencies. -/ @[ext] structure CoreReadings (Designatum : Type u) (Contrib : Type v) where occurrence : OccurrenceReading Designatum response : RespondsToReading Designatum placement : PlacementReading Designatum Contrib conditioning : ConditionsReading Designatum /- -------------------------------------------------------------------------- Derived definitions with explanatory dependencies -------------------------------------------------------------------------- -/ /-- An occurrence is actual when its response reading agrees with the occurrence's three role faces. -/ def Actual (O : OccurrenceReading Designatum) (R : RespondsToReading Designatum) (w : O.Weld) : Prop := R.respondsTo w.agent w.call = some w.response /-- The contribution assigned directly to an occurrence designatum. -/ def share (O : OccurrenceReading Designatum) (P : PlacementReading Designatum Contrib) (w : O.Weld) : Contrib := P.grade w.1 /-- Whether a supplied response rule mounts some response at an agent/call pair. -/ def MountsAt (R : RespondsToReading Designatum) (b c : Designatum) : Prop := ∃ r, R.respondsTo b c = some r /-- Delivery supplied independently by a conditioning reading. -/ def DeliveredTo (O : OccurrenceReading Designatum) (C : ConditionsReading Designatum) (deed reception : O.Weld) : Prop := C.conditions deed.1 reception.1 /-- An actual occurrence marked sentient by a supplied reading. -/ def SentientAct (O : OccurrenceReading Designatum) (R : RespondsToReading Designatum) (S : SentienceReading Designatum) (w : O.Weld) : Prop := Actual O R w ∧ S.sentient w.1 /-- An actual occurrence not marked sentient by a supplied reading. -/ def InsentientAct (O : OccurrenceReading Designatum) (R : RespondsToReading Designatum) (S : SentienceReading Designatum) (w : O.Weld) : Prop := Actual O R w ∧ ¬ S.sentient w.1 /-- The sentient, live-self-share cell of the act square. -/ def OrdinaryAct [PreorderBot Contrib] (O : OccurrenceReading Designatum) (R : RespondsToReading Designatum) (P : PlacementReading Designatum Contrib) (S : SentienceReading Designatum) (w : O.Weld) : Prop := SentientAct O R S w ∧ ¬ AtBot (share O P w) /-- The sentient, pole-share cell of the act square. -/ def TerminusAct [PreorderBot Contrib] (O : OccurrenceReading Designatum) (R : RespondsToReading Designatum) (P : PlacementReading Designatum Contrib) (S : SentienceReading Designatum) (w : O.Weld) : Prop := SentientAct O R S w ∧ AtBot (share O P w) /-- The insentient, live-self-share cell of the act square. -/ def InsentientAppropriation [PreorderBot Contrib] (O : OccurrenceReading Designatum) (R : RespondsToReading Designatum) (P : PlacementReading Designatum Contrib) (S : SentienceReading Designatum) (w : O.Weld) : Prop := InsentientAct O R S w ∧ ¬ AtBot (share O P w) /-- The insentient, pole-share cell of the act square. -/ def StoneAct [PreorderBot Contrib] (O : OccurrenceReading Designatum) (R : RespondsToReading Designatum) (P : PlacementReading Designatum Contrib) (S : SentienceReading Designatum) (w : O.Weld) : Prop := InsentientAct O R S w ∧ AtBot (share O P w) end KannoSoe ===== FILE: KannoSoe/Signature/SentienceConvention.lean ===== /- ================================================================================ KannoSoe.Signature.SentienceConvention Supplied sentience readings over occurrence designata ================================================================================ -/ import KannoSoe.Signature.Grid namespace KannoSoe universe u v namespace Grid variable {Designatum : Type u} {Contrib : Type v} variable [PreorderBot Contrib] variable (G : CoreReadings Designatum Contrib) /-- Compatibility specialization of the independent sentience reading. -/ abbrev SentienceReading (_G : CoreReadings Designatum Contrib) := KannoSoe.SentienceReading Designatum namespace SentienceReading variable {G : CoreReadings Designatum Contrib} def allSentient (G : CoreReadings Designatum Contrib) : SentienceReading G := KannoSoe.SentienceReading.allSentient Designatum def allInsentient (G : CoreReadings Designatum Contrib) : SentienceReading G := KannoSoe.SentienceReading.allInsentient Designatum /-- Conditioning transposition does not alter sentience. -/ def transpose (S : SentienceReading G) : SentienceReading (Grid.transpose G) := S omit [PreorderBot Contrib] in @[simp] theorem transpose_sentient (S : SentienceReading G) (w : Grid.Weld G) : S.transpose.sentient w.1 ↔ S.sentient w.1 := Iff.rfl end SentienceReading def SentientAct (S : SentienceReading G) (w : Weld G) : Prop := KannoSoe.SentientAct G.occurrence G.response S w def InsentientAct (S : SentienceReading G) (w : Weld G) : Prop := KannoSoe.InsentientAct G.occurrence G.response S w def OrdinaryAct (S : SentienceReading G) (w : Weld G) : Prop := KannoSoe.OrdinaryAct G.occurrence G.response G.placement S w def TerminusAct (S : SentienceReading G) (w : Weld G) : Prop := KannoSoe.TerminusAct G.occurrence G.response G.placement S w def InsentientAppropriation (S : SentienceReading G) (w : Weld G) : Prop := KannoSoe.InsentientAppropriation G.occurrence G.response G.placement S w def StoneAct (S : SentienceReading G) (w : Weld G) : Prop := KannoSoe.StoneAct G.occurrence G.response G.placement S w omit [PreorderBot Contrib] in theorem actual_of_sentientAct {S : SentienceReading G} {w : Weld G} (h : SentientAct G S w) : Actual G w := h.left omit [PreorderBot Contrib] in theorem actual_of_insentientAct {S : SentienceReading G} {w : Weld G} (h : InsentientAct G S w) : Actual G w := h.left omit [PreorderBot Contrib] in theorem not_insentientAct_of_sentientAct {S : SentienceReading G} {w : Weld G} (h : SentientAct G S w) : ¬ InsentientAct G S w := fun hi => hi.right h.right omit [PreorderBot Contrib] in theorem not_sentientAct_of_insentientAct {S : SentienceReading G} {w : Weld G} (h : InsentientAct G S w) : ¬ SentientAct G S w := fun hs => h.right hs.right theorem actual_act_fourfold (S : SentienceReading G) (w : Weld G) [Decidable (S.sentient w.1)] [Decidable (AtBot (share G w))] (hactual : Actual G w) : OrdinaryAct G S w ∨ TerminusAct G S w ∨ InsentientAppropriation G S w ∨ StoneAct G S w := by by_cases hsentient : S.sentient w.1 · by_cases hpole : AtBot (share G w) · exact Or.inr (Or.inl ⟨⟨hactual, hsentient⟩, hpole⟩) · exact Or.inl ⟨⟨hactual, hsentient⟩, hpole⟩ · by_cases hpole : AtBot (share G w) · exact Or.inr (Or.inr (Or.inr ⟨⟨hactual, hsentient⟩, hpole⟩)) · exact Or.inr (Or.inr (Or.inl ⟨⟨hactual, hsentient⟩, hpole⟩)) /-- The non-sentience readings visible to a would-be recovery function. -/ abbrev SentienceGridData (_G : CoreReadings Designatum Contrib) : Type (max u v) := RespondsToReading Designatum × PlacementReading Designatum Contrib × ConditionsReading Designatum def sentienceGridData : SentienceGridData G := (G.response, G.placement, G.conditioning) omit [PreorderBot Contrib] in theorem actual_weld_readings_split (w : Weld G) (hactual : Actual G w) : SentientAct G (SentienceReading.allSentient G) w ∧ InsentientAct G (SentienceReading.allInsentient G) w := ⟨⟨hactual, True.intro⟩, ⟨hactual, fun h => h⟩⟩ omit [PreorderBot Contrib] in theorem no_sentience_recovery (w : Weld G) (hactual : Actual G w) : ¬ ∃ recover : SentienceGridData G → Weld G → Prop, recover (sentienceGridData G) = SentientAct G (SentienceReading.allSentient G) ∧ recover (sentienceGridData G) = SentientAct G (SentienceReading.allInsentient G) := by rintro ⟨recover, hall, hnone⟩ have hsplit := actual_weld_readings_split G w hactual have htrue : recover (sentienceGridData G) w := by rw [hall] exact hsplit.left have hfalse : ¬ recover (sentienceGridData G) w := by rw [hnone] exact not_sentientAct_of_insentientAct G hsplit.right exact hfalse htrue end Grid namespace CoreReadings variable {Designatum : Type u} {Contrib : Type v} variable [PreorderBot Contrib] abbrev SentienceReading (G : CoreReadings Designatum Contrib) := Grid.SentienceReading G abbrev SentientAct (G : CoreReadings Designatum Contrib) := Grid.SentientAct G abbrev InsentientAct (G : CoreReadings Designatum Contrib) := Grid.InsentientAct G abbrev OrdinaryAct (G : CoreReadings Designatum Contrib) := Grid.OrdinaryAct G abbrev TerminusAct (G : CoreReadings Designatum Contrib) := Grid.TerminusAct G abbrev InsentientAppropriation (G : CoreReadings Designatum Contrib) := Grid.InsentientAppropriation G abbrev StoneAct (G : CoreReadings Designatum Contrib) := Grid.StoneAct G abbrev actual_of_sentientAct (G : CoreReadings Designatum Contrib) {S : G.SentienceReading} {w : G.Weld} (h : G.SentientAct S w) := Grid.actual_of_sentientAct G h abbrev actual_of_insentientAct (G : CoreReadings Designatum Contrib) {S : G.SentienceReading} {w : G.Weld} (h : G.InsentientAct S w) := Grid.actual_of_insentientAct G h abbrev not_insentientAct_of_sentientAct (G : CoreReadings Designatum Contrib) {S : G.SentienceReading} {w : G.Weld} (h : G.SentientAct S w) := Grid.not_insentientAct_of_sentientAct G h abbrev not_sentientAct_of_insentientAct (G : CoreReadings Designatum Contrib) {S : G.SentienceReading} {w : G.Weld} (h : G.InsentientAct S w) := Grid.not_sentientAct_of_insentientAct G h abbrev actual_act_fourfold (G : CoreReadings Designatum Contrib) := Grid.actual_act_fourfold G abbrev SentienceGridData (G : CoreReadings Designatum Contrib) := Grid.SentienceGridData G abbrev sentienceGridData (G : CoreReadings Designatum Contrib) := Grid.sentienceGridData G abbrev actual_weld_readings_split (G : CoreReadings Designatum Contrib) := Grid.actual_weld_readings_split G abbrev no_sentience_recovery (G : CoreReadings Designatum Contrib) := Grid.no_sentience_recovery G end CoreReadings end KannoSoe ===== FILE: KannoSoe/Signature/V2.lean ===== import Std /-! # Mutual dependence, resonance, and direction Raw types describe component structures without asserting that their linkages hold. Certified types pair those descriptions with proofs, while `Elaboration` targets raw mutual dependences so it can remain agnostic about the validity of its targets. A linkage derived from an elaboration (`Linkage.ofElaboration E`) cannot appear inside the targets of `E`'s own definition; see `Elaboration.certify` and `Elaboration.SelfCertified`. Direction/causality is an additional interpretation a domain may carry, not something mutual dependence or resonance asserts or requires. -/ universe u v /-! ## Components -/ structure Component (D : Type u) where carrier : D → Prop nonempty : ∃ d, carrier d instance {D : Type u} : Membership D (Component D) := ⟨fun a d => a.carrier d⟩ instance {D : Type u} : CoeFun (Component D) (fun _ => D → Prop) := ⟨Component.carrier⟩ namespace Component def singleton {D : Type u} (d : D) : Component D where carrier := fun x => x = d nonempty := ⟨d, rfl⟩ @[simp] theorem mem_singleton_iff {D : Type u} {d x : D} : x ∈ singleton d ↔ x = d := Iff.rfl theorem exists_mem {D : Type u} (a : Component D) : ∃ d, d ∈ a := a.nonempty end Component /-! ## Linkage -/ structure Linkage (D : Type u) where Linked : Component D → Component D → Prop symm : ∀ {c₁ c₂}, Linked c₁ c₂ → Linked c₂ c₁ namespace Linkage inductive ChainLinked {D : Type u} (L : Linkage D) : List (Component D) → Prop where | nil : ChainLinked L [] | single (c₁ : Component D) : ChainLinked L [c₁] | cons {c₁ c₂ : Component D} {rest : List (Component D)} (h₁₂ : L.Linked c₁ c₂) (h : ChainLinked L (c₂ :: rest)) : ChainLinked L (c₁ :: c₂ :: rest) theorem ChainLinked.tail {D : Type u} {L : Linkage D} {c₁ : Component D} {l : List (Component D)} (h : L.ChainLinked (c₁ :: l)) : L.ChainLinked l := by cases h with | single _ => exact ChainLinked.nil | cons _ h => exact h theorem ChainLinked.of_append_right {D : Type u} {L : Linkage D} : ∀ (l₁ : List (Component D)) {l₂ : List (Component D)}, L.ChainLinked (l₁ ++ l₂) → L.ChainLinked l₂ | [], _, h => h | c₁ :: rest, l₂, h => by rw [List.cons_append] at h exact ChainLinked.of_append_right rest h.tail theorem ChainLinked.of_append_left {D : Type u} {L : Linkage D} : ∀ (l₁ l₂ : List (Component D)), L.ChainLinked (l₁ ++ l₂) → L.ChainLinked l₁ | [], _, _ => ChainLinked.nil | [c₁], _, _ => ChainLinked.single c₁ | c₁ :: c₂ :: rest, l₂, h => by rw [List.cons_append, List.cons_append] at h cases h with | cons h₁₂ h => refine ChainLinked.cons h₁₂ (ChainLinked.of_append_left (c₂ :: rest) l₂ ?_) rw [List.cons_append] exact h theorem ChainLinked.glue {D : Type u} {L : Linkage D} : ∀ {l₁ : List (Component D)} {cₙ : Component D} {l₂ : List (Component D)}, L.ChainLinked (l₁ ++ [cₙ]) → L.ChainLinked (cₙ :: l₂) → L.ChainLinked (l₁ ++ cₙ :: l₂) := by intro l₁ cₙ l₂ hleft hright induction l₁ with | nil => exact hright | cons c₁ rest ih => cases rest with | nil => change L.ChainLinked [c₁, cₙ] at hleft cases hleft with | cons h₁ₙ _ => exact .cons h₁ₙ hright | cons c₂ rest => change L.ChainLinked (c₁ :: c₂ :: rest ++ [cₙ]) at hleft cases hleft with | cons h₁₂ htail => exact .cons h₁₂ (ih htail) end Linkage /-! ## Raw mutual dependence: data only -/ /-- Components plus their linkage, as pure data (1:1: each value carries exactly one linkage). At least two components by construction. This type makes no assertion; `RawMutualDependence.Holds` states it, and `MutualDependence` below bundles the proof. -/ structure RawMutualDependence (D : Type u) where linkage : Linkage D c₁ : Component D middle : List (Component D) cₙ : Component D namespace RawMutualDependence def components {D : Type u} (rawM : RawMutualDependence D) : List (Component D) := rawM.c₁ :: rawM.middle ++ [rawM.cₙ] /-- The assertion: every two adjacent components are accepted by the bundled linkage. -/ def Holds {D : Type u} (rawM : RawMutualDependence D) : Prop := rawM.linkage.ChainLinked rawM.components def pair {D : Type u} (L : Linkage D) (c₁ c₂ : Component D) : RawMutualDependence D := ⟨L, c₁, [], c₂⟩ def triple {D : Type u} (L : Linkage D) (c₁ c₂ c₃ : Component D) : RawMutualDependence D := ⟨L, c₁, [c₂], c₃⟩ def quad {D : Type u} (L : Linkage D) (c₁ c₂ c₃ c₄ : Component D) : RawMutualDependence D := ⟨L, c₁, [c₂, c₃], c₄⟩ @[simp] theorem linkage_pair {D : Type u} (L : Linkage D) (c₁ c₂ : Component D) : (pair L c₁ c₂).linkage = L := rfl @[simp] theorem components_pair {D : Type u} (L : Linkage D) (c₁ c₂ : Component D) : (pair L c₁ c₂).components = [c₁, c₂] := rfl @[simp] theorem components_triple {D : Type u} (L : Linkage D) (c₁ c₂ c₃ : Component D) : (triple L c₁ c₂ c₃).components = [c₁, c₂, c₃] := rfl @[simp] theorem components_quad {D : Type u} (L : Linkage D) (c₁ c₂ c₃ c₄ : Component D) : (quad L c₁ c₂ c₃ c₄).components = [c₁, c₂, c₃, c₄] := rfl @[simp] theorem holds_pair_iff {D : Type u} {L : Linkage D} {c₁ c₂ : Component D} : (pair L c₁ c₂).Holds ↔ L.Linked c₁ c₂ := by constructor · intro h have h : L.ChainLinked [c₁, c₂] := h cases h with | cons h₁₂ _ => exact h₁₂ · intro h show L.ChainLinked [c₁, c₂] exact .cons h (.single c₂) @[simp] theorem holds_triple_iff {D : Type u} {L : Linkage D} {c₁ c₂ c₃ : Component D} : (triple L c₁ c₂ c₃).Holds ↔ L.Linked c₁ c₂ ∧ L.Linked c₂ c₃ := by constructor · intro h have h : L.ChainLinked [c₁, c₂, c₃] := h cases h with | cons h₁₂ h => cases h with | cons h₂₃ _ => exact ⟨h₁₂, h₂₃⟩ · intro h show L.ChainLinked [c₁, c₂, c₃] exact .cons h.1 (.cons h.2 (.single c₃)) @[simp] theorem holds_quad_iff {D : Type u} {L : Linkage D} {c₁ c₂ c₃ c₄ : Component D} : (quad L c₁ c₂ c₃ c₄).Holds ↔ L.Linked c₁ c₂ ∧ L.Linked c₂ c₃ ∧ L.Linked c₃ c₄ := by constructor · intro h have h : L.ChainLinked [c₁, c₂, c₃, c₄] := h cases h with | cons h₁₂ h => cases h with | cons h₂₃ h => cases h with | cons h₃₄ _ => exact ⟨h₁₂, h₂₃, h₃₄⟩ · intro h show L.ChainLinked [c₁, c₂, c₃, c₄] exact .cons h.1 (.cons h.2.1 (.cons h.2.2 (.single c₄))) theorem holds_of_contiguous {D : Type u} {whole sub : RawMutualDependence D} {pre suf : List (Component D)} (hL : sub.linkage = whole.linkage) (hdecomp : whole.components = pre ++ sub.components ++ suf) (hw : whole.Holds) : sub.Holds := by have h : whole.linkage.ChainLinked (pre ++ sub.components ++ suf) := by rw [← hdecomp] exact hw show sub.linkage.ChainLinked sub.components rw [hL] exact Linkage.ChainLinked.of_append_right pre (Linkage.ChainLinked.of_append_left _ suf h) def IsResonance {D : Type u} (rawM : RawMutualDependence D) : Prop := ∃ b₁ b₂ : D, rawM.middle = [Component.singleton b₁, Component.singleton b₂] theorem isResonance_quad {D : Type u} (L : Linkage D) (c₁ : Component D) (b₁ b₂ : D) (c₄ : Component D) : (quad L c₁ (Component.singleton b₁) (Component.singleton b₂) c₄).IsResonance := ⟨b₁, b₂, rfl⟩ end RawMutualDependence /-! ## Mutual dependence: data plus proof -/ /-- The certified type downstream code should use: a raw mutual dependence together with the proof that it holds under its own linkage. If most of your linkage proofs are dischargeable by a tactic, give the `holds` field a default (`holds : toRaw.Holds := by your_tactic`) so construction feels field-free at most sites. -/ structure MutualDependence (D : Type u) where toRaw : RawMutualDependence D holds : toRaw.Holds namespace MutualDependence def linkage {D : Type u} (m : MutualDependence D) : Linkage D := m.toRaw.linkage def c₁ {D : Type u} (m : MutualDependence D) : Component D := m.toRaw.c₁ def middle {D : Type u} (m : MutualDependence D) : List (Component D) := m.toRaw.middle def cₙ {D : Type u} (m : MutualDependence D) : Component D := m.toRaw.cₙ def components {D : Type u} (m : MutualDependence D) : List (Component D) := m.toRaw.components /-- Proof irrelevance: equality of certified dependences reduces to equality of the underlying data. -/ theorem ext {D : Type u} {a b : MutualDependence D} (h : a.toRaw = b.toRaw) : a = b := by cases a cases b cases h rfl def pair {D : Type u} (L : Linkage D) (c₁ c₂ : Component D) (h : L.Linked c₁ c₂) : MutualDependence D := ⟨RawMutualDependence.pair L c₁ c₂, RawMutualDependence.holds_pair_iff.mpr h⟩ def triple {D : Type u} (L : Linkage D) (c₁ c₂ c₃ : Component D) (h₁₂ : L.Linked c₁ c₂) (h₂₃ : L.Linked c₂ c₃) : MutualDependence D := ⟨RawMutualDependence.triple L c₁ c₂ c₃, RawMutualDependence.holds_triple_iff.mpr ⟨h₁₂, h₂₃⟩⟩ def quad {D : Type u} (L : Linkage D) (c₁ c₂ c₃ c₄ : Component D) (h₁₂ : L.Linked c₁ c₂) (h₂₃ : L.Linked c₂ c₃) (h₃₄ : L.Linked c₃ c₄) : MutualDependence D := ⟨RawMutualDependence.quad L c₁ c₂ c₃ c₄, RawMutualDependence.holds_quad_iff.mpr ⟨h₁₂, h₂₃, h₃₄⟩⟩ /-- `holds_of_contiguous` as a slicing function: the sub-tuple copies the whole's linkage, so it comes back certified with no side conditions. -/ def slice {D : Type u} (whole : MutualDependence D) (c₁ : Component D) (middle : List (Component D)) (cₙ : Component D) (pre suf : List (Component D)) (hdecomp : whole.toRaw.components = pre ++ (c₁ :: middle ++ [cₙ]) ++ suf) : MutualDependence D := ⟨⟨whole.toRaw.linkage, c₁, middle, cₙ⟩, RawMutualDependence.holds_of_contiguous (whole := whole.toRaw) (sub := ⟨whole.toRaw.linkage, c₁, middle, cₙ⟩) (pre := pre) (suf := suf) rfl hdecomp whole.holds⟩ def mergeSharedEndpoint {D : Type u} (m₁ m₂ : MutualDependence D) (hL : m₁.linkage = m₂.linkage) (hShared : m₁.cₙ = m₂.c₁) : MutualDependence D := by refine ⟨⟨m₁.linkage, m₁.c₁, m₁.middle ++ m₁.cₙ :: m₂.middle, m₂.cₙ⟩, ?_⟩ have h₂ : m₁.linkage.ChainLinked (m₁.cₙ :: m₂.middle ++ [m₂.cₙ]) := by rw [hL, hShared] exact m₂.holds have h := Linkage.ChainLinked.glue (l₁ := m₁.c₁ :: m₁.middle) (cₙ := m₁.cₙ) (l₂ := m₂.middle ++ [m₂.cₙ]) m₁.holds h₂ simpa [MutualDependence.linkage, MutualDependence.c₁, MutualDependence.middle, MutualDependence.cₙ, RawMutualDependence.Holds, RawMutualDependence.components, List.append_assoc] using h def mergeLinkedEndpoints {D : Type u} (m₁ m₂ : MutualDependence D) (hL : m₁.linkage = m₂.linkage) (hJoin : m₁.linkage.Linked m₁.cₙ m₂.c₁) : MutualDependence D := by refine ⟨⟨m₁.linkage, m₁.c₁, m₁.middle ++ [m₁.cₙ, m₂.c₁] ++ m₂.middle, m₂.cₙ⟩, ?_⟩ have h₁₂ : m₁.linkage.ChainLinked (((m₁.c₁ :: m₁.middle) ++ [m₁.cₙ]) ++ [m₂.c₁]) := by simpa [MutualDependence.linkage, MutualDependence.c₁, MutualDependence.middle, MutualDependence.cₙ, List.append_assoc] using (Linkage.ChainLinked.glue (l₁ := m₁.c₁ :: m₁.middle) (cₙ := m₁.cₙ) (l₂ := [m₂.c₁]) m₁.holds (.cons hJoin (.single m₂.c₁))) have h₂ : m₁.linkage.ChainLinked (m₂.c₁ :: m₂.middle ++ [m₂.cₙ]) := by rw [hL] exact m₂.holds have h := Linkage.ChainLinked.glue (l₁ := (m₁.c₁ :: m₁.middle) ++ [m₁.cₙ]) (cₙ := m₂.c₁) (l₂ := m₂.middle ++ [m₂.cₙ]) h₁₂ h₂ simpa [MutualDependence.linkage, MutualDependence.c₁, MutualDependence.middle, MutualDependence.cₙ, RawMutualDependence.Holds, RawMutualDependence.components, List.append_assoc] using h def IsResonance {D : Type u} (m : MutualDependence D) : Prop := m.toRaw.IsResonance end MutualDependence /-! ## Elaboration and relatedness -/ /-- An elaboration system. `Elab d rawM` asserts that designatum `d` *may be elaborated as* the raw mutual dependence `rawM`. `Elaboration` must target `RawMutualDependence`: it constrains the components of its targets and stays agnostic about both the bundled linkage and whether the tuple holds. Requiring targets to carry `Linkage.ofElaboration` of this same elaboration — let alone proofs under it — inside the elaboration's own definition is value-level self-reference; see `certify` and `SelfCertified`. -/ structure Elaboration (D : Type u) where Elab : D → RawMutualDependence D → Prop namespace Elaboration inductive Reaches {D : Type u} (E : Elaboration D) : D → D → Prop where | refl (d : D) : Reaches E d d | step {d e f : D} {rawM : RawMutualDependence D} {a : Component D} (hE : E.Elab d rawM) (ha : a ∈ rawM.components) (he : e ∈ a) (h : Reaches E e f) : Reaches E d f theorem Reaches.trans {D : Type u} {E : Elaboration D} {d e f : D} (h₁ : E.Reaches d e) : E.Reaches e f → E.Reaches d f := by induction h₁ with | refl _ => exact id | step hE ha he _ ih => exact fun h₂ => Reaches.step hE ha he (ih h₂) theorem Reaches.single {D : Type u} {E : Elaboration D} {d e : D} {rawM : RawMutualDependence D} {a : Component D} (hE : E.Elab d rawM) (ha : a ∈ rawM.components) (he : e ∈ a) : E.Reaches d e := Reaches.step hE ha he (Reaches.refl e) def Related {D : Type u} (E : Elaboration D) (a b : D) : Prop := ∃ w, E.Reaches a w ∧ E.Reaches b w theorem Related.refl {D : Type u} (E : Elaboration D) (a : D) : E.Related a a := ⟨a, Reaches.refl a, Reaches.refl a⟩ theorem Related.symm {D : Type u} {E : Elaboration D} {a b : D} (h : E.Related a b) : E.Related b a := by obtain ⟨w, ha, hb⟩ := h exact ⟨w, hb, ha⟩ private inductive RelatedNotTransitiveCase where | a | b | c deriving DecidableEq theorem Related.not_transitive : ∃ (D : Type) (E : Elaboration D), ¬ ∀ ⦃a b c⦄, E.Related a b → E.Related b c → E.Related a c := by let L : Linkage RelatedNotTransitiveCase := { Linked := fun _ _ => True symm := fun _ => trivial } let m : RawMutualDependence RelatedNotTransitiveCase := .pair L (Component.singleton .a) (Component.singleton .c) let E : Elaboration RelatedNotTransitiveCase := ⟨fun d m' => d = .b ∧ m' = m⟩ refine ⟨RelatedNotTransitiveCase, E, ?_⟩ intro htrans have hba : E.Reaches .b .a := Reaches.single (rawM := m) (a := Component.singleton .a) ⟨rfl, rfl⟩ (by simp [m]) rfl have hbc : E.Reaches .b .c := Reaches.single (rawM := m) (a := Component.singleton .c) ⟨rfl, rfl⟩ (by simp [m]) rfl have hab : E.Related .a .b := ⟨RelatedNotTransitiveCase.a, Reaches.refl RelatedNotTransitiveCase.a, hba⟩ have hbc' : E.Related .b .c := ⟨RelatedNotTransitiveCase.c, hbc, Reaches.refl RelatedNotTransitiveCase.c⟩ obtain ⟨w, haw, hcw⟩ := htrans hab hbc' have hwa : w = .a := by cases haw with | refl _ => rfl | step hE _ _ _ => simp [E] at hE have hwc : w = .c := by cases hcw with | refl _ => rfl | step hE _ _ _ => simp [E] at hE exact (by decide : RelatedNotTransitiveCase.a ≠ .c) (hwa.symm.trans hwc) def Linked {D : Type u} (E : Elaboration D) (c₁ c₂ : Component D) : Prop := (∀ a ∈ c₁, ∃ b ∈ c₂, E.Related a b) ∧ (∀ b ∈ c₂, ∃ a ∈ c₁, E.Related a b) theorem Linked.symm {D : Type u} {E : Elaboration D} {c₁ c₂ : Component D} (h : E.Linked c₁ c₂) : E.Linked c₂ c₁ := by obtain ⟨h₁, h₂⟩ := h refine ⟨fun b hb => ?_, fun a ha => ?_⟩ · obtain ⟨a, ha, hr⟩ := h₂ b hb exact ⟨a, ha, hr.symm⟩ · obtain ⟨b, hb, hr⟩ := h₁ a ha exact ⟨b, hb, hr.symm⟩ @[simp] theorem linked_singleton_iff {D : Type u} {E : Elaboration D} {a b : D} : E.Linked (Component.singleton a) (Component.singleton b) ↔ E.Related a b := by constructor · intro h obtain ⟨b', hb', hr⟩ := h.1 a rfl have hb : b' = b := hb' subst hb exact hr · intro h refine ⟨fun a' ha' => ?_, fun b' hb' => ?_⟩ · have ha : a' = a := ha' subst ha exact ⟨b, rfl, h⟩ · have hb : b' = b := hb' subst hb exact ⟨a, rfl, h⟩ end Elaboration namespace Linkage def ofElaboration {D : Type u} (E : Elaboration D) : Linkage D where Linked := E.Linked symm := Elaboration.Linked.symm instance {D : Type u} : Coe (Elaboration D) (Linkage D) := ⟨ofElaboration⟩ end Linkage namespace Elaboration /-- Re-tag a raw dependence with the linkage derived from `E` — the sanctioned route around the self-reference restriction. Certifying (i.e. producing a `MutualDependence`) additionally requires proving `Holds` under the derived linkage, which is genuine work per system. -/ def certify {D : Type u} (E : Elaboration D) (rawM : RawMutualDependence D) : RawMutualDependence D := { rawM with linkage := Linkage.ofElaboration E } @[simp] theorem linkage_certify {D : Type u} (E : Elaboration D) (rawM : RawMutualDependence D) : (E.certify rawM).linkage = Linkage.ofElaboration E := rfl @[simp] theorem components_certify {D : Type u} (E : Elaboration D) (rawM : RawMutualDependence D) : (E.certify rawM).components = rawM.components := rfl /-- Well-formedness of a completed system: every emitted raw dependence carries the linkage derived from the elaboration itself. Provable about a finished `E`; not expressible inside `E`'s own definition. -/ def SelfCertified {D : Type u} (E : Elaboration D) : Prop := ∀ d rawM, E.Elab d rawM → rawM.linkage = Linkage.ofElaboration E end Elaboration /-! ## Resonance, raw and certified -/ /-- Resonance data whose two middle components are forced to be singletons. b₁ is the being receiving calls; b₂ is the "same" being responding. The being's receiving-stage and responding-stage share linkage despite the change. -/ structure RawResonance (D : Type u) where linkage : Linkage D calls : Component D b₁ : D b₂ : D responses : Component D namespace RawResonance def middle {D : Type u} (rawR : RawResonance D) : List (Component D) := [Component.singleton rawR.b₁, Component.singleton rawR.b₂] def toRawMutualDependence {D : Type u} (rawR : RawResonance D) : RawMutualDependence D := RawMutualDependence.quad rawR.linkage rawR.calls (Component.singleton rawR.b₁) (Component.singleton rawR.b₂) rawR.responses def components {D : Type u} (rawR : RawResonance D) : List (Component D) := rawR.toRawMutualDependence.components @[simp] theorem linkage_toRawMutualDependence {D : Type u} (rawR : RawResonance D) : rawR.toRawMutualDependence.linkage = rawR.linkage := rfl @[simp] theorem middle_toRawMutualDependence {D : Type u} (rawR : RawResonance D) : rawR.toRawMutualDependence.middle = rawR.middle := rfl @[simp] theorem components_eq {D : Type u} (rawR : RawResonance D) : rawR.components = [rawR.calls, Component.singleton rawR.b₁, Component.singleton rawR.b₂, rawR.responses] := rfl theorem isResonance {D : Type u} (rawR : RawResonance D) : rawR.toRawMutualDependence.IsResonance := ⟨rawR.b₁, rawR.b₂, rfl⟩ def Holds {D : Type u} (rawR : RawResonance D) : Prop := rawR.toRawMutualDependence.Holds @[simp] theorem holds_iff {D : Type u} {rawR : RawResonance D} : rawR.Holds ↔ rawR.linkage.Linked rawR.calls (Component.singleton rawR.b₁) ∧ rawR.linkage.Linked (Component.singleton rawR.b₁) (Component.singleton rawR.b₂) ∧ rawR.linkage.Linked (Component.singleton rawR.b₂) rawR.responses := by change (RawMutualDependence.quad rawR.linkage rawR.calls (Component.singleton rawR.b₁) (Component.singleton rawR.b₂) rawR.responses).Holds ↔ _ exact RawMutualDependence.holds_quad_iff end RawResonance /-- Completeness at the raw level: every raw mutual dependence satisfying `IsResonance` is represented by some `RawResonance`. -/ theorem RawMutualDependence.IsResonance.exists_rawResonance {D : Type u} {rawM : RawMutualDependence D} (h : rawM.IsResonance) : ∃ rawR : RawResonance D, rawR.toRawMutualDependence = rawM := by cases rawM with | mk linkage c₁ middle cₙ => obtain ⟨b₁, b₂, hmiddle⟩ := h change middle = [Component.singleton b₁, Component.singleton b₂] at hmiddle subst middle exact ⟨⟨linkage, c₁, b₁, b₂, cₙ⟩, rfl⟩ /-- The certified counterpart to `RawResonance`, following the same raw/certified boundary as mutual dependence. -/ structure Resonance (D : Type u) where toRawResonance : RawResonance D holds : toRawResonance.Holds namespace Resonance def linkage {D : Type u} (r : Resonance D) : Linkage D := r.toRawResonance.linkage def calls {D : Type u} (r : Resonance D) : Component D := r.toRawResonance.calls def b₁ {D : Type u} (r : Resonance D) : D := r.toRawResonance.b₁ def b₂ {D : Type u} (r : Resonance D) : D := r.toRawResonance.b₂ def responses {D : Type u} (r : Resonance D) : Component D := r.toRawResonance.responses def middleComponents {D : Type u} (r : Resonance D) : List (Component D) := [Component.singleton r.b₁, Component.singleton r.b₂] def toMutualDependence {D : Type u} (r : Resonance D) : MutualDependence D := ⟨r.toRawResonance.toRawMutualDependence, r.holds⟩ instance {D : Type u} : Coe (Resonance D) (MutualDependence D) := ⟨toMutualDependence⟩ theorem isResonance {D : Type u} (r : Resonance D) : r.toMutualDependence.IsResonance := r.toRawResonance.isResonance def mk' {D : Type u} (L : Linkage D) (calls : Component D) (b₁ b₂ : D) (responses : Component D) (h₁ : L.Linked calls (Component.singleton b₁)) (h₂ : L.Linked (Component.singleton b₁) (Component.singleton b₂)) (h₃ : L.Linked (Component.singleton b₂) responses) : Resonance D := ⟨⟨L, calls, b₁, b₂, responses⟩, RawResonance.holds_iff.mpr ⟨h₁, h₂, h₃⟩⟩ end Resonance /-- Completeness at the certified level: every certified mutual dependence satisfying `IsResonance` comes from a certified `Resonance`; the proof is transported along the raw representation. -/ theorem MutualDependence.IsResonance.exists_resonance {D : Type u} {m : MutualDependence D} (h : m.IsResonance) : ∃ r : Resonance D, r.toMutualDependence = m := by obtain ⟨rawR, hrawR⟩ := RawMutualDependence.IsResonance.exists_rawResonance h exact ⟨⟨rawR, (show rawR.toRawMutualDependence.Holds from hrawR.symm ▸ m.holds)⟩, MutualDependence.ext hrawR⟩ /-! ## Being -/ /-- A nonempty collection of resonances whose singleton middle components form one certified mutual dependence. -/ structure Being (D : Type u) where resonances : List (Resonance D) nonempty : resonances ≠ [] toMutualDependence : MutualDependence D components_eq : toMutualDependence.components = resonances.flatMap Resonance.middleComponents namespace Being private def rawOfComponents {D : Type u} (L : Linkage D) (c₁ c₂ : Component D) : List (Component D) → RawMutualDependence D | [] => RawMutualDependence.pair L c₁ c₂ | c₃ :: rest => let rawM := rawOfComponents L c₂ c₃ rest ⟨L, c₁, c₂ :: rawM.middle, rawM.cₙ⟩ private theorem linkage_rawOfComponents {D : Type u} (L : Linkage D) (c₁ c₂ : Component D) (rest : List (Component D)) : (rawOfComponents L c₁ c₂ rest).linkage = L := by cases rest <;> rfl private theorem c₁_rawOfComponents {D : Type u} (L : Linkage D) (c₁ c₂ : Component D) (rest : List (Component D)) : (rawOfComponents L c₁ c₂ rest).c₁ = c₁ := by cases rest <;> rfl private theorem components_rawOfComponents {D : Type u} (L : Linkage D) (c₁ c₂ : Component D) (rest : List (Component D)) : (rawOfComponents L c₁ c₂ rest).components = c₁ :: c₂ :: rest := by induction rest generalizing c₁ c₂ with | nil => rfl | cons c₃ rest ih => change c₁ :: (c₂ :: (rawOfComponents L c₂ c₃ rest).middle) ++ [(rawOfComponents L c₂ c₃ rest).cₙ] = c₁ :: c₂ :: c₃ :: rest have tailComponents : (c₂ :: (rawOfComponents L c₂ c₃ rest).middle) ++ [(rawOfComponents L c₂ c₃ rest).cₙ] = c₂ :: c₃ :: rest := by calc _ = (rawOfComponents L c₂ c₃ rest).c₁ :: (rawOfComponents L c₂ c₃ rest).middle ++ [(rawOfComponents L c₂ c₃ rest).cₙ] := by exact congrArg (fun c => (c :: (rawOfComponents L c₂ c₃ rest).middle) ++ [(rawOfComponents L c₂ c₃ rest).cₙ]) (c₁_rawOfComponents L c₂ c₃ rest).symm _ = (rawOfComponents L c₂ c₃ rest).components := rfl _ = c₂ :: c₃ :: rest := ih c₂ c₃ exact congrArg (List.cons c₁) tailComponents private def mutualDependenceOfComponents {D : Type u} (L : Linkage D) (c₁ c₂ : Component D) (rest : List (Component D)) (holds : L.ChainLinked (c₁ :: c₂ :: rest)) : MutualDependence D := by refine ⟨rawOfComponents L c₁ c₂ rest, ?_⟩ change (rawOfComponents L c₁ c₂ rest).linkage.ChainLinked (rawOfComponents L c₁ c₂ rest).components rw [linkage_rawOfComponents, components_rawOfComponents] exact holds /-- Certify a nonempty list of resonances as a being. Each resonance contributes its two singleton middle components, and `holds` certifies the resulting chain, including every join between consecutive resonances. -/ def ofResonances {D : Type u} (L : Linkage D) (resonances : List (Resonance D)) (nonempty : resonances ≠ []) (holds : L.ChainLinked (resonances.flatMap Resonance.middleComponents)) : Being D := by cases resonances with | nil => exact (nonempty rfl).elim | cons r rest => have chain : L.ChainLinked (Component.singleton r.b₁ :: Component.singleton r.b₂ :: rest.flatMap Resonance.middleComponents) := by simpa [Resonance.middleComponents] using holds refine ⟨r :: rest, by simp, mutualDependenceOfComponents L (Component.singleton r.b₁) (Component.singleton r.b₂) (rest.flatMap Resonance.middleComponents) chain, ?_⟩ simpa [mutualDependenceOfComponents, MutualDependence.components, Resonance.middleComponents] using (components_rawOfComponents L (Component.singleton r.b₁) (Component.singleton r.b₂) (rest.flatMap Resonance.middleComponents)) instance {D : Type u} : Coe (Being D) (MutualDependence D) := ⟨toMutualDependence⟩ end Being /-! ## Grading -/ structure PreorderBot (Grade : Type v) where le : Grade → Grade → Prop bot : Grade leRefl : ∀ grade, le grade grade leTrans : ∀ {a b c}, le a b → le b c → le a c botLeast : ∀ grade, le bot grade /-- Grade can be thought of as a "dis-resonance". Bot = no dis-resonance. -/ structure GradedResonance (D : Type u) {Grade : Type v} (PB : PreorderBot Grade) extends Resonance D where callsGrade : Grade responsesGrade : Grade namespace GradedResonance def toMutualDependence {D : Type u} {Grade : Type v} {PB : PreorderBot Grade} (r : GradedResonance D PB) : MutualDependence D := r.toResonance.toMutualDependence instance {D : Type u} {Grade : Type v} {PB : PreorderBot Grade} : CoeOut (GradedResonance D PB) (Resonance D) := ⟨GradedResonance.toResonance⟩ theorem isResonance {D : Type u} {Grade : Type v} {PB : PreorderBot Grade} (r : GradedResonance D PB) : r.toMutualDependence.IsResonance := r.toResonance.isResonance def ofResonance {D : Type u} {Grade : Type v} {PB : PreorderBot Grade} (r : Resonance D) (callsGrade responsesGrade : Grade) : GradedResonance D PB where toResonance := r callsGrade := callsGrade responsesGrade := responsesGrade @[simp] theorem callsGrade_ofResonance {D : Type u} {Grade : Type v} {PB : PreorderBot Grade} (r : Resonance D) (callsGrade responsesGrade : Grade) : (ofResonance (PB := PB) r callsGrade responsesGrade).callsGrade = callsGrade := rfl @[simp] theorem responsesGrade_ofResonance {D : Type u} {Grade : Type v} {PB : PreorderBot Grade} (r : Resonance D) (callsGrade responsesGrade : Grade) : (ofResonance (PB := PB) r callsGrade responsesGrade).responsesGrade = responsesGrade := rfl def ungraded {D : Type u} {Grade : Type v} {PB : PreorderBot Grade} (r : Resonance D) : GradedResonance D PB := ofResonance r PB.bot PB.bot @[simp] theorem callsGrade_ungraded {D : Type u} {Grade : Type v} {PB : PreorderBot Grade} (r : Resonance D) : (ungraded (PB := PB) r).callsGrade = PB.bot := rfl @[simp] theorem responsesGrade_ungraded {D : Type u} {Grade : Type v} {PB : PreorderBot Grade} (r : Resonance D) : (ungraded (PB := PB) r).responsesGrade = PB.bot := rfl def IsUngraded {D : Type u} {Grade : Type v} {PB : PreorderBot Grade} (r : GradedResonance D PB) : Prop := r.callsGrade = PB.bot ∧ r.responsesGrade = PB.bot def le {D : Type u} {Grade : Type v} {PB : PreorderBot Grade} (a b : GradedResonance D PB) : Prop := PB.le a.callsGrade b.callsGrade ∧ PB.le a.responsesGrade b.responsesGrade end GradedResonance /-! ## 10 Bulls -/ /- Nature/Bull 8/Arhat = Some r1, r1 is Ungraded, Being = [r1] Nature/Bull 9/Private Buddha = Some , r1 is Ungraded, r2 is IsUngraded, Being = [r2] Bull 10 = Some , r1 is Ungraded, r2 is graded, Being = [r1] -/ /-! ## Direction and causality -/ /-- Directed is not derived from the MutualDependence or Resonance, instead it's a fact among those - it just turns out that when thermodynamic gradient is possible, some designata sit at lower entropy than others; Directed specifies which. Causal comes with an assertion that there's a mutual dependence chain with x at one side and y at another. -/ structure Directed (D : Type u) where Before : D → D → Prop trans : ∀ {x y z : D}, Before x y → Before y z → Before x z irrefl : ∀ x : D, ¬ Before x x namespace Directed theorem asymm {D : Type u} (DA : Directed D) {x y : D} (h : DA.Before x y) : ¬ DA.Before y x := fun h' => DA.irrefl x (DA.trans h h') def ofBase {D : Type u} (base : D → D → Prop) (acyclic : ∀ x, ¬ Relation.TransGen base x x) : Directed D where Before := Relation.TransGen base trans := Relation.TransGen.trans irrefl := acyclic theorem rank_lt_of_transGen {D : Type u} {base : D → D → Prop} {rank : D → Nat} (step_lt : ∀ {x y}, base x y → rank x < rank y) {x y : D} (h : Relation.TransGen base x y) : rank x < rank y := by induction h with | single hxy => exact step_lt hxy | tail _ hyz ih => exact Nat.lt_trans ih (step_lt hyz) def ofBaseRank {D : Type u} (base : D → D → Prop) (rank : D → Nat) (step_lt : ∀ {x y}, base x y → rank x < rank y) : Directed D := ofBase base fun x h => Nat.lt_irrefl (rank x) (rank_lt_of_transGen (base := base) (rank := rank) step_lt h) end Directed inductive Causation (D : Type u) (x y : D) : Prop where | ofMutualDependence (m : MutualDependence D) (mem_c₁ : x ∈ m.c₁) (mem_cₙ : y ∈ m.cₙ) structure Causal (D : Type u) extends Directed D where Causes : D → D → Prop causes_before : ∀ {x y : D}, Causes x y → Before x y certify : ∀ {x y : D}, Causes x y → Causation D x y ===== FILE: KannoSoe/Consequences/Basic.lean ===== /- ================================================================================ KannoSoe.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 KannoSoe.Signature namespace KannoSoe 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 {Designatum Contrib : Type} [PreorderBot Contrib] variable (G : CoreReadings Designatum Contrib) /- Reading and motivation: Identification/Commentary.lean, C.2. -/ omit [PreorderBot Contrib] in /-- 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.1 := rfl omit [PreorderBot Contrib] in /-- 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⟩ omit [PreorderBot Contrib] in /-- An actual weld supplies the occurrence-form non-vacuity witness for its agent. -/ theorem actualAgentInhabited_of_actual (w : G.Weld) (h : G.Actual w) : G.ActualAgentInhabited w.agent := ⟨w, h, rfl⟩ omit [PreorderBot Contrib] in /-- Mounting at a call is exactly the existence of an actual weld with that agent and call. Function talk is thereby kept per occurrence. -/ theorem mountsAt_iff_exists_actual (b : Designatum) (c : Designatum) (hrealize : ∀ r, G.respondsTo b c = some r → ∃ w : G.Weld, G.Actual w ∧ w.agent = b ∧ w.call = c) : G.MountsAt b c ↔ ∃ w : G.Weld, G.Actual w ∧ w.agent = b ∧ w.call = c := by constructor · rintro ⟨r, hresp⟩ exact hrealize r hresp · rintro ⟨w, hactual, hagent, hcall⟩ subst hagent subst hcall exact ⟨w.response, hactual⟩ omit [PreorderBot Contrib] in theorem respondsToEveryCall_of_no_call (h : ∀ c, ¬ G.occurrence.isCall c) (b : Designatum) : G.RespondsToEveryCall b := fun c hcall => False.elim (h c hcall) /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem atPoleClass_of_terminus (b : Designatum) (hterm : G.Terminus b) : G.AtPoleClass b := hterm /- Reading and motivation: Identification/Commentary.lean, C.2. -/ omit [PreorderBot Contrib] in 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) {w : G.Weld} (hterm : G.Terminus w.agent) (hactual : G.Actual w) : AtBot (G.rePitch before w).tendency := G.atBot_of_terminus_response hterm hactual /- ============================================================================== Conditions-free grade checks ============================================================================== -/ /-- Replace only the conditioning reading. Response and placement readings are left untouched. -/ def withConditions (conditions' : Designatum → Designatum → Prop) : CoreReadings Designatum Contrib where occurrence := G.occurrence response := G.response placement := G.placement conditioning := { conditions := conditions' } omit [PreorderBot Contrib] in @[simp] theorem withConditions_respondsTo (conditions' : Designatum → Designatum → Prop) (b : Designatum) (c : Designatum) : (withConditions G conditions').respondsTo b c = G.respondsTo b c := rfl omit [PreorderBot Contrib] in @[simp] theorem withConditions_grade (conditions' : Designatum → Designatum → Prop) (d : Designatum) : (withConditions G conditions').grade d = G.grade d := rfl omit [PreorderBot Contrib] in @[simp] theorem withConditions_share (conditions' : Designatum → Designatum → Prop) (w : G.Weld) : (withConditions G conditions').share w = G.share w := rfl omit [PreorderBot Contrib] in @[simp] theorem withConditions_actual_iff (conditions' : Designatum → Designatum → Prop) (w : G.Weld) : (withConditions G conditions').Actual w ↔ G.Actual w := Iff.rfl omit [PreorderBot Contrib] in /-- 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₂ : Designatum → Designatum → Prop) (d : Designatum) : (withConditions G conditions₁).grade d = (withConditions G conditions₂).grade d := rfl omit [PreorderBot Contrib] in /-- 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₂ : Designatum → Designatum → Prop) (w : G.Weld) : (withConditions G conditions₁).share w = (withConditions G conditions₂).share w := rfl /- ============================================================================== Response-function replacement as countermodel tooling ============================================================================== -/ /-- Replace only the response function of a grid. Grade and delivery data are left untouched. This is countermodel tooling; no doctrinal reading is attached to the `none` region it may create. -/ def withRespondsTo (respondsTo' : Designatum -> Designatum -> Option Designatum) : CoreReadings Designatum Contrib where occurrence := G.occurrence response := { respondsTo := respondsTo' } placement := G.placement conditioning := G.conditioning omit [PreorderBot Contrib] in @[simp] theorem withRespondsTo_grade (respondsTo' : Designatum -> Designatum -> Option Designatum) (d : Designatum) : (withRespondsTo G respondsTo').grade d = G.grade d := rfl omit [PreorderBot Contrib] in @[simp] theorem withRespondsTo_share (respondsTo' : Designatum -> Designatum -> Option Designatum) (w : G.Weld) : (withRespondsTo G respondsTo').share w = G.share w := rfl omit [PreorderBot Contrib] in @[simp] theorem withRespondsTo_conditions (respondsTo' : Designatum -> Designatum -> Option Designatum) : (withRespondsTo G respondsTo').conditions = G.conditions := rfl /- ============================================================================== Accumulation: `rePitch` has no history register ============================================================================== -/ omit [PreorderBot Contrib] in /-- 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 omit [PreorderBot Contrib] in /-- 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 (rePitch_forgets G before₁ before₂ received) /- ============================================================================== The environs lens ============================================================================== -/ namespace DirectedConvention /- Reading and motivation: Identification/Commentary.lean, C.2. -/ theorem environsLine_of_shareDropLine {before : Config Contrib} {b : Designatum} {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 : Designatum} {deed reception : G.Weld} (h : ShareDropLine G before b deed reception) : G.IsShareDrop before reception := h.right omit [PreorderBot Contrib] in /-- An environs-line is a delivery-fact. -/ theorem deliveredTo_of_environsLine {b : Designatum} {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 := not_isShareDrop_of_tendency_atBot G (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 : Designatum) (deed reception : G.Weld) : ¬ ShareDropLine G before b deed reception := fun hline => not_isShareDrop_of_tendency_atBot G 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 : Designatum) (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 : Designatum} {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 : Designatum} {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 /-- Effective-terminus display, quantified over the run: the being is a responsive terminus and every delivered reception of one of its deeds closes shortfall for a live prior tendency. This descriptive standing form is legal as display over the run; it is not an act-time verdict or, by itself, the testimonial faith-object. The operational shushō-ittō face is `KsmdEffectiveOccurrence`, while `EffectiveTerminusNegative` checks that the universal conjunct is not recovered from actual-run data. Reading and motivation: Identification/Commentary.lean, C.4. -/ def KsmdEffectiveTerminus (b : Designatum) : Prop := G.ResponsiveTerminus b ∧ ∀ before deed reception, deed.agent = b → ShortfallClosedAt G before deed reception theorem responsiveTerminus_of_ksmdEffectiveTerminus {b : Designatum} (h : KsmdEffectiveTerminus G b) : G.ResponsiveTerminus b := h.left theorem shortfallClosedAt_of_ksmdEffectiveTerminus {b : Designatum} (h : KsmdEffectiveTerminus 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. The vacuous standing display is separated from enacted effectiveness by `not_effectivenessEnacted_of_undelivered`. -/ theorem ksmdEffectiveTerminus_of_responsiveTerminus_of_undelivered {b : Designatum} (hterm : G.ResponsiveTerminus b) (hundelivered : ∀ (deed reception : G.Weld), deed.agent = b → ¬ DeliveredTo G deed reception) : KsmdEffectiveTerminus 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 omit [PreorderBot Contrib] in /-- A full reach-back is the same field-side fact as delivery. -/ theorem ksmdReachBackFull_iff_deliveredTo (deed reception : G.Weld) : KsmdReachBackFull G deed reception ↔ DeliveredTo G deed reception := Iff.rfl omit [PreorderBot Contrib] in /-- The display-tier aiming lens unfolds to delivery and adds no mechanism. -/ theorem ksmdAimedAt_iff_deliveredTo (deed reception : G.Weld) : KsmdAimedAt G deed reception ↔ DeliveredTo G deed reception := Iff.rfl omit [PreorderBot Contrib] in /-- Landing includes delivery. -/ theorem deliveredTo_of_landsAt {deed reception : G.Weld} (h : LandsAt G deed reception) : DeliveredTo G deed reception := h.left omit [PreorderBot Contrib] in /-- 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 : CoreReadings Designatum Contrib} omit [PreorderBot Contrib] in /-- The first member of a reception pair is actual. -/ theorem first_actual (p : ReceptionPair G) : G.Actual p.first.weld := p.first.actual omit [PreorderBot Contrib] in /-- The second member of a reception pair is actual. -/ theorem second_actual (p : ReceptionPair G) : G.Actual p.second.weld := p.second.actual omit [PreorderBot Contrib] in /-- 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. -/ omit [PreorderBot Contrib] in 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. -/ omit [PreorderBot Contrib] in 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) := not_actTime_hasLiveShare_of_atBot G (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 => floor_has_no_live_share G 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 (floor_has_no_live_share G)) /-- 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 floor-apophatic row language below is the special case where the missing genjō-fusion clause is built into the semantics by indiscernibility. -/ 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 : CoreReadings Designatum Contrib} {L : ClaimLanguage G} omit [PreorderBot Contrib] in /-- 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 omit [PreorderBot Contrib] in /-- 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 namespace CoreReadings variable {Designatum Contrib : Type} [PreorderBot Contrib] abbrev withConditions (G : CoreReadings Designatum Contrib) := Grid.withConditions G abbrev withRespondsTo (G : CoreReadings Designatum Contrib) := Grid.withRespondsTo G abbrev rePitch_tendency_atBot_of_terminus_response (G : CoreReadings Designatum Contrib) := Grid.rePitch_tendency_atBot_of_terminus_response G abbrev grade_independent_of_conditions (G : CoreReadings Designatum Contrib) := Grid.grade_independent_of_conditions G abbrev share_independent_of_conditions (G : CoreReadings Designatum Contrib) := Grid.share_independent_of_conditions G abbrev rePitch_forgets (G : CoreReadings Designatum Contrib) := Grid.rePitch_forgets G abbrev accumulated_attainment_constant_of_same_final (G : CoreReadings Designatum Contrib) {α : Type} (score : Config Contrib → α) (before₁ before₂ : Config Contrib) (received : G.Weld) := Grid.accumulated_attainment_constant_of_same_final G score before₁ before₂ received abbrev not_isShareDrop_of_tendency_atBot (G : CoreReadings Designatum Contrib) {before : Config Contrib} (h : AtBot before.tendency) (received : G.Weld) := Grid.not_isShareDrop_of_tendency_atBot G h received abbrev fused_of_obeysSeparateFuse (G : CoreReadings Designatum Contrib) {d : Grid.Distinction G} (h : d.ObeysSeparateFuse) (t : Grid.Tier G) := Grid.fused_of_obeysSeparateFuse G h t abbrev separated_of_obeysSeparateFuse (G : CoreReadings Designatum Contrib) {d : Grid.Distinction G} (h : d.ObeysSeparateFuse) {t : Grid.Tier G} (ht : Grid.Tier.hasLiveShare G t) := Grid.separated_of_obeysSeparateFuse G h ht abbrev floor_has_no_live_share (G : CoreReadings Designatum Contrib) := Grid.floor_has_no_live_share G abbrev not_actTime_hasLiveShare_of_atBot (G : CoreReadings Designatum Contrib) {w : G.Weld} (h : AtBot (G.share w)) := Grid.not_actTime_hasLiveShare_of_atBot G h end CoreReadings end KannoSoe ===== FILE: KannoSoe/Consequences/Compounds.lean ===== /- ================================================================================ KannoSoe.Consequences.Compounds Compound positions as decompositions over taxonomy rows ================================================================================ Reading and motivation: Identification/Commentary.lean, C.2. -/ import KannoSoe.Consequences.Taxonomy namespace KannoSoe 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 {Designatum Contrib : Type} [PreorderBot Contrib] variable (G : CoreReadings Designatum 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 KannoSoe ===== FILE: KannoSoe/Consequences/ContentRows.lean ===== /- ================================================================================ KannoSoe.Consequences.ContentRows Content-bearing layer rows and the content beings ladder ================================================================================ Reading and motivation: Identification/Commentary.lean, C.2. -/ import KannoSoe.Consequences.Ladder namespace KannoSoe namespace Grid variable {Designatum Contrib : Type} [PreorderBot Contrib] variable (G : CoreReadings Designatum 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 : CoreReadings Designatum Contrib) : ClaimLanguage G where Claim := LayerClaim Holds | .floor, _ => False | .actTime w, .conventionLive _ => G.HasSelfPoleIndex w | .actTime _, .layerDenied .directedTime => DirectionVoid Contrib | .actTime _, .layerDenied .intraWeldArrow => ∀ b : Designatum, ¬ G.ResponseVariesWithCall b | .actTime _, .layerDenied .beings => ¬ ∃ w : G.Weld, G.Actual w | .actTime _, .layerDenied .gridLens => ∀ t : Tier G, ¬ Tier.hasLiveShare G t | .actTime _, .layerDenied .weldGrain => ¬ ∃ w : G.Weld, G.Actual w def contentLayerRow (G : CoreReadings Designatum Contrib) (l : ConventionLayer) : Distinction G := { language := contentLayerLanguage G sideA := .conventionLive l sideB := .layerDenied l } def contentBeforeAfterRow (G : CoreReadings Designatum Contrib) : Distinction G := contentLayerRow G .directedTime def contentIntraWeldArrowRow (G : CoreReadings Designatum Contrib) : Distinction G := contentLayerRow G .intraWeldArrow def contentBeingsRow (G : CoreReadings Designatum Contrib) : Distinction G := contentLayerRow G .beings def contentGridLensRow (G : CoreReadings Designatum Contrib) : Distinction G := contentLayerRow G .gridLens def contentWeldRow (G : CoreReadings Designatum Contrib) : Distinction G := contentLayerRow G .weldGrain /-- A content denial cannot fuse with the live-side claim at a non-live act-time where that denial is true. This pointwise certificate records the exact tier at which fusion fails. -/ theorem contentLayerRow_not_fused_of_nonlive_denial (l : ConventionLayer) (w : G.Weld) (hnonlive : ¬ G.HasSelfPoleIndex w) (hdenial : (contentLayerLanguage G).TrueAt (.actTime w) (.layerDenied l)) : ¬ (contentLayerRow G l).Fused (.actTime w) := by intro hfused have hiff := hfused hnonlive have hlive : G.HasSelfPoleIndex w := by exact hiff.mpr hdenial exact hnonlive hlive /-- The same local failure refutes the global separate/fuse rule. -/ theorem contentLayerRow_not_obeys_of_nonlive_denial (l : ConventionLayer) (w : G.Weld) (hnonlive : ¬ G.HasSelfPoleIndex w) (hdenial : (contentLayerLanguage G).TrueAt (.actTime w) (.layerDenied l)) : ¬ (contentLayerRow G l).ObeysSeparateFuse := by intro h exact contentLayerRow_not_fused_of_nonlive_denial G l w hnonlive hdenial (G.fused_of_obeysSeparateFuse h (.actTime w)) /-- If the occurrence reading selects nothing, every content row obeys vacuously: only the floor tier remains. This is a boundary theorem, not a missing-hypothesis countermodel, because there is no act-time at which fusion could fail. -/ theorem contentLayerRow_obeys_of_no_occurrences (l : ConventionLayer) (hno : ∀ _w : G.Weld, False) : (contentLayerRow G l).ObeysSeparateFuse := by constructor · intro t hlive cases t with | floor => exact False.elim hlive | actTime w => exact False.elim (hno w) · intro t _hnonlive cases t with | floor => exact Iff.rfl | actTime w => exact False.elim (hno w) 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 => exact Iff.rfl | 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 : ∃ w : G.Weld, G.Actual w) : (contentLayerRow G .beings).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 => exact Iff.rfl | actTime _ => dsimp [contentLayerRow, contentLayerLanguage, ClaimLanguage.TrueAt] constructor · intro hLive exact False.elim (hNotLive hLive) · intro hnone exact False.elim (hnone h) theorem contentLayerRow_obeys_of_variation (h : ∃ b : Designatum, 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 => exact Iff.rfl | 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 => exact Iff.rfl | 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 => exact Iff.rfl | 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 : Designatum, G.ResponseVariesWithCall b) : (contentIntraWeldArrowRow G).ObeysSeparateFuse := contentLayerRow_obeys_of_variation G h theorem contentBeingsRow_obeys_of_being (h : ∃ w : G.Weld, G.Actual w) : (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 utterance itself supplies the denied actual weld. -/ 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 hfit ⟨u.weld, u.actual⟩ /-- 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 : CoreReadings Designatum Contrib) : Nat → Distinction G := ladder (contentBeingsRow G) theorem contentBeingsLadder_obeys_of_being (h : ∃ w : G.Weld, G.Actual w) : ∀ n, (contentBeingsLadder G n).ObeysSeparateFuse := ladder_obeys (G := G) (contentBeingsRow_obeys_of_being G h) theorem contentBeingsLadder_no_level_final_of_being (h : ∃ w : G.Weld, G.Actual w) : ∀ 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 KannoSoe ===== FILE: KannoSoe/Consequences/FoxCase.lean ===== /- ================================================================================ KannoSoe.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 KannoSoe.Consequences.Taxonomy namespace KannoSoe namespace FoxCase open Grid open Grid.DirectedConvention open Grid.DirectedConvention.BeingConvention open Grid.DirectedConvention.BeingConvention.GridConvention inductive FoxDesignatum | life (n : Nat) | question | fruit | turningWord | notFall | clench | release | sentenceOccurrence | lifeReceptionOccurrence (n : Nat) | releaseOccurrence deriving DecidableEq namespace FoxCall abbrev question : FoxDesignatum := .question abbrev fruit : FoxDesignatum := .fruit abbrev turningWord : FoxDesignatum := .turningWord end FoxCall namespace FoxResponse abbrev notFall : FoxDesignatum := .notFall abbrev clench : FoxDesignatum := .clench abbrev release : FoxDesignatum := .release end FoxResponse def foxOccurrence : OccurrenceReading FoxDesignatum where occurrence d := match d with | .sentenceOccurrence | .lifeReceptionOccurrence _ | .releaseOccurrence => True | _ => False isBeing d := match d with | .life _ => True | _ => False isCall d := match d with | .question | .fruit | .turningWord => True | _ => False isResponse d := match d with | .notFall | .clench | .release => True | _ => False agent d := match d with | .sentenceOccurrence => .life 0 | .lifeReceptionOccurrence n => .life n | .releaseOccurrence => .life 1 | _ => d call d := match d with | .sentenceOccurrence => .question | .lifeReceptionOccurrence _ => .fruit | .releaseOccurrence => .turningWord | _ => d response d := match d with | .sentenceOccurrence => .notFall | .lifeReceptionOccurrence _ => .clench | .releaseOccurrence => .release | _ => d def foxAgentNumber : FoxDesignatum → Nat | .sentenceOccurrence => 0 | .lifeReceptionOccurrence n => n | .releaseOccurrence => 1 | .life n => n | _ => 0 /-- The concrete fox grid: life 0 answers the question; later lives receive fruit; the turning word releases without reaching the pole. -/ def foxGrid : CoreReadings FoxDesignatum Nat where occurrence := foxOccurrence response := { respondsTo := fun b c => match b, c with | .life 0, .question => some .notFall | .life _, .fruit => some .clench | .life _, .turningWord => some .release | _, _ => none } placement := { grade := fun d => match d with | .sentenceOccurrence | .lifeReceptionOccurrence _ => 5 | .releaseOccurrence => 1 | _ => 0 } conditioning := { conditions := fun deed reception => foxAgentNumber reception = foxAgentNumber deed + 1 ∨ foxAgentNumber deed = 0 } def sentenceWeld : foxGrid.Weld := ⟨.sentenceOccurrence, True.intro⟩ def lifeReception (n : Nat) : foxGrid.Weld := ⟨.lifeReceptionOccurrence n, True.intro⟩ def releaseWeld : foxGrid.Weld := ⟨.releaseOccurrence, True.intro⟩ 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₂ : FoxDesignatum -> FoxDesignatum -> Prop) : (∀ d, (foxGrid.withConditions conditions₁).grade d = (foxGrid.withConditions conditions₂).grade d) ∧ ∀ 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) : Grid.DirectedConvention.DeliveredTo foxGrid sentenceWeld (lifeReception (n + 1)) := by dsimp [Grid.DirectedConvention.DeliveredTo, KannoSoe.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 : KsmdReachBackFull foxGrid sentenceWeld releaseWeld := by dsimp [KsmdReachBackFull, 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 rintro ⟨d, hd⟩ _hactual change foxOccurrence.occurrence d at hd change ¬ foxGrid.placement.grade d ≤ (0 : Nat) cases d with | life _ => change False at hd exact hd.elim | question => change False at hd exact hd.elim | fruit => change False at hd exact hd.elim | turningWord => change False at hd exact hd.elim | notFall => change False at hd exact hd.elim | clench => change False at hd exact hd.elim | release => change False at hd exact hd.elim | sentenceOccurrence => show ¬ (5 : Nat) ≤ 0 decide | lifeReceptionOccurrence _ => show ¬ (5 : Nat) ≤ 0 decide | releaseOccurrence => show ¬ (1 : Nat) ≤ 0 decide /-- The display convention merging all lives into "the fox"; the fine tags remain distinct designata. -/ def foxSeriesCoarsening : BeingCoarsening foxGrid Unit where proj _ := () def foxSeriesSentienceReading : foxGrid.SentienceReading := Grid.SentienceReading.allSentient foxGrid theorem foxSeries_macro_sentient : foxSeriesCoarsening.SentientTag foxSeriesSentienceReading () := ⟨sentenceWeld, ⟨sentenceWeld_actual, True.intro⟩, 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.MisfitsOfferedTier := denied_misfits_live_offer_as_error foxGrid .foxWeld oldManUtterance rfl sentenceWeld_hasSelfPoleIndex /-- Compatibility form of the old-man verdict. -/ theorem oldMan_utterance_not_fits : ¬ oldManUtterance.FitsOfferedTier := denied_misfits_live_offer foxGrid .foxWeld 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 /-- The daishugyō floor face is beyond conviction by silence, not true at the floor. -/ theorem daishugyo_floor_face_error_free : ¬ daishugyoFloorUtterance.MisfitsOfferedTier := not_misfits_of_floor_offer foxGrid daishugyoFloorUtterance rfl /-- The daishugyō conventional face positively fits its live act-time tier. -/ theorem daishugyo_conventional_face_fits : daishugyoConventionalUtterance.FitsOfferedTier := 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.MisfitsOfferedTier := denied_misfits_live_offer_as_error foxGrid .foxWeld jinshinIngaFloorVoicing rfl releaseWeld_hasSelfPoleIndex /-- Dōgen's doubling holds both faces without making the floor face an assertion: the old man errs, daishugyō does not, and the difference is carried by the error predicate rather than by floor truth. -/ theorem dogen_doubling : (¬ daishugyoFloorUtterance.MisfitsOfferedTier) ∧ daishugyoConventionalUtterance.FitsOfferedTier ∧ jinshinIngaInstruction.FitsOfferedTier ∧ jinshinIngaFloorVoicing.MisfitsOfferedTier := ⟨daishugyo_floor_face_error_free, daishugyo_conventional_face_fits, jinshinInga_instruction_fits, jinshinInga_floor_voicing_would_misfit⟩ end FoxCase end KannoSoe ===== FILE: KannoSoe/Consequences/Ladder.lean ===== /- ================================================================================ KannoSoe.Consequences.Ladder Re-emptying ladder generated from taxonomy rows ================================================================================ Reading and motivation: Identification/Commentary.lean, C.2. -/ import KannoSoe.Consequences.Taxonomy namespace KannoSoe namespace Grid variable {Designatum Contrib : Type} [PreorderBot Contrib] variable (G : CoreReadings Designatum 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 is silent at the floor and separates, at act-time, the lower row's live separation from the claim that the lower row has frozen. -/ def reEmptied {G : CoreReadings Designatum Contrib} (d : Distinction G) : Distinction G where language := { Claim := LadderSide Holds := fun t c => match t, c with | .floor, _ => False | .actTime w, .liveBelow => d.Separated (.actTime w) | .actTime _, .finalBelow => d.Freeze } sideA := .liveBelow sideB := .finalBelow def ladder {G : CoreReadings Designatum 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 => exact Iff.rfl | 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] exact Iff.rfl | 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 : CoreReadings Designatum Contrib) : Nat → Distinction G := ladder (beingsRow G) def beforeAfterLadder (G : CoreReadings Designatum Contrib) : Nat → Distinction G := ladder (beforeAfterRow G) def intraWeldArrowLadder (G : CoreReadings Designatum Contrib) : Nat → Distinction G := ladder (intraWeldArrowRow G) def gridLensLadder (G : CoreReadings Designatum Contrib) : Nat → Distinction G := ladder (gridLensRow G) def weldLadder (G : CoreReadings Designatum Contrib) : Nat → Distinction G := ladder (weldRow G) def doerDeedLadder (G : CoreReadings Designatum 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 KannoSoe ===== FILE: KannoSoe/Consequences/ModelWitnesses.lean ===== /- ================================================================================ KannoSoe.Consequences.ModelWitnesses Concrete discharges of general consequence-level statements ================================================================================ Concrete grids live here rather than in `Taxonomy`, whose statements remain parametric in the grid wherever their content is general. -/ import KannoSoe.Consequences.Taxonomy namespace KannoSoe /-- 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 }, registerWeld 2, ?_, ?_, ?_⟩ · 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 }, backslideWeld .gentle, backslideWeld .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 := backslideWeld .gentle, actual := rfl }, second := { weld := backslideWeld .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 ⟨registerWeld 5, ?_, ?_, ?_⟩ · 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 /-- 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 }, clockAdaptivePresent, ?_, ?_⟩ · 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 }, clockAdaptivePresent, ?_, ?_, ?_⟩ · 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 adaptive clock concretely discharges the general, mark-free pole-tier inhabitation theorem. -/ theorem clock_poleTier_inhabited : ∃ w : clockGrid.Weld, clockGrid.Actual w ∧ w.agent = Clock.adaptive ∧ AtBot (clockGrid.share w) ∧ clockGrid.AtPoleClass w.agent := poleTier_inhabited_of_liveTerminus adaptive_liveTerminus end KannoSoe ===== FILE: KannoSoe/Consequences/Taxonomy.lean ===== /- ================================================================================ KannoSoe.Consequences.Taxonomy Error taxonomy, table order, and witnesses ================================================================================ Reading and motivation: Identification/Commentary.lean, C.2. -/ import KannoSoe.Consequences.Basic namespace KannoSoe namespace Grid variable {Designatum Contrib : Type} [PreorderBot Contrib] variable (G : CoreReadings Designatum 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 | standingSentience | 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) /-- Floor-apophatic semantics. At `floor` no claim holds: the floor asserts nothing, and fusion there is degeneracy of the claim-space, not joint truth. At act-time the conventional side holds; the denial side holds exactly at the pole-class, where it is earned as diagnosis (不昧). Nothing in this language affirms a positive truth predicate of the floor. -/ def rowLanguage (G : CoreReadings Designatum Contrib) : ClaimLanguage G where Claim := RowClaim Holds | .floor, _ => False | .actTime _, .inForce _ => True | .actTime w, .denied _ => AtBot (G.share w) /-- Nothing is assertable at the floor; the ultimate appears in the formal language only as the point where the language runs out. -/ theorem no_row_claim_holds_at_floor : ∀ p : RowClaim, ¬ (rowLanguage G).Holds Tier.floor p := by intro _p h exact h /-- At the floor every distinction of this language degenerates. Fusion is by silence, not by joint truth; compare `not_freeze_of_same_claim`. -/ theorem floor_claims_indiscernible : ∀ p q : RowClaim, ((rowLanguage G).Holds Tier.floor p ↔ (rowLanguage G).Holds Tier.floor q) := by intro _p _q exact Iff.rfl /-- Without relying on the conventional, nothing is taught: any recorded utterance that fits its offered tier is offered at an act-time tier. Error, and therefore correction, exists only under separation (MMK 24.10). -/ theorem fitting_offer_is_actTime (u : RecordedUtterance G (rowLanguage G)) (hfit : u.FitsOfferedTier) : ∃ w : G.Weld, u.offeredAt = Tier.actTime w := by cases hoff : u.offeredAt with | floor => change (rowLanguage G).TrueAt u.offeredAt u.content at hfit rw [hoff] at hfit exact hfit.elim | actTime w => exact ⟨w, rfl⟩ /-- Ordinary conventional speech fits its offer: an `inForce` claim offered at any act-time tier is true there. The taxonomy's default verdict on ordinary speech is decline. -/ theorem inForce_fits_actTime_offer (u : RecordedUtterance G (rowLanguage G)) (r : RowTag) (hcontent : u.content = .inForce r) (w : G.Weld) (hoff : u.offeredAt = Tier.actTime w) : u.FitsOfferedTier := by change (rowLanguage G).TrueAt u.offeredAt u.content rw [hoff, hcontent] exact True.intro /-- A floor offer is error-free by silence: it asserts nothing, so nothing convicts it. This is not a positive truth judgement at the floor. -/ theorem not_misfits_of_floor_offer (u : RecordedUtterance G (rowLanguage G)) (hoff : u.offeredAt = Tier.floor) : ¬ u.MisfitsOfferedTier := by rintro ⟨w, hact, _hfalse⟩ rw [hoff] at hact cases hact /-- Failure to fit an act-time offer is exactly enough to introduce the conventional error predicate. -/ theorem misfits_of_not_fits_actTime (u : RecordedUtterance G (rowLanguage G)) (w : G.Weld) (hoff : u.offeredAt = Tier.actTime w) (hnot : ¬ u.FitsOfferedTier) : u.MisfitsOfferedTier := ⟨w, hoff, hnot⟩ /-- A fitting offer cannot be a conventional misfit. -/ theorem not_misfits_of_fits (u : RecordedUtterance G (rowLanguage G)) (hfit : u.FitsOfferedTier) : ¬ u.MisfitsOfferedTier := by rintro ⟨_w, _hoff, hnot⟩ exact hnot hfit def rowOf (G : CoreReadings Designatum 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] exact Iff.rfl /-- 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 => exact h.elim | 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] exact Iff.rfl | 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 floor-apophatic 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 /-- The error-predicate form of `denied_misfits_live_offer`: a live denial is not merely unfit but a conventional misfit. -/ theorem denied_misfits_live_offer_as_error (r : RowTag) (u : RecordedUtterance G (rowLanguage G)) (hcontent : u.content = .denied r) (hlive : Tier.hasLiveShare G u.offeredAt) : u.MisfitsOfferedTier := by cases hoff : u.offeredAt with | floor => rw [hoff] at hlive cases hlive | actTime w => exact misfits_of_not_fits_actTime G u w hoff (denied_misfits_live_offer G r u hcontent hlive) abbrev layerRow (G : CoreReadings Designatum Contrib) (l : ConventionLayer) : Distinction G := rowOf G (.layer l) abbrev beforeAfterRow (G : CoreReadings Designatum Contrib) : Distinction G := rowOf G (.layer .directedTime) abbrev beingsRow (G : CoreReadings Designatum Contrib) : Distinction G := rowOf G (.layer .beings) abbrev gridLensRow (G : CoreReadings Designatum Contrib) : Distinction G := rowOf G (.layer .gridLens) abbrev weldRow (G : CoreReadings Designatum Contrib) : Distinction G := rowOf G (.layer .weldGrain) abbrev intraWeldArrowRow (G : CoreReadings Designatum 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 : CoreReadings Designatum 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 : CoreReadings Designatum 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 : CoreReadings Designatum 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 : CoreReadings Designatum 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 function_share_cell_collapse_self_refuting (t : Tier G) : ¬ (functionShareRow G).Collapse t := rowOf_collapse_self_refuting G .functionShare t abbrev karmaIngaRow (G : CoreReadings Designatum 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 : CoreReadings Designatum 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 : CoreReadings Designatum 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 : CoreReadings Designatum 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 : CoreReadings Designatum 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 : CoreReadings Designatum 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 object_axis_as_subject_collapse_self_refuting (t : Tier G) : ¬ (subjectObjectAxisRow G).Collapse t := rowOf_collapse_self_refuting G .subjectObjectAxis t /- Sentience is marked per weld by `SentienceReading`; treating the mark as a standing nature freezes this distinction, while identifying it with grid-visible function collapses the two sides. The generic row machinery checks the taxonomy shape without pretending to recover the supplied mark. -/ abbrev standingSentienceRow (G : CoreReadings Designatum Contrib) : Distinction G := rowOf G .standingSentience theorem standingSentienceRow_obeys [∀ w : G.Weld, Decidable (AtBot (G.share w))] : (standingSentienceRow G).ObeysSeparateFuse := rowOf_obeys G .standingSentience theorem standingSentienceRow_not_freeze : ¬ (standingSentienceRow G).Freeze := rowOf_not_freeze G .standingSentience theorem sentience_from_function_collapse_self_refuting (t : Tier G) : ¬ (standingSentienceRow G).Collapse t := rowOf_collapse_self_refuting G .standingSentience t abbrev perCallGlobalRow (G : CoreReadings Designatum 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 : CoreReadings Designatum 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 : CoreReadings Designatum 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) /- Scope note, against over-diagnosis. The table grades offers, not sentences: the generator's unit is `RecordedUtterance` — content carried with its call and its offered tier — and a sentence-shape alone is not in the domain (the gradeability discipline's limit case; compare `severed_transcript_ungradeable`). Ordinary conventional speech is the validated default, not the suspect case: the row language makes each row's conventional side hold wherever an act is under way — validity by stipulation, not an achievement of the sentence (`rowLanguage`, `inForce_fits_actTime_offer`) — so narration that merely exercises the being, doer/deed, before/after, and weld-grain conventions, "a man walked into a bar", violates none of them, and the generator's standing verdict on it is decline. Errors enter with the offer, never with the words: the same words carried by a different offer are a different recorded utterance — held out as floor-furniture they stack freezes per distinction touched; their denial, offered as live diagnosis, stacks collapses. A diagnosis that convicts the sentence itself is the over-generation the decline verdict fences. -/ 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 .standingSentience, .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 /-- A live terminus supplies an actual pole-share weld in its own agent fiber. This is mark-free: no sentience reading is needed to inhabit the tier. -/ theorem poleTier_inhabited_of_liveTerminus {Designatum Contrib : Type} [PreorderBot Contrib] {G : CoreReadings Designatum Contrib} {b : Designatum} (h : G.LiveTerminus b) : ∃ w : G.Weld, G.Actual w ∧ w.agent = b ∧ AtBot (G.share w) ∧ G.AtPoleClass w.agent := by rcases h.left with ⟨w, hactual, hagent⟩ refine ⟨w, hactual, hagent, ?_, ?_⟩ · exact h.right w hactual hagent · simpa [Grid.AtPoleClass, hagent] using h.right /-- `LiveTerminus` fixes the pole-share witness, while the supplied mark conditionally determines which row of the act square contains it. The theorem remains constructive by making neither row choice itself. -/ theorem poleTier_cell_of_liveTerminus {Designatum Contrib : Type} [PreorderBot Contrib] {G : CoreReadings Designatum Contrib} {b : Designatum} (S : G.SentienceReading) (h : G.LiveTerminus b) : ∃ w : G.Weld, w.agent = b ∧ AtBot (G.share w) ∧ (S.sentient w → G.TerminusAct S w) ∧ (¬ S.sentient w → G.StoneAct S w) := by rcases poleTier_inhabited_of_liveTerminus h with ⟨w, hactual, hagent, hbot, _hatPole⟩ exact ⟨w, hagent, hbot, fun hmarked => ⟨⟨hactual, hmarked⟩, hbot⟩, fun hunmarked => ⟨⟨hactual, hunmarked⟩, hbot⟩⟩ /-- Assertable and displayable are different verdict voices. -/ theorem assertable_ne_displayable : Grid.VerdictVoice.assertable ≠ Grid.VerdictVoice.displayable := by intro h cases h end KannoSoe ===== FILE: KannoSoe/Doctrines/Correlations.lean ===== /- ================================================================================ KannoSoe.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 KannoSoe.Doctrines.Deliberation namespace KannoSoe namespace Grid open DirectedConvention open DirectedConvention.BeingConvention variable {Designatum Contrib : Type} [PreorderBot Contrib] variable (G : CoreReadings Designatum 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 := StageScheme G (Fin 52) /-- The boundary relation read from a supplied coarsening. -/ abbrev CoarseningBoundary {Macro : Type} (κ : BeingCoarsening G Macro) : Designatum → Designatum → 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 KsmdBullSeven (b : Designatum) : 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. The retired function-zero disjunct is absent; this is terminus typing. -/ abbrev KsmdBullEight (b : Designatum) : Prop := G.AtPoleClass b /-- Bull 9: return to source as call-entire terminus response. -/ abbrev KsmdBullNine (b : Designatum) : 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 KsmdBullTen {Macro : Type} (S : SentienceReading G) (κ : BeingCoarsening G Macro) (b : Designatum) : Prop := G.ResponsiveTerminus b ∧ ∃ deed reception : G.Weld, κ.InFiber (κ.proj b) deed ∧ G.Actual reception ∧ ¬ κ.SameFiber deed.agent reception.agent ∧ κ.SentientTag S (κ.proj reception.agent) ∧ DirectedConvention.DeliveredTo G deed reception /-- The shelved stronger bodhisattva reading: delivery reaches every other sentient fiber. The source picture does not require this strength. -/ def StrongKsmdBullTen {Macro : Type} (S : SentienceReading G) (κ : BeingCoarsening G Macro) (b : Designatum) : Prop := G.ResponsiveTerminus b ∧ ∀ m : Macro, κ.SentientTag S m → m ≠ κ.proj b → ∃ deed reception : G.Weld, κ.InFiber (κ.proj b) deed ∧ κ.InFiber m reception ∧ G.Actual reception ∧ DirectedConvention.DeliveredTo G deed reception theorem bullSeven_not_terminus {b : Designatum} (h : KsmdBullSeven G 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 : Designatum} (h : KsmdBullSeven G b) : ¬ KsmdBullEight G b := by exact bullSeven_not_terminus G h theorem bullTen_to_bullNine {Macro : Type} {S : SentienceReading G} {κ : BeingCoarsening G Macro} {b : Designatum} (h : KsmdBullTen G S κ b) : KsmdBullNine G b := h.left theorem bullNine_to_terminus {b : Designatum} (h : KsmdBullNine G b) : G.Terminus b := h.right theorem terminus_to_bullEight {b : Designatum} (h : G.Terminus b) : KsmdBullEight G b := h theorem bullNine_to_bullEight {b : Designatum} (h : KsmdBullNine G b) : KsmdBullEight G b := terminus_to_bullEight G h.right theorem bullTen_to_bullEight {Macro : Type} {S : SentienceReading G} {κ : BeingCoarsening G Macro} {b : Designatum} (h : KsmdBullTen G S κ b) : KsmdBullEight G b := bullNine_to_bullEight G h.left /-- Bull 10 is explicitly reading-relative: under the constant-false sentience reading its marketplace destination cannot be inhabited. -/ theorem not_ksmdBullTen_allInsentient {Macro : Type} (κ : BeingCoarsening G Macro) (b : Designatum) : ¬ KsmdBullTen G (SentienceReading.allInsentient G) κ b := by rintro ⟨_hterm, deed, reception, _hdeed, _hactual, _hcross, hsentient, _hdel⟩ exact κ.allInsentient_not_sentientTag (κ.proj reception.agent) hsentient 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 {Designatum Contrib : Type} [PreorderBot Contrib] variable (G : CoreReadings Designatum 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 | .floor, _ => False | .actTime _, _ => True abbrev RecordedRankUtterance : Type := RecordedUtterance G (rankLanguage G) /-- The 到 rank's checked shape: marketplace arrival is exactly the Bull 10 delivery pattern under the supplied coarsening. -/ abbrev KenChuToShape {Macro : Type} (S : SentienceReading G) (κ : BeingCoarsening G Macro) (b : Designatum) : Prop := KsmdBullTen G S κ b theorem kenChuTo_implies_ksmdBullTen {Macro : Type} {S : SentienceReading G} {κ : BeingCoarsening G Macro} {b : Designatum} (h : KenChuToShape G S κ b) : KsmdBullTen G S κ b := h end Grid namespace CoreReadings variable {Designatum Contrib : Type} [PreorderBot Contrib] abbrev StageScheme (G : CoreReadings Designatum Contrib) := Grid.StageScheme G abbrev FiftyTwoStageScheme (G : CoreReadings Designatum Contrib) := Grid.FiftyTwoStageScheme G abbrev KsmdBullSeven (G : CoreReadings Designatum Contrib) := Grid.KsmdBullSeven G abbrev KsmdBullEight (G : CoreReadings Designatum Contrib) := Grid.KsmdBullEight G abbrev KsmdBullNine (G : CoreReadings Designatum Contrib) := Grid.KsmdBullNine G abbrev ShareDropRun (G : CoreReadings Designatum Contrib) := Grid.ShareDropRun G abbrev KsmdBullTen (G : CoreReadings Designatum Contrib) {Macro : Type} (S : Grid.SentienceReading G) (κ : Grid.DirectedConvention.BeingConvention.BeingCoarsening G Macro) := Grid.KsmdBullTen G S κ abbrev StrongKsmdBullTen (G : CoreReadings Designatum Contrib) {Macro : Type} (S : Grid.SentienceReading G) (κ : Grid.DirectedConvention.BeingConvention.BeingCoarsening G Macro) := Grid.StrongKsmdBullTen G S κ abbrev rankLanguage (G : CoreReadings Designatum Contrib) := Grid.rankLanguage G abbrev RecordedRankUtterance (G : CoreReadings Designatum Contrib) := Grid.RecordedRankUtterance G abbrev KenChuToShape (G : CoreReadings Designatum Contrib) {Macro : Type} (S : Grid.SentienceReading G) (κ : Grid.DirectedConvention.BeingConvention.BeingCoarsening G Macro) := Grid.KenChuToShape G S κ end CoreReadings end KannoSoe ===== FILE: KannoSoe/Doctrines/CorrelationsNegative.lean ===== /- ================================================================================ KannoSoe.Doctrines.CorrelationsNegative Negative witnesses for Bulls, ranks, and stage-coarsenings ================================================================================ -/ import KannoSoe.Doctrines.Correlations namespace KannoSoe namespace CorrelationsNegative open Grid.DirectedConvention open Grid.DirectedConvention.BeingConvention /- ============================================================================== Bull 9 without Bull 10 ============================================================================== -/ inductive SolitaryDesignatum | solo | other | call | response | soloOccurrence | otherOccurrence deriving DecidableEq def solitaryOccurrence : OccurrenceReading SolitaryDesignatum where occurrence | .soloOccurrence | .otherOccurrence => True | _ => False isBeing | .solo | .other => True | _ => False isCall d := d = .call isResponse d := d = .response agent | .soloOccurrence => .solo | .otherOccurrence => .other | d => d call | .soloOccurrence | .otherOccurrence => .call | d => d response | .soloOccurrence | .otherOccurrence => .response | d => d /-- A pole responder in a world where delivery never crosses fibers. -/ def solitaryGrid : CoreReadings SolitaryDesignatum Nat where occurrence := solitaryOccurrence response := { respondsTo := fun b c => match b, c with | .solo, .call | .other, .call => some .response | _, _ => none } placement := { grade := fun _ => 0 } conditioning := { conditions := fun deed reception => solitaryOccurrence.agent deed = solitaryOccurrence.agent reception } def identityCoarsening : BeingCoarsening solitaryGrid SolitaryDesignatum where proj := id def solitarySentience : solitaryGrid.SentienceReading := Grid.SentienceReading.allSentient solitaryGrid theorem solo_bullNine : solitaryGrid.KsmdBullNine SolitaryDesignatum.solo := by constructor · intro c hc change c = SolitaryDesignatum.call at hc subst c exact ⟨SolitaryDesignatum.response, rfl⟩ · intro _w _hactual _hagent exact Nat.le_refl 0 theorem solo_not_bullTen : ¬ solitaryGrid.KsmdBullTen solitarySentience identityCoarsening SolitaryDesignatum.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.KsmdBullNine SolitaryDesignatum.solo ∧ ¬ solitaryGrid.KsmdBullTen solitarySentience identityCoarsening SolitaryDesignatum.solo := ⟨solo_bullNine, solo_not_bullTen⟩ /- ============================================================================== No grid-carried recovery of a unique stage boundary ============================================================================== -/ inductive StageDesignatum | fineFalse | fineTrue | call | response | falseOccurrence | trueOccurrence deriving DecidableEq def stageOccurrence : OccurrenceReading StageDesignatum where occurrence | .falseOccurrence | .trueOccurrence => True | _ => False isBeing | .fineFalse | .fineTrue => True | _ => False isCall d := d = .call isResponse d := d = .response agent | .falseOccurrence => .fineFalse | .trueOccurrence => .fineTrue | d => d call | .falseOccurrence | .trueOccurrence => .call | d => d response | .falseOccurrence | .trueOccurrence => .response | d => d /-- Two fine tags with identical grid data, as in the being-boundary witness. -/ def stageGrid : CoreReadings StageDesignatum Nat where occurrence := stageOccurrence response := { respondsTo := fun _ _ => some .response } placement := { grade := fun _ => 0 } conditioning := { conditions := fun _ _ => True } def stageMerge : stageGrid.StageScheme Unit where proj _ := () def stageSplit : stageGrid.StageScheme StageDesignatum where proj := id theorem stageMerge_same_fiber : stageMerge.SameFiber StageDesignatum.fineFalse StageDesignatum.fineTrue := rfl theorem stageSplit_not_same_fiber : ¬ stageSplit.SameFiber StageDesignatum.fineFalse StageDesignatum.fineTrue := by intro h cases h abbrev W := stageGrid.Weld abbrev GridData : Type := (StageDesignatum → StageDesignatum → Option StageDesignatum) × (StageDesignatum → Nat) × (W → W → Prop) def gridData : GridData := (stageGrid.respondsTo, stageGrid.grade, stageGrid.conditions) def mergedBoundary (_p _q : StageDesignatum) : Prop := True def splitBoundary (p q : StageDesignatum) : 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 → StageDesignatum → StageDesignatum → Prop, recover gridData = mergedBoundary ∧ recover gridData = splitBoundary := by rintro ⟨recover, hmerge, hsplit⟩ have hmerged : recover gridData .fineFalse .fineTrue := by rw [hmerge] exact True.intro have hsplitNot : ¬ recover gridData .fineFalse .fineTrue := by rw [hsplit] intro h cases h exact hsplitNot hmerged end CorrelationsNegative end KannoSoe ===== FILE: KannoSoe/Doctrines/Deliberation.lean ===== /- ================================================================================ KannoSoe.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 KannoSoe.Consequences.Basic namespace KannoSoe namespace Grid variable {Designatum Contrib : Type} [PreorderBot Contrib] variable (G : CoreReadings Designatum 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 : CoreReadings Designatum 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 : CoreReadings Designatum 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 : Designatum, κ.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 : CoreReadings Designatum 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 : CoreReadings Designatum Contrib) : ClaimLanguage G where Claim := DeliveryCommand G Holds | .floor, _ => False | .actTime _, claim => DirectedConvention.DeliveredTo G claim.deed claim.reception omit [PreorderBot Contrib] in /-- 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 cases hoff : u.offeredAt with | floor => rw [hoff] at hfit exact hfit.elim | actTime _ => rw [hoff] 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 {Designatum Contrib : Type} [PreorderBot Contrib] (G : CoreReadings Designatum 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 {Designatum Contrib α : Type} [PreorderBot Contrib] (G : CoreReadings Designatum 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. -/ inductive ObjectiveDesignatum | falseAgent | trueAgent | cue | response | falseOccurrence | trueOccurrence deriving DecidableEq def objectiveOccurrence : OccurrenceReading ObjectiveDesignatum where occurrence d := d = .falseOccurrence ∨ d = .trueOccurrence isBeing d := d = .falseAgent ∨ d = .trueAgent isCall d := d = .cue isResponse d := d = .response agent d := match d with | .falseOccurrence => .falseAgent | .trueOccurrence => .trueAgent | _ => d call d := match d with | .falseOccurrence | .trueOccurrence => .cue | _ => d response d := match d with | .falseOccurrence | .trueOccurrence => .response | _ => d def objectiveGrid : CoreReadings ObjectiveDesignatum Nat where occurrence := objectiveOccurrence response := { respondsTo := fun b c => if (b = .falseAgent ∨ b = .trueAgent) ∧ c = .cue then some .response else none } placement := { grade := fun d => match d with | .falseOccurrence => 2 | .trueOccurrence => 1 | _ => 0 } conditioning := { conditions := fun _ _ => True } instance objectiveGrid_isShareDrop_decidable (before : Config Nat) (received : objectiveGrid.Weld) : Decidable (objectiveGrid.IsShareDrop before received) := by rcases received with ⟨d, hd⟩ cases d with | falseAgent | trueAgent | cue | response => change Decidable (((0 : Nat) ≤ before.tendency) ∧ ¬ before.tendency ≤ (0 : Nat)) infer_instance | falseOccurrence => change Decidable (((2 : Nat) ≤ before.tendency) ∧ ¬ before.tendency ≤ (2 : Nat)) infer_instance | trueOccurrence => 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 p := if p = .trueAgent then true else false 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 := ⟨.falseOccurrence, Or.inl rfl⟩ def wTrue : objectiveGrid.Weld := ⟨.trueOccurrence, Or.inr rfl⟩ 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 := objectiveGrid.Weld /-- The grid data visible to a convention-free recovery function. -/ abbrev GridData : Type := (ObjectiveDesignatum -> ObjectiveDesignatum -> Option ObjectiveDesignatum) × (ObjectiveDesignatum -> Nat) × (ObjectiveDesignatum -> ObjectiveDesignatum -> Prop) def gridData : GridData := (objectiveGrid.respondsTo, objectiveGrid.grade, objectiveGrid.conditioning.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 TransferDesignatum | teacher | seen | fresh | track | lands | misses | seenOccurrence | landingFreshOccurrence | missingFreshOccurrence | staticFreshOccurrence deriving DecidableEq namespace Teacher abbrev teacher : TransferDesignatum := .teacher end Teacher namespace Call abbrev seen : TransferDesignatum := .seen abbrev fresh : TransferDesignatum := .fresh end Call namespace Response abbrev track : TransferDesignatum := .track abbrev lands : TransferDesignatum := .lands abbrev misses : TransferDesignatum := .misses end Response def trackClass : TransferDesignatum -> Prop | .seen => True | _ => False def transferOccurrence : OccurrenceReading TransferDesignatum where occurrence d := d = .seenOccurrence ∨ d = .landingFreshOccurrence ∨ d = .missingFreshOccurrence ∨ d = .staticFreshOccurrence isBeing d := d = .teacher isCall d := d = .seen ∨ d = .fresh isResponse d := d = .track ∨ d = .lands ∨ d = .misses agent d := match d with | .seenOccurrence | .landingFreshOccurrence | .missingFreshOccurrence | .staticFreshOccurrence => .teacher | _ => d call d := match d with | .seenOccurrence => .seen | .landingFreshOccurrence | .missingFreshOccurrence | .staticFreshOccurrence => .fresh | _ => d response d := match d with | .seenOccurrence | .staticFreshOccurrence => .track | .landingFreshOccurrence => .lands | .missingFreshOccurrence => .misses | _ => d def trackedOccurrence : TransferDesignatum → TransferDesignatum | .seen => .seenOccurrence | d => d def landingGrid : CoreReadings TransferDesignatum Nat where occurrence := transferOccurrence response := { respondsTo := fun b c => if b = .teacher then match c with | .seen => some .track | .fresh => some .lands | _ => none else none } placement := { grade := fun d => match d with | .seenOccurrence => 5 | .landingFreshOccurrence => 0 | _ => 0 } conditioning := { conditions := fun _ _ => True } def missingGrid : CoreReadings TransferDesignatum Nat where occurrence := transferOccurrence response := { respondsTo := fun b c => if b = .teacher then match c with | .seen => some .track | .fresh => some .misses | _ => none else none } placement := { grade := fun d => match d with | .seenOccurrence => 5 | .missingFreshOccurrence => 1 | _ => 0 } conditioning := { conditions := fun _ _ => True } /-- The restricted track record: response and grade behavior on the seen call. -/ abbrev TrackData : Type := Option TransferDesignatum × Nat def landingTrackData : TrackData := (landingGrid.respondsTo Teacher.teacher Call.seen, landingGrid.grade .seenOccurrence) def missingTrackData : TrackData := (missingGrid.respondsTo Teacher.teacher Call.seen, missingGrid.grade .seenOccurrence) theorem restricted_track_agrees : landingTrackData = missingTrackData := rfl theorem respondsTo_agrees_on_trackClass {c : TransferDesignatum} (hc : trackClass c) : landingGrid.respondsTo Teacher.teacher c = missingGrid.respondsTo Teacher.teacher c := by cases c <;> simp_all [trackClass, landingGrid, missingGrid] theorem grade_agrees_on_trackClass {c : TransferDesignatum} (hc : trackClass c) : landingGrid.grade (trackedOccurrence c) = missingGrid.grade (trackedOccurrence c) := by cases c <;> simp_all [trackClass, trackedOccurrence, landingGrid, missingGrid] def landingFreshEffect : Nat := landingGrid.grade .landingFreshOccurrence def missingFreshEffect : Nat := missingGrid.grade .missingFreshOccurrence 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 {Designatum Contrib : Type} [PreorderBot Contrib] {G : CoreReadings Designatum Contrib} {b : Designatum} {seen fresh : Designatum} {rSeen rFresh : Designatum} (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 : CoreReadings TransferDesignatum Nat where occurrence := transferOccurrence response := { respondsTo := fun b _ => if b = .teacher then some .track else none } placement := { grade := fun _ => 5 } conditioning := { conditions := fun _ _ => True } theorem static_responseInvariant : staticGrid.ResponseInvariant Teacher.teacher := by intro _c₁ _c₂ _r₁ _r₂ h₁ h₂ change some .track = some _r₁ at h₁ change some .track = some _r₂ at h₂ exact Option.some.inj (h₁.symm.trans h₂) 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 Designatum | planner | deed | fruit | utter | deedOccurrence | receptionOccurrence deriving DecidableEq namespace Being abbrev planner : Designatum := .planner end Being namespace Call abbrev deed : Designatum := .deed abbrev fruit : Designatum := .fruit end Call namespace Response abbrev utter : Designatum := .utter end Response def commandOccurrence : OccurrenceReading Designatum where occurrence d := d = .deedOccurrence ∨ d = .receptionOccurrence isBeing d := d = .planner isCall d := d = .deed ∨ d = .fruit isResponse d := d = .utter agent d := match d with | .deedOccurrence | .receptionOccurrence => .planner | _ => d call d := match d with | .deedOccurrence => .deed | .receptionOccurrence => .fruit | _ => d response d := match d with | .deedOccurrence | .receptionOccurrence => .utter | _ => d def commandGrid : CoreReadings Designatum Nat where occurrence := commandOccurrence response := { respondsTo := fun b c => if b = .planner ∧ (c = .deed ∨ c = .fruit) then some .utter else none } placement := { grade := fun _ => 1 } conditioning := { conditions := fun _ _ => False } def deed : commandGrid.Weld := ⟨.deedOccurrence, Or.inl rfl⟩ def reception : commandGrid.Weld := ⟨.receptionOccurrence, Or.inr rfl⟩ 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 KannoSoe ===== FILE: KannoSoe/Doctrines/Doors.lean ===== /- ================================================================================ KannoSoe.Doctrines.Doors Three-door diagnosis, production, and fine-being quiet ================================================================================ -/ import KannoSoe.Consequences.Taxonomy namespace KannoSoe /-- The canonical three doors through which an occurrence may be diagnosed. -/ inductive Door | body | speech | mind deriving DecidableEq namespace Grid open DirectedConvention open DirectedConvention.BeingConvention variable {Designatum Contrib : Type} [PreorderBot Contrib] variable {G : CoreReadings Designatum Contrib} /-- A total, model-supplied diagnosis of every fine weld by door. -/ structure DoorReading (G : CoreReadings Designatum Contrib) where door : G.Weld → Door /-- A supplied voicing layer. Voicing is deliberately not restricted by door: thoughts and expressive bodily deeds may be represented by the same primitive, while testimonial predicates impose their own speech boundary. -/ structure SpeechReading (G : CoreReadings Designatum Contrib) (L : ClaimLanguage G) extends DoorReading G where voices : G.Weld → Option L.Claim /-- An actual weld together with the claim that the supplied reading says it produces. Production itself is door-neutral. -/ structure ProducedUtterance {G : CoreReadings Designatum Contrib} {L : ClaimLanguage G} (sr : SpeechReading G L) where weld : G.Weld actual : G.Actual weld content : L.Claim voiced : sr.voices weld = some content namespace ProducedUtterance /-- Speech production enters the testimonial layer at its own act-time. The door proof is the structural fence excluding mind-door productions from `RecordedUtterance`, `Fidelity`, `Faith`, and `Ethics`. -/ def toRecorded {L : ClaimLanguage G} {sr : SpeechReading G L} (u : ProducedUtterance sr) (_hspeech : sr.door u.weld = .speech) : RecordedUtterance G L where weld := u.weld actual := u.actual offeredAt := Tier.actTime u.weld content := u.content omit [PreorderBot Contrib] in @[simp] theorem toRecorded_weld {L : ClaimLanguage G} {sr : SpeechReading G L} (u : ProducedUtterance sr) (hspeech : sr.door u.weld = .speech) : (u.toRecorded hspeech).weld = u.weld := rfl omit [PreorderBot Contrib] in @[simp] theorem toRecorded_offeredAt {L : ClaimLanguage G} {sr : SpeechReading G L} (u : ProducedUtterance sr) (hspeech : sr.door u.weld = .speech) : (u.toRecorded hspeech).offeredAt = Tier.actTime u.weld := rfl end ProducedUtterance /-- Speech-door production that misfits its token-reflexive act-time tier and carries a live self-pole. Identifying this derivable schema with canonical deliberate lying is a separate modelling claim. -/ def KsmdDefiledFalsehood {L : ClaimLanguage G} (sr : SpeechReading G L) (u : ProducedUtterance sr) : Prop := sr.door u.weld = .speech ∧ ¬ L.TrueAt (Tier.actTime u.weld) u.content ∧ G.HasSelfPoleIndex u.weld /-- Fine-being quiet on a supplied class of welds. -/ def QuietOn (G : CoreReadings Designatum Contrib) (b : Designatum) (ws : G.Weld → Prop) : Prop := ∀ w, G.Actual w → w.agent = b → ws w → AtBot (G.share w) /-- Quietness restricted to one supplied door. -/ def DoorQuiet (dr : DoorReading G) (b : Designatum) (d : Door) : Prop := QuietOn G b (fun w => dr.door w = d) /-- Every bad-content production by `b` at door `d` is at the pole. Full `QuietOn G b ⊤` therefore covers every door, including deceptive gesture; a merely speech-and-mind-quiet regional figure does not cover the body door. -/ def NoDefiledVoicing {L : ClaimLanguage G} (sr : SpeechReading G L) (b : Designatum) (bad : L.Claim → Prop) (d : Door) : Prop := ∀ u : ProducedUtterance sr, u.weld.agent = b → sr.door u.weld = d → bad u.content → AtBot (G.share u.weld) /-- Quietness is antitone in the selected weld-class. -/ theorem quietOn_mono {b : Designatum} {ws vs : G.Weld → Prop} (hsub : ∀ w, ws w → vs w) (hquiet : QuietOn G b vs) : QuietOn G b ws := by intro w hactual hagent hws exact hquiet w hactual hagent (hsub w hws) /-- Total quietness supplies quietness on every weld-class. -/ theorem quietOn_univ {b : Designatum} {ws : G.Weld → Prop} (hquiet : QuietOn G b (fun _ => True)) : QuietOn G b ws := quietOn_mono (fun _ _ => True.intro) hquiet /-- Total quietness is exactly quietness through all three doors. -/ theorem arhat_iff_three_doors_quiet (dr : DoorReading G) (b : Designatum) : QuietOn G b (fun _ => True) ↔ DoorQuiet dr b .body ∧ DoorQuiet dr b .speech ∧ DoorQuiet dr b .mind := by constructor · intro h exact ⟨quietOn_univ h, quietOn_univ h, quietOn_univ h⟩ · rintro ⟨hbody, hspeech, hmind⟩ w hactual hagent _ cases hdoor : dr.door w with | body => exact hbody w hactual hagent hdoor | speech => exact hspeech w hactual hagent hdoor | mind => exact hmind w hactual hagent hdoor /-- A terminus is quiet on every actual weld it produces. -/ theorem arhat_of_terminus (_dr : DoorReading G) {b : Designatum} (hterm : G.Terminus b) : QuietOn G b (fun _ => True) := by intro w hactual hagent _ subst hagent exact G.atBot_of_terminus_response hterm hactual /-- Fine total quiet excludes a live self-pole on every actual weld of `b`. -/ theorem conceit_excluded_of_quietOn {b : Designatum} (hquiet : QuietOn G b (fun _ => True)) {w : G.Weld} (hactual : G.Actual w) (hagent : w.agent = b) : ¬ G.HasSelfPoleIndex w := G.no_self_pole_index_of_atBot w (hquiet w hactual hagent True.intro) /-- A pole production cannot instantiate defiled falsehood. -/ theorem not_defiledFalsehood_of_atBot {L : ClaimLanguage G} {sr : SpeechReading G L} {u : ProducedUtterance sr} (hbot : AtBot (G.share u.weld)) : ¬ KsmdDefiledFalsehood sr u := by intro hfalse exact hfalse.right.right hbot /-- Speech-door quiet excludes defiled falsehood by that fine being. -/ theorem no_defiledFalsehood_of_speechDoorQuiet {L : ClaimLanguage G} {sr : SpeechReading G L} {b : Designatum} (hquiet : DoorQuiet sr.toDoorReading b .speech) : ∀ u : ProducedUtterance sr, u.weld.agent = b → ¬ KsmdDefiledFalsehood sr u := by intro u hagent hfalse exact hfalse.right.right (hquiet u.weld u.actual hagent hfalse.left) /-- A terminus producer makes no defiled falsehood. -/ theorem no_defiledFalsehood_of_terminus {L : ClaimLanguage G} (sr : SpeechReading G L) {b : Designatum} (hterm : G.Terminus b) : ∀ u : ProducedUtterance sr, u.weld.agent = b → ¬ KsmdDefiledFalsehood sr u := no_defiledFalsehood_of_speechDoorQuiet (quietOn_univ (arhat_of_terminus sr.toDoorReading hterm)) /-- Three-door quietness, in its canonical arhat form, excludes falsehood. -/ theorem no_defiledFalsehood_of_arhat {L : ClaimLanguage G} (sr : SpeechReading G L) {b : Designatum} (harhat : DoorQuiet sr.toDoorReading b .body ∧ DoorQuiet sr.toDoorReading b .speech ∧ DoorQuiet sr.toDoorReading b .mind) : ∀ u : ProducedUtterance sr, u.weld.agent = b → ¬ KsmdDefiledFalsehood sr u := no_defiledFalsehood_of_speechDoorQuiet harhat.right.left /-- Door quiet supplies the content-parametric no-defiled-voicing schema. -/ theorem noDefiledVoicing_of_doorQuiet {L : ClaimLanguage G} {sr : SpeechReading G L} {b : Designatum} {d : Door} (hquiet : DoorQuiet sr.toDoorReading b d) (bad : L.Claim → Prop) : NoDefiledVoicing sr b bad d := by intro u hagent hdoor _ exact hquiet u.weld u.actual hagent hdoor /-- Mind-door quiet excludes a live self-pole in any thought-production. This is freedom from defiled thought (the kleśāvaraṇa side), not the truth of the thought. Thought-truth is the later no-nescience conjunct on the jñeyāvaraṇa side. -/ theorem no_defiled_thought_of_mindDoorQuiet {L : ClaimLanguage G} {sr : SpeechReading G L} {b : Designatum} (hquiet : DoorQuiet sr.toDoorReading b .mind) : ∀ u : ProducedUtterance sr, u.weld.agent = b → sr.door u.weld = .mind → ¬ G.HasSelfPoleIndex u.weld := by intro u hagent hmind hidx exact hidx (hquiet u.weld u.actual hagent hmind) /-- At the identity coarsening, old fiber-at-pole and fine total quiet are the same predicate. This is the retirement bridge for the old arhat display. -/ theorem quietOn_univ_iff_fiberAtPole_id (b : Designatum) : QuietOn G b (fun _ => True) ↔ (BeingCoarsening.id G).FiberAtPole b := by constructor · intro h w hactual hfiber exact h w hactual hfiber True.intro · intro h w hactual hagent _ exact h w hactual hagent /-- Series-level quiet is derived display: precisely all fine tags in the coarsening fiber are quiet on the selected weld-class. -/ theorem seriesQuiet_iff_forall_fine {Macro : Type} (kappa : BeingCoarsening G Macro) (b : Macro) (ws : G.Weld → Prop) : (∀ p : Designatum, kappa.proj p = b → QuietOn G p ws) ↔ ∀ w : G.Weld, G.Actual w → kappa.InFiber b w → ws w → AtBot (G.share w) := by constructor · intro hfine w hactual hfiber hws exact hfine w.agent hfiber w hactual rfl hws · intro hseries p hp w hactual hagent hws apply hseries w hactual · simpa [BeingCoarsening.InFiber, hagent] using hp · exact hws end Grid namespace CoreReadings variable {Designatum Contrib : Type} [PreorderBot Contrib] abbrev DoorReading (G : CoreReadings Designatum Contrib) := Grid.DoorReading G abbrev SpeechReading (G : CoreReadings Designatum Contrib) := Grid.SpeechReading G abbrev ProducedUtterance (G : CoreReadings Designatum Contrib) {L : Grid.ClaimLanguage G} (sr : Grid.SpeechReading G L) := Grid.ProducedUtterance sr abbrev KsmdDefiledFalsehood (G : CoreReadings Designatum Contrib) {L : Grid.ClaimLanguage G} (sr : Grid.SpeechReading G L) := Grid.KsmdDefiledFalsehood sr abbrev QuietOn (G : CoreReadings Designatum Contrib) := Grid.QuietOn G abbrev DoorQuiet (G : CoreReadings Designatum Contrib) := Grid.DoorQuiet (G := G) abbrev NoDefiledVoicing (G : CoreReadings Designatum Contrib) {L : Grid.ClaimLanguage G} (sr : Grid.SpeechReading G L) := Grid.NoDefiledVoicing sr end CoreReadings end KannoSoe ===== FILE: KannoSoe/Doctrines/DoorsNegative.lean ===== /- ================================================================================ KannoSoe.Doctrines.DoorsNegative Recovery limits and inhabitation witnesses for doors and production ================================================================================ -/ import KannoSoe.Doctrines.Doors namespace KannoSoe namespace DoorsNegative open Grid /-- A two-weld grid whose visible response, grade, and delivery data do not choose a door or a voicing interpretation. -/ inductive Designatum | being | falseCall | trueCall | response | falseOccurrence | trueOccurrence deriving DecidableEq def occurrence : OccurrenceReading Designatum where occurrence d := d = .falseOccurrence ∨ d = .trueOccurrence isBeing d := d = .being isCall d := d = .falseCall ∨ d = .trueCall isResponse d := d = .response agent d := match d with | .falseOccurrence | .trueOccurrence => .being | _ => d call d := match d with | .falseOccurrence => .falseCall | .trueOccurrence => .trueCall | _ => d response d := match d with | .falseOccurrence | .trueOccurrence => .response | _ => d def grid : CoreReadings Designatum Nat where occurrence := occurrence response := { respondsTo := fun b c => match b, c with | .being, .falseCall | .being, .trueCall => some .response | _, _ => none } placement := { grade := fun _ => 1 } conditioning := { conditions := fun _ _ => True } def wFalse : grid.Weld := ⟨.falseOccurrence, Or.inl rfl⟩ def wTrue : grid.Weld := ⟨.trueOccurrence, Or.inr rfl⟩ theorem wFalse_actual : grid.Actual wFalse := rfl theorem wTrue_actual : grid.Actual wTrue := rfl theorem wFalse_ne_wTrue : wFalse ≠ wTrue := by decide abbrev W := grid.Weld abbrev GridData : Type := (Designatum → Designatum → Option Designatum) × (Designatum → Nat) × (Designatum → Designatum → Prop) def gridData : GridData := (grid.respondsTo, grid.grade, grid.conditioning.conditions) /-- A merged door reading diagnoses every weld as bodily. -/ def mergedDoorReading : grid.DoorReading where door _ := .body /-- A split reading diagnoses the second weld as mind-door. -/ def splitDoorReading : grid.DoorReading where door w := if w = wFalse then .body else .mind theorem door_readings_disagree : mergedDoorReading.door wTrue = .body ∧ splitDoorReading.door wTrue = .mind := by constructor <;> rfl /-- No function of the identical visible grid data recovers a unique total door classification. This replaces the old soma-region boundary witness. -/ theorem no_door_boundary_recovery : ¬ ∃ recover : GridData → W → Door, recover gridData = mergedDoorReading.door ∧ recover gridData = splitDoorReading.door := by rintro ⟨recover, hmerged, hsplit⟩ have hbody : recover gridData wTrue = .body := by rw [hmerged] rfl have hmind : recover gridData wTrue = .mind := by rw [hsplit] rfl rw [hbody] at hmind cases hmind /-- A one-claim language used to isolate production identity from content. -/ def language : ClaimLanguage grid where Claim := Unit Holds _ _ := False def speechReading : grid.SpeechReading language where door _ := .speech voices _ := some () def productionFalse : grid.ProducedUtterance speechReading where weld := wFalse actual := wFalse_actual content := () voiced := rfl def productionTrue : grid.ProducedUtterance speechReading where weld := wTrue actual := wTrue_actual content := () voiced := rfl /-- Equal record content cannot recover which of two distinct welds produced it; occurrence fidelity therefore remains an independent hypothesis. -/ theorem no_production_recovery : ¬ ∃ recover : language.Claim → grid.Weld, recover productionFalse.content = productionFalse.weld ∧ recover productionTrue.content = productionTrue.weld := by rintro ⟨recover, hfalse, htrue⟩ apply wFalse_ne_wTrue calc wFalse = recover () := hfalse.symm _ = wTrue := htrue def mindDoorReading : grid.DoorReading where door _ := .mind def voicedReading : grid.SpeechReading language where toDoorReading := mindDoorReading voices _ := some () def silentReading : grid.SpeechReading language where toDoorReading := mindDoorReading voices _ := none /-- Voicing, including thought as mind-door voicing, is not recoverable from response/grade/delivery data. It is supplied diagnosis-time data. -/ theorem no_voicing_recovery : ¬ ∃ recover : GridData → W → Option language.Claim, recover gridData = voicedReading.voices ∧ recover gridData = silentReading.voices := by rintro ⟨recover, hvis, hsil⟩ have hsome : recover gridData wFalse = some () := by rw [hvis] rfl have hnone : recover gridData wFalse = none := by rw [hsil] rfl rw [hsome] at hnone cases hnone theorem wFalse_hasSelfPoleIndex : grid.HasSelfPoleIndex wFalse := by dsimp [Grid.HasSelfPoleIndex, Grid.share, grid, wFalse, AtBot, shareBot] show ¬ (1 : Nat) ≤ 0 decide /-- The defiled-falsehood schema is inhabited independently of the fox model. -/ theorem defiledFalsehood_inhabited : grid.KsmdDefiledFalsehood speechReading productionFalse := ⟨rfl, by dsimp [language, ClaimLanguage.TrueAt] exact ⟨fun h => h, wFalse_hasSelfPoleIndex⟩⟩ end DoorsNegative end KannoSoe ===== FILE: KannoSoe/Doctrines/EffectiveTerminusNegative.lean ===== /- ================================================================================ KannoSoe.Doctrines.EffectiveTerminusNegative Actual-run underdetermination of effective termination ================================================================================ The standing predicate is intentionally stronger than any actual-run transcript that omits the delivery register. Replacing only `conditions` can leave every mounted response and share unchanged while flipping `KsmdEffectiveTerminus`. Reading and motivation: Identification/Commentary.lean, C.4. -/ import KannoSoe.Doctrines.Shusho import KannoSoe.Doctrines.SraddhaNegative namespace KannoSoe namespace EffectiveTerminusNegative open Grid open Grid.DirectedConvention abbrev baseGrid : CoreReadings SraddhaNegative.CaseDesignatum Nat := SraddhaNegative.zeroEffectGrid abbrev sealedGrid : CoreReadings SraddhaNegative.CaseDesignatum Nat := baseGrid.withConditions (fun _ _ => False) def addedDelivery (deed reception : SraddhaNegative.CaseDesignatum) : Prop := deed = .sraddhaOccurrence ∧ reception = .receiverOccurrence abbrev openedGrid : CoreReadings SraddhaNegative.CaseDesignatum Nat := sealedGrid.withConditions addedDelivery def b : SraddhaNegative.CaseDesignatum := .sraddha def liveBefore : Config Nat := SraddhaNegative.liveBefore def deed : sealedGrid.Weld := ⟨.sraddhaOccurrence, True.intro⟩ def reception : sealedGrid.Weld := ⟨.receiverOccurrence, True.intro⟩ theorem sealed_responsiveTerminus : sealedGrid.ResponsiveTerminus b := SraddhaNegative.sraddha_responsiveTerminus theorem sealed_undelivered : ∀ (deed reception : sealedGrid.Weld), deed.agent = b → ¬ Grid.DirectedConvention.DeliveredTo sealedGrid deed reception := by intro deed reception _hdeed hdel exact hdel theorem sealed_ksmdEffectiveTerminus : KsmdEffectiveTerminus sealedGrid b := ksmdEffectiveTerminus_of_responsiveTerminus_of_undelivered sealedGrid sealed_responsiveTerminus sealed_undelivered theorem opened_delivered : Grid.DirectedConvention.DeliveredTo openedGrid deed reception := by exact ⟨rfl, rfl⟩ theorem opened_liveBefore_not_atBot : ¬ AtBot liveBefore.tendency := SraddhaNegative.liveBefore_not_atBot theorem opened_not_hasShareDropLanding : ¬ HasShareDropLanding openedGrid liveBefore deed := by rintro ⟨received, hland⟩ have hreceiver : received.1 = SraddhaNegative.CaseDesignatum.receiverOccurrence := hland.left.left.right have hdrop : Strict (openedGrid.share received) liveBefore.tendency := hland.right rcases received with ⟨d, hd⟩ change d = SraddhaNegative.CaseDesignatum.receiverOccurrence at hreceiver subst d change Strict (1 : Nat) 1 at hdrop exact strict_irrefl (1 : Nat) hdrop theorem opened_not_ksmdEffectiveTerminus : ¬ KsmdEffectiveTerminus openedGrid b := by intro hstanding exact opened_not_hasShareDropLanding (hstanding.right liveBefore deed reception rfl opened_liveBefore_not_atBot opened_delivered) /-- The actual-run transcript used by this collision: response function plus grade/share data, deliberately excluding the delivery relation. -/ abbrev RunData : Type := (SraddhaNegative.CaseDesignatum -> SraddhaNegative.CaseDesignatum -> Option SraddhaNegative.CaseDesignatum) × (SraddhaNegative.CaseDesignatum -> Nat) def sealedRunData : RunData := (sealedGrid.respondsTo, sealedGrid.grade) def openedRunData : RunData := (openedGrid.respondsTo, openedGrid.grade) theorem runData_agrees : sealedRunData = openedRunData := rfl theorem actual_iff_agrees (w : sealedGrid.Weld) : sealedGrid.Actual w ↔ openedGrid.Actual w := Iff.rfl theorem share_agrees (w : sealedGrid.Weld) : sealedGrid.share w = openedGrid.share w := rfl theorem respondsTo_agrees (being cue : SraddhaNegative.CaseDesignatum) : sealedGrid.respondsTo being cue = openedGrid.respondsTo being cue := rfl theorem effectiveTerminus_collision : sealedRunData = openedRunData ∧ KsmdEffectiveTerminus sealedGrid b ∧ ¬ KsmdEffectiveTerminus openedGrid b := ⟨runData_agrees, sealed_ksmdEffectiveTerminus, opened_not_ksmdEffectiveTerminus⟩ /-- No Boolean estimator from this actual-run transcript can recover the effective-terminus predicate across the collision. -/ theorem no_effectiveTerminus_recovery_from_run : ¬ ∃ estimate : RunData -> Bool, estimate sealedRunData = true ∧ estimate openedRunData = false := by rintro ⟨estimate, hsealed, hopened⟩ have hsame : estimate sealedRunData = estimate openedRunData := congrArg estimate runData_agrees have htruefalse : true = false := by calc true = estimate sealedRunData := hsealed.symm _ = estimate openedRunData := hsame _ = false := hopened cases htruefalse theorem actual_run_data_underdetermines_effectiveTerminus : KsmdEffectiveTerminus sealedGrid b ∧ ¬ KsmdEffectiveTerminus openedGrid b ∧ sealedRunData = openedRunData ∧ ¬ ∃ estimate : RunData -> Bool, estimate sealedRunData = true ∧ estimate openedRunData = false := ⟨sealed_ksmdEffectiveTerminus, opened_not_ksmdEffectiveTerminus, runData_agrees, no_effectiveTerminus_recovery_from_run⟩ end EffectiveTerminusNegative end KannoSoe ===== FILE: KannoSoe/Doctrines/Ethics.lean ===== /- ================================================================================ KannoSoe.Doctrines.Ethics Ethics as the bundled production-fidelity conditional ================================================================================ -/ import KannoSoe.Doctrines.Faith namespace KannoSoe namespace Grid namespace DirectedConvention variable {Designatum Contrib : Type} [PreorderBot Contrib] variable (G : CoreReadings Designatum Contrib) /-- The stance carries factive faith and the model-side assertion that its fidelity predicate is instantiated by actual speech productions. -/ structure KsmdEthicsStance (sr : SpeechReading G (ksmdPathClaimLanguage G)) (Fidelity : RecordedUtterance G (ksmdPathClaimLanguage G) → Prop) (Faith : Prop → Prop) (b : Designatum) : Prop where factive : Factive Faith faith : Faith (KsmdFullyEnlightened G sr b) fidelityProduces : ∀ record, Fidelity record → ProductionFidelity G sr record /-- The ethical code remains an implication type. The prior untied act-time witness is gone: production fidelity fixes the record's own act-time. -/ def KsmdEthicalCode (sr : SpeechReading G (ksmdPathClaimLanguage G)) (Fidelity : RecordedUtterance G (ksmdPathClaimLanguage G) → Prop) (Faith : Prop → Prop) (b : Designatum) : Prop := KsmdEthicsStance G sr Fidelity Faith b → ∀ u : RecordedUtterance G (ksmdPathClaimLanguage G), Fidelity u → u.weld.agent = b → DeliveredTo G u.content.deed u.content.reception → KsmdAversionContext G u.content.before u.content.reception → HasShareDropLanding G u.content.before u.content.deed theorem ksmd_stance_says_true {sr : SpeechReading G (ksmdPathClaimLanguage G)} {Fidelity : RecordedUtterance G (ksmdPathClaimLanguage G) → Prop} {Faith : Prop → Prop} {b : Designatum} (hstance : KsmdEthicsStance G sr Fidelity Faith b) (u : RecordedUtterance G (ksmdPathClaimLanguage G)) (hagent : u.weld.agent = b) (hfid : Fidelity u) : u.FitsOfferedTier := ksmd_says_true_of_faith G hstance.factive hstance.faith u hagent (hstance.fidelityProduces u hfid) theorem ksmd_ethics_landing_of_stance {sr : SpeechReading G (ksmdPathClaimLanguage G)} {Fidelity : RecordedUtterance G (ksmdPathClaimLanguage G) → Prop} {Faith : Prop → Prop} {b : Designatum} (hstance : KsmdEthicsStance G sr Fidelity Faith b) (u : RecordedUtterance G (ksmdPathClaimLanguage G)) (hagent : u.weld.agent = b) (hfid : Fidelity u) (hdel : DeliveredTo G u.content.deed u.content.reception) (hctx : KsmdAversionContext G u.content.before u.content.reception) : HasShareDropLanding G u.content.before u.content.deed := ksmd_path_landing_of_stance G hstance.factive hstance.faith u hagent (hstance.fidelityProduces u hfid) hdel hctx theorem ksmdEthicalCode_conditional (sr : SpeechReading G (ksmdPathClaimLanguage G)) (Fidelity : RecordedUtterance G (ksmdPathClaimLanguage G) → Prop) (Faith : Prop → Prop) (b : Designatum) : KsmdEthicalCode G sr Fidelity Faith b := by intro hstance u hfid hagent hdel hctx exact ksmd_ethics_landing_of_stance G hstance u hagent hfid hdel hctx theorem ksmdFaithOught_of_ethicalCode {sr : SpeechReading G (ksmdPathClaimLanguage G)} {Fidelity : RecordedUtterance G (ksmdPathClaimLanguage G) → Prop} {Faith : Prop → Prop} {b : Designatum} (hcode : KsmdEthicalCode G sr Fidelity Faith b) (u : RecordedUtterance G (ksmdPathClaimLanguage G)) : KsmdFaithOught G sr Fidelity Faith b u := by intro hfact hfaith hfid hproduces hagent hdel hctx exact hcode ⟨hfact, hfaith, hproduces⟩ u hfid hagent hdel hctx namespace BeingConvention namespace GridConvention def KsmdEthicsConditionalVoice : ErrorGrade := ErrorGrade.verdict def KsmdEthicsDetachedVoice : ErrorGrade := ErrorGrade.shortfall theorem ksmd_ethics_conditional_voice_assertable : ErrorGrade.voice KsmdEthicsConditionalVoice = VerdictVoice.assertable := rfl theorem ksmd_ethics_detached_voice_displayable : ErrorGrade.voice KsmdEthicsDetachedVoice = VerdictVoice.displayable := rfl end GridConvention end BeingConvention end DirectedConvention end Grid end KannoSoe ===== FILE: KannoSoe/Doctrines/EthicsNegative.lean ===== /- ================================================================================ KannoSoe.Doctrines.EthicsNegative Production-tied testimony and conditional ethics witnesses ================================================================================ -/ import KannoSoe.Doctrines.Ethics import KannoSoe.Doctrines.FaithNegative namespace KannoSoe namespace EthicsNegative open Grid open Grid.DirectedConvention open FaithNegative /-- The false thought from the strictness model cannot cross the testimonial boundary: its supplied door is mind, not speech. -/ theorem mind_production_not_testimony : ¬ reading.door mindProduction.weld = .speech := by intro h cases h /-- Re-read the same false production as speech to test the ethics boundary itself. This separate reading is deliberate: door typing is model-supplied diagnostic structure, not recoverable from the grid. -/ def falseSpeechReading : SpeechReading grid (ksmdPathClaimLanguage grid) where door _ := .speech voices w := match w.call with | .mind => some falseContent | _ => none def falseSpeechProduction : ProducedUtterance falseSpeechReading where weld := mindWeld actual := rfl content := falseContent voiced := rfl def falseRecord : RecordedUtterance grid (ksmdPathClaimLanguage grid) := falseSpeechProduction.toRecorded rfl def onlyFalseFidelity (record : RecordedUtterance grid (ksmdPathClaimLanguage grid)) : Prop := record = falseRecord /-- No factive ethics stance can license an admitted false speech production. The contradiction is tied to that production's own act-time; there is no free-standing tier witness. -/ theorem no_stance_over_false_speech (Faith : Prop → Prop) : ¬ KsmdEthicsStance grid falseSpeechReading onlyFalseFidelity Faith CaseDesignatum.producer := by intro hstance have hfit := ksmd_stance_says_true grid hstance falseRecord rfl rfl exact falseContent_not_trueAt hfit /-- At a pole prior there is no live aversion antecedent and hence no detached practical conclusion, regardless of what production-tied stance is hypothesized. -/ theorem no_ethics_bearing_at_pole (Fidelity : RecordedUtterance grid (ksmdPathClaimLanguage grid) → Prop) (Faith : Prop → Prop) (_hstance : KsmdEthicsStance grid reading Fidelity Faith CaseDesignatum.producer) : ¬ KsmdAversionContext grid poleBefore targetWeld ∧ ¬ HasShareDropLanding grid poleBefore mindWeld := ⟨no_ksmd_aversion_context_at_pole grid (Nat.le_refl 0) targetWeld, no_ksmd_path_at_pole grid (Nat.le_refl 0) mindWeld⟩ end EthicsNegative end KannoSoe ===== FILE: KannoSoe/Doctrines/Factors.lean ===== /- ================================================================================ KannoSoe.Doctrines.Factors Path-factor hold/release readings over door-aware weld-classes ================================================================================ -/ import KannoSoe.Doctrines.Fetters import KannoSoe.Doctrines.SuddenGradual namespace KannoSoe inductive PathFactor | rites | view | resolve | speech | conduct namespace PathFactor /-- Factor blocker classes are weld-classes. Speech is now the supplied speech-door class; conduct remains deliberately inert. -/ def blockerClass {Designatum Contrib : Type} [PreorderBot Contrib] {G : CoreReadings Designatum Contrib} (dr : G.DoorReading) (fr : G.FetterReading) : PathFactor → G.Weld → Prop | .rites, w => fr.provocationClass Fetter.ritesGrasp w | .view, w => fr.provocationClass Fetter.identityView w ∨ fr.provocationClass Fetter.doubt w | .resolve, w => fr.provocationClass Fetter.sensualDesire w ∨ fr.provocationClass Fetter.illWill w | .speech, w => dr.door w = .speech | .conduct, _ => False end PathFactor namespace Grid variable {Designatum Contrib : Type} [PreorderBot Contrib] variable (G : CoreReadings Designatum Contrib) theorem ritesView_union_covers_streamEntry_fetters (dr : G.DoorReading) (fr : G.FetterReading) (w : G.Weld) : (PathFactor.blockerClass dr fr .rites w ∨ PathFactor.blockerClass dr fr .view w) ↔ Path.cutClasses fr .streamEntry w := by constructor · rintro (hrites | hidentity | hdoubt) · exact ⟨.ritesGrasp, rfl, hrites⟩ · exact ⟨.identityView, rfl, hidentity⟩ · exact ⟨.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 | illWill | formDesire | formlessDesire | conceit | restlessness | ignorance => cases hf theorem resolve_covers_nonReturn_fetters (dr : G.DoorReading) (fr : G.FetterReading) (w : G.Weld) : PathFactor.blockerClass dr fr .resolve w ↔ ∃ f : Fetter, Fetter.abandonedAt f = .nonReturn ∧ fr.provocationClass f w := by constructor · rintro (hsensual | hill) · exact ⟨.sensualDesire, rfl, hsensual⟩ · exact ⟨.illWill, rfl, hill⟩ · rintro ⟨f, hf, hclass⟩ cases f with | sensualDesire => exact Or.inl hclass | illWill => exact Or.inr hclass | identityView | doubt | ritesGrasp | formDesire | formlessDesire | conceit | restlessness | ignorance => cases hf theorem lower_fetters_covered_by_rites_view_resolve (dr : G.DoorReading) (fr : G.FetterReading) (w : G.Weld) : (PathFactor.blockerClass dr fr .rites w ∨ PathFactor.blockerClass dr fr .view w ∨ PathFactor.blockerClass dr fr .resolve w) ↔ Path.cutClasses fr .nonReturn w := by constructor · rintro (hrites | hview | hresolve) · exact ⟨.ritesGrasp, Or.inl rfl, hrites⟩ · rcases hview with hidentity | hdoubt · exact ⟨.identityView, Or.inl rfl, hidentity⟩ · exact ⟨.doubt, Or.inl rfl, hdoubt⟩ · rcases hresolve with hsensual | hill · exact ⟨.sensualDesire, Or.inr rfl, hsensual⟩ · exact ⟨.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 | formlessDesire | conceit | restlessness | ignorance => rcases hf with h | h <;> cases h /-- A factor is held when the finite run contains an actual live weld of `b` in the factor's blocker class. -/ def FactorHeld (dr : G.DoorReading) (b : Designatum) (fr : G.FetterReading) (factor : PathFactor) (run : List G.Weld) : Prop := ∃ w ∈ run, G.Actual w ∧ w.agent = b ∧ PathFactor.blockerClass dr fr factor w ∧ G.HasSelfPoleIndex w /-- A factor is released when the fine being is quiet on its blocker class. -/ def FactorReleased (dr : G.DoorReading) (b : Designatum) (fr : G.FetterReading) (factor : PathFactor) : Prop := QuietOn G b (PathFactor.blockerClass dr fr factor) theorem not_factorHeld_of_factorReleased {dr : G.DoorReading} {b : Designatum} {fr : G.FetterReading} {factor : PathFactor} {run : List G.Weld} (h : FactorReleased G dr b fr factor) : ¬ FactorHeld G dr b fr factor run := by rintro ⟨w, _hmem, hactual, hagent, hclass, hidx⟩ exact hidx (h w hactual hagent hclass) theorem factorReleased_rites_iff_ritesGrasp_cut (dr : G.DoorReading) (b : Designatum) (fr : G.FetterReading) : FactorReleased G dr b fr .rites ↔ G.FetterCut b fr .ritesGrasp := Iff.rfl theorem factorReleased_view_iff (dr : G.DoorReading) (b : Designatum) (fr : G.FetterReading) : FactorReleased G dr b fr .view ↔ G.FetterCut b fr .identityView ∧ G.FetterCut b fr .doubt := by constructor · intro h exact ⟨quietOn_mono (fun _ hc => Or.inl hc) h, quietOn_mono (fun _ hc => Or.inr hc) h⟩ · rintro ⟨hidentity, hdoubt⟩ w hactual hagent (hc | hc) · exact hidentity w hactual hagent hc · exact hdoubt w hactual hagent hc theorem factorReleased_resolve_iff (dr : G.DoorReading) (b : Designatum) (fr : G.FetterReading) : FactorReleased G dr b fr .resolve ↔ G.FetterCut b fr .sensualDesire ∧ G.FetterCut b fr .illWill := by constructor · intro h exact ⟨quietOn_mono (fun _ hc => Or.inl hc) h, quietOn_mono (fun _ hc => Or.inr hc) h⟩ · rintro ⟨hsensual, hill⟩ w hactual hagent (hc | hc) · exact hsensual w hactual hagent hc · exact hill w hactual hagent hc def KsmdStreamEnterer (dr : G.DoorReading) (b : Designatum) (fr : G.FetterReading) (run : List G.Weld) : Prop := FactorReleased G dr b fr .rites ∧ FactorHeld G dr b fr .view run def KsmdStreamWinner (dr : G.DoorReading) (b : Designatum) (fr : G.FetterReading) : Prop := FactorReleased G dr b fr .rites ∧ FactorReleased G dr b fr .view def KsmdOnceReturner (dr : G.DoorReading) (b : Designatum) (fr : G.FetterReading) (run : List G.Weld) : Prop := KsmdStreamWinner G dr b fr ∧ FactorHeld G dr b fr .resolve run def KsmdNonReturner (dr : G.DoorReading) (b : Designatum) (fr : G.FetterReading) : Prop := KsmdStreamWinner G dr b fr ∧ FactorReleased G dr b fr .resolve theorem ksmdStreamWinner_iff_streamEntry_cutClasses (dr : G.DoorReading) (b : Designatum) (fr : G.FetterReading) : KsmdStreamWinner G dr b fr ↔ QuietOn G b (Path.cutClasses fr .streamEntry) := by constructor · rintro ⟨hrites, hview⟩ w hactual hagent hclass rcases (ritesView_union_covers_streamEntry_fetters G dr fr w).mpr hclass with hritesClass | hviewClass · exact hrites w hactual hagent hritesClass · exact hview w hactual hagent hviewClass · intro hcut constructor · exact quietOn_mono (fun w hc => (ritesView_union_covers_streamEntry_fetters G dr fr w).mp (Or.inl hc)) hcut · exact quietOn_mono (fun w hc => (ritesView_union_covers_streamEntry_fetters G dr fr w).mp (Or.inr hc)) hcut theorem ksmdNonReturner_iff_nonReturn_cut (dr : G.DoorReading) (b : Designatum) (fr : G.FetterReading) : KsmdNonReturner G dr b fr ↔ QuietOn G b (Path.cutClasses fr .nonReturn) := by constructor · rintro ⟨hstream, hresolve⟩ w hactual hagent hclass rcases (lower_fetters_covered_by_rites_view_resolve G dr fr w).mpr hclass with hrites | hview | hresolveClass · exact hstream.left w hactual hagent hrites · exact hstream.right w hactual hagent hview · exact hresolve w hactual hagent hresolveClass · intro hcut refine ⟨⟨?_, ?_⟩, ?_⟩ · exact quietOn_mono (fun w hc => (lower_fetters_covered_by_rites_view_resolve G dr fr w).mp (Or.inl hc)) hcut · exact quietOn_mono (fun w hc => (lower_fetters_covered_by_rites_view_resolve G dr fr w).mp (Or.inr (Or.inl hc))) hcut · exact quietOn_mono (fun w hc => (lower_fetters_covered_by_rites_view_resolve G dr fr w).mp (Or.inr (Or.inr hc))) hcut theorem ksmdNonReturner_of_quietOn_univ (dr : G.DoorReading) (b : Designatum) (fr : G.FetterReading) (h : QuietOn G b (fun _ => True)) : KsmdNonReturner G dr b fr := (ksmdNonReturner_iff_nonReturn_cut G dr b fr).mpr (quietOn_univ h) theorem ksmdStreamWinner_of_ksmdNonReturner {dr : G.DoorReading} {b : Designatum} {fr : G.FetterReading} (h : KsmdNonReturner G dr b fr) : KsmdStreamWinner G dr b fr := h.left theorem not_ksmdStreamEnterer_of_ksmdStreamWinner {dr : G.DoorReading} {b : Designatum} {fr : G.FetterReading} {run : List G.Weld} (h : KsmdStreamWinner G dr b fr) : ¬ KsmdStreamEnterer G dr b fr run := by intro henterer exact (not_factorHeld_of_factorReleased G h.right) henterer.right /-- When view-factor release uses the supplied owner-claim/mind-door factoring, a stream winner has no defiled identity-view voicing. -/ theorem streamWinner_no_identityView_voicing {L : ClaimLanguage G} (sr : SpeechReading G L) (vr : ViewReading G L) (b : Designatum) (fr : G.FetterReading) (hfactor : ∀ w : G.Weld, fr.provocationClass Fetter.identityView w ↔ sr.door w = .mind ∧ ∃ content, sr.voices w = some content ∧ vr.ownerClaim content) (h : KsmdStreamWinner G sr.toDoorReading b fr) : NoDefiledVoicing sr b vr.ownerClaim .mind := (G.identityView_cut_iff_noDefiledVoicing sr vr b fr hfactor).mp ((factorReleased_view_iff G sr.toDoorReading b fr).mp h.right).left /- Once-return attenuation remains a finite share-drop display, now over a weld-class rather than a call-class. -/ def ShareDropRunOn (before : Config Contrib) (ws : G.Weld → Prop) (run : List G.Weld) : Prop := G.ShareDropRun before run ∧ ∀ w : G.Weld, w ∈ run → ws w def ShareDropRunOnFactor (dr : G.DoorReading) (fr : G.FetterReading) (factor : PathFactor) (run : List G.Weld) : Prop := ∃ before : Config Contrib, ShareDropRunOn G before (PathFactor.blockerClass dr fr factor) run def KsmdResolveAttenuation (dr : G.DoorReading) (_b : Designatum) (fr : G.FetterReading) (run : List G.Weld) : Prop := ∃ (before : Config Contrib) (received : G.Weld) (rest : List G.Weld), run = received :: rest ∧ ShareDropRunOn G before (PathFactor.blockerClass dr fr .resolve) run ∧ ¬ AtBot before.tendency ∧ ¬ AtBot ((Grid.rePitchRun G before run).tendency) def registerFactorDoorReading : registerClockGrid.DoorReading where door _ := .body def registerResolveFactorReading : registerClockGrid.FetterReading where provocationClass f _ := match f with | .sensualDesire => True | _ => False def registerResolveWeld : registerClockGrid.Weld := registerWeld 2 def registerResolveRun : List registerClockGrid.Weld := [registerResolveWeld] theorem registerResolve_streamWinner : KsmdStreamWinner registerClockGrid registerFactorDoorReading (RegisterCase.register 2) registerResolveFactorReading := by constructor <;> intro w _hactual _hagent hclass · cases hclass · rcases hclass with h | h <;> cases h theorem registerResolve_held : FactorHeld registerClockGrid registerFactorDoorReading (RegisterCase.register 2) registerResolveFactorReading .resolve registerResolveRun := by refine ⟨registerResolveWeld, by simp [registerResolveRun], rfl, rfl, Or.inl True.intro, ?_⟩ dsimp [Grid.HasSelfPoleIndex, Grid.share, registerClockGrid, registerResolveWeld, AtBot, shareBot] show ¬ (2 : Nat) ≤ 0 decide theorem registerResolve_attenuation : KsmdResolveAttenuation registerClockGrid registerFactorDoorReading (RegisterCase.register 2) registerResolveFactorReading registerResolveRun := by refine ⟨{ tendency := 5 }, registerResolveWeld, [], rfl, ?_, ?_, ?_⟩ · constructor · exact Grid.ShareDropRun.cons rfl (by dsimp [Grid.IsShareDrop, Grid.share, registerClockGrid, registerResolveWeld] constructor · show (2 : Nat) ≤ 5 decide · show ¬ (5 : Nat) ≤ 2 decide) (Grid.ShareDropRun.nil _) · intro w hmem simp [registerResolveRun] at hmem subst w exact Or.inl True.intro · dsimp [AtBot, shareBot] show ¬ (5 : Nat) ≤ 0 decide · dsimp [Grid.rePitchRun, Grid.rePitch, Grid.share, registerClockGrid, registerResolveRun, registerResolveWeld, AtBot, shareBot] show ¬ (2 : Nat) ≤ 0 decide theorem registerResolve_not_released : ¬ FactorReleased registerClockGrid registerFactorDoorReading (RegisterCase.register 2) registerResolveFactorReading .resolve := by intro hrelease have hbot := hrelease registerResolveWeld rfl rfl (Or.inl True.intro) dsimp [Grid.share, registerClockGrid, registerResolveWeld, AtBot, shareBot] at hbot exact Nat.not_succ_le_zero 1 hbot theorem ksmdOnceReturner_attenuation_witness : KsmdOnceReturner registerClockGrid registerFactorDoorReading (RegisterCase.register 2) registerResolveFactorReading registerResolveRun ∧ KsmdResolveAttenuation registerClockGrid registerFactorDoorReading (RegisterCase.register 2) registerResolveFactorReading registerResolveRun ∧ ¬ FactorReleased registerClockGrid registerFactorDoorReading (RegisterCase.register 2) registerResolveFactorReading .resolve := ⟨⟨registerResolve_streamWinner, registerResolve_held⟩, registerResolve_attenuation, registerResolve_not_released⟩ def RunsExhibitFactorOrder (dr : G.DoorReading) (fr : G.FetterReading) (runs : List (List G.Weld)) : Prop := ∃ ritesRun viewRun resolveRun : List G.Weld, runs = [ritesRun, viewRun, resolveRun] ∧ ShareDropRunOnFactor G dr fr .rites ritesRun ∧ ShareDropRunOnFactor G dr fr .view viewRun ∧ ShareDropRunOnFactor G dr fr .resolve resolveRun def KsmdSerialFactorRegime (dr : G.DoorReading) (b : Designatum) (fr : G.FetterReading) (runs : List (List G.Weld)) : Prop := RunsExhibitFactorOrder G dr fr runs → (∀ run ∈ runs, KsmdStreamEnterer G dr b fr run → KsmdStreamWinner G dr b fr) ∧ (∀ run ∈ runs, KsmdOnceReturner G dr b fr run → KsmdNonReturner G dr b fr) theorem ksmdSerialFactorRegime_conditional {dr : G.DoorReading} {b : Designatum} {fr : G.FetterReading} {runs : List (List G.Weld)} (hregime : KsmdSerialFactorRegime G dr b fr runs) (horder : RunsExhibitFactorOrder G dr fr runs) : (∀ run ∈ runs, KsmdStreamEnterer G dr b fr run → KsmdStreamWinner G dr b fr) ∧ (∀ run ∈ runs, KsmdOnceReturner G dr b fr run → KsmdNonReturner G dr b fr) := hregime horder theorem ksmdSuddenArrival_consistent_with_factorScheme {before : Config Contrib} {received : G.Weld} (dr : G.DoorReading) (fr : G.FetterReading) (hsudden : Grid.KsmdSuddenArrival G before received) (hquiet : QuietOn G received.agent (fun _ => True)) : Grid.KsmdSuddenArrival G before received ∧ KsmdStreamWinner G dr received.agent fr ∧ KsmdNonReturner G dr received.agent fr := by have hnon := ksmdNonReturner_of_quietOn_univ G dr received.agent fr hquiet exact ⟨hsudden, hnon.left, hnon⟩ end Grid namespace CoreReadings variable {Designatum Contrib : Type} [PreorderBot Contrib] abbrev FactorHeld (G : CoreReadings Designatum Contrib) := Grid.FactorHeld G abbrev FactorReleased (G : CoreReadings Designatum Contrib) := Grid.FactorReleased G abbrev KsmdStreamEnterer (G : CoreReadings Designatum Contrib) := Grid.KsmdStreamEnterer G abbrev KsmdStreamWinner (G : CoreReadings Designatum Contrib) := Grid.KsmdStreamWinner G abbrev KsmdOnceReturner (G : CoreReadings Designatum Contrib) := Grid.KsmdOnceReturner G abbrev KsmdNonReturner (G : CoreReadings Designatum Contrib) := Grid.KsmdNonReturner G abbrev ShareDropRunOn (G : CoreReadings Designatum Contrib) := Grid.ShareDropRunOn G abbrev ShareDropRunOnFactor (G : CoreReadings Designatum Contrib) := Grid.ShareDropRunOnFactor G abbrev KsmdResolveAttenuation (G : CoreReadings Designatum Contrib) := Grid.KsmdResolveAttenuation G abbrev RunsExhibitFactorOrder (G : CoreReadings Designatum Contrib) := Grid.RunsExhibitFactorOrder G abbrev KsmdSerialFactorRegime (G : CoreReadings Designatum Contrib) := Grid.KsmdSerialFactorRegime G end CoreReadings end KannoSoe ===== FILE: KannoSoe/Doctrines/FactorsNegative.lean ===== /- ================================================================================ KannoSoe.Doctrines.FactorsNegative Supplied factor boundaries and order underdetermination ================================================================================ -/ import KannoSoe.Doctrines.Factors namespace KannoSoe namespace FactorsNegative open Grid inductive CaseDesignatum | being | first | second | response | firstOccurrence | secondOccurrence def occurrenceReading : OccurrenceReading CaseDesignatum where occurrence d := d = .firstOccurrence ∨ d = .secondOccurrence isBeing d := d = .being isCall | .first | .second => True | _ => False isResponse d := d = .response agent | .firstOccurrence | .secondOccurrence => .being | d => d call | .firstOccurrence => .first | .secondOccurrence => .second | d => d response | .firstOccurrence | .secondOccurrence => .response | d => d def grid : CoreReadings CaseDesignatum Nat where occurrence := occurrenceReading response := { respondsTo := fun b c => match b, c with | .being, .first | .being, .second => some .response | _, _ => none } placement := { grade := fun d => match d with | .firstOccurrence => 1 | _ => 0 } conditioning := { conditions := fun _ _ => True } def reading : grid.DoorReading where door w := match w.call with | .first => .speech | _ => .body def firstWeld : grid.Weld := ⟨.firstOccurrence, Or.inl rfl⟩ def secondWeld : grid.Weld := ⟨.secondOccurrence, Or.inr rfl⟩ def firstViewReading : grid.FetterReading where provocationClass f w := match f with | .identityView => w.call = .first | .ritesGrasp => w.call = .second | _ => False def secondViewReading : grid.FetterReading where provocationClass f w := match f with | .identityView => w.call = .second | .ritesGrasp => w.call = .first | _ => False theorem speech_class_activated : PathFactor.blockerClass reading firstViewReading .speech firstWeld := rfl theorem conduct_class_inert (w : grid.Weld) : ¬ PathFactor.blockerClass reading firstViewReading .conduct w := fun h => h theorem first_view_held : grid.FactorHeld reading CaseDesignatum.being firstViewReading .view [firstWeld] := by refine ⟨firstWeld, by simp, rfl, rfl, Or.inl rfl, ?_⟩ dsimp [Grid.HasSelfPoleIndex, Grid.share, grid, firstWeld, AtBot, shareBot] show ¬ (1 : Nat) ≤ 0 decide theorem second_view_released : grid.FactorReleased reading CaseDesignatum.being secondViewReading .view := by rintro ⟨d, hd⟩ _hactual _hagent hclass rcases hclass with hclass | hclass · change d = CaseDesignatum.firstOccurrence ∨ d = CaseDesignatum.secondOccurrence at hd change occurrenceReading.call d = CaseDesignatum.second at hclass rcases hd with rfl | rfl · contradiction · exact Nat.le_refl 0 · cases hclass abbrev GridData : Type := (CaseDesignatum → CaseDesignatum → Option CaseDesignatum) × (CaseDesignatum → Nat) def gridData : GridData := (grid.respondsTo, grid.grade) def firstViewBoundary (w : grid.Weld) : Prop := w.call = .first def secondViewBoundary (w : grid.Weld) : Prop := w.call = .second /-- The same grid data supports incompatible factor boundaries, so a seen hold/release classification remains reading-relative. -/ theorem no_hold_conceit_boundary_recovery : ¬ ∃ recover : GridData → grid.Weld → Prop, recover gridData = firstViewBoundary ∧ recover gridData = secondViewBoundary := by rintro ⟨recover, hfirst, hsecond⟩ have hyes : recover gridData firstWeld := by rw [hfirst]; rfl have hno : ¬ recover gridData firstWeld := by rw [hsecond] intro h cases h exact hno hyes /-- Swapping the supplied view and rites classes reverses their displayed factor order without changing the underlying grid. -/ theorem factor_order_underdetermined : firstViewReading.provocationClass Fetter.identityView firstWeld ∧ secondViewReading.provocationClass Fetter.ritesGrasp firstWeld ∧ firstViewReading.provocationClass Fetter.ritesGrasp secondWeld ∧ secondViewReading.provocationClass Fetter.identityView secondWeld := ⟨rfl, rfl, rfl, rfl⟩ end FactorsNegative end KannoSoe ===== FILE: KannoSoe/Doctrines/Faith.lean ===== /- ================================================================================ KannoSoe.Doctrines.Faith Speech-only testimony and speech-or-mind no-nescience ================================================================================ -/ import KannoSoe.Doctrines.Shusho import KannoSoe.Doctrines.Doors namespace KannoSoe namespace Grid namespace DirectedConvention variable {Designatum Contrib : Type} [PreorderBot Contrib] variable (G : CoreReadings Designatum Contrib) structure KsmdPathClaim where before : Config Contrib deed : G.Weld reception : G.Weld def ksmdPathClaimLanguage : ClaimLanguage G where Claim := KsmdPathClaim G Holds | .floor, _ => False | .actTime _, claim => ShortfallClosedAt G claim.before claim.deed claim.reception def Factive (Faith : Prop → Prop) : Prop := ∀ P : Prop, Faith P → P /-- The former speech-side character conjunct, retained as the comparison target for the deliberate strengthening to `KsmdNoNescience`. -/ def KsmdNoDelusion (Fidelity : RecordedUtterance G (ksmdPathClaimLanguage G) → Prop) (b : Designatum) : Prop := ∀ u : RecordedUtterance G (ksmdPathClaimLanguage G), u.weld.agent = b → Fidelity u → ∀ w : G.Weld, u.offeredAt = Tier.actTime w → (ksmdPathClaimLanguage G).TrueAt u.offeredAt u.content /-- Production-instantiated fidelity: a record is faithful here exactly when it is the speech-door record of a supplied production. -/ def ProductionFidelity (sr : SpeechReading G (ksmdPathClaimLanguage G)) (record : RecordedUtterance G (ksmdPathClaimLanguage G)) : Prop := ∃ u : ProducedUtterance sr, ∃ hspeech : sr.door u.weld = .speech, u.toRecorded hspeech = record /-- Positive truth at a production's own act-time for every speech-or-mind pole-share production. This is the cognitive-obscuration conjunct: thoughts are included, while testimony remains speech-only. -/ def KsmdNoNescience (sr : SpeechReading G (ksmdPathClaimLanguage G)) (b : Designatum) : Prop := ∀ u : ProducedUtterance sr, u.weld.agent = b → (sr.door u.weld = .speech ∨ sr.door u.weld = .mind) → AtBot (G.share u.weld) → (ksmdPathClaimLanguage G).TrueAt (Tier.actTime u.weld) u.content /-- For a terminus producer, every production-instantiated speech record is at pole, so no-nescience supplies the old speech-side no-delusion theorem. -/ theorem noDelusion_of_noNescience_of_terminus (sr : SpeechReading G (ksmdPathClaimLanguage G)) {b : Designatum} (hnescience : KsmdNoNescience G sr b) (hterm : G.Terminus b) : KsmdNoDelusion G (ProductionFidelity G sr) b := by intro record hagent hfid w hoff rcases hfid with ⟨u, hspeech, rfl⟩ have hagentU : u.weld.agent = b := by simpa using hagent have htermU : G.Terminus u.weld.agent := by rw [hagentU] exact hterm change (ksmdPathClaimLanguage G).TrueAt (Tier.actTime u.weld) u.content exact hnescience u hagentU (Or.inl hspeech) (G.atBot_of_terminus_response htermU u.actual) theorem ksmdNoDelusion_not_misfits {Fidelity : RecordedUtterance G (ksmdPathClaimLanguage G) → Prop} {b : Designatum} (h : KsmdNoDelusion G Fidelity b) (u : RecordedUtterance G (ksmdPathClaimLanguage G)) (hutter : u.weld.agent = b) (hfid : Fidelity u) : ¬ u.MisfitsOfferedTier := by rintro ⟨w, hoff, hnot⟩ exact hnot (h u hutter hfid w hoff) /-- Full enlightenment combines effective termination with the strengthened speech-or-mind no-nescience conjunct. Including thought is the point: the jñeyāvaraṇa face is stronger than faithful speech alone. -/ structure KsmdFullyEnlightened (sr : SpeechReading G (ksmdPathClaimLanguage G)) (b : Designatum) : Prop where effective : KsmdEffectiveTerminus G b noNescience : KsmdNoNescience G sr b /-- A non-vacuous faithful speech occurrence, tied to its production weld and therefore definitionally offered at that weld's act-time. -/ def KsmdFaithfulSpeechOccurrence (sr : SpeechReading G (ksmdPathClaimLanguage G)) (Fidelity : RecordedUtterance G (ksmdPathClaimLanguage G) → Prop) (b : Designatum) : Prop := ∃ u : ProducedUtterance sr, u.weld.agent = b ∧ ∃ hspeech : sr.door u.weld = .speech, Fidelity (u.toRecorded hspeech) ∧ (u.toRecorded hspeech).FitsOfferedTier /-- Enacted faithful speech is standing full enlightenment plus a tied speech occurrence. -/ def KsmdFaithfulSpeechEnacted (sr : SpeechReading G (ksmdPathClaimLanguage G)) (Fidelity : RecordedUtterance G (ksmdPathClaimLanguage G) → Prop) (b : Designatum) : Prop := KsmdFullyEnlightened G sr b ∧ KsmdFaithfulSpeechOccurrence G sr Fidelity b structure KsmdFullyEnlightenedEnacted (sr : SpeechReading G (ksmdPathClaimLanguage G)) (Fidelity : RecordedUtterance G (ksmdPathClaimLanguage G) → Prop) (b : Designatum) : Prop where standing : KsmdFullyEnlightened G sr b deedWitness : KsmdEffectivenessEnacted G b speechOccurrence : KsmdFaithfulSpeechOccurrence G sr Fidelity b theorem ksmdEffectiveTerminus_of_fullyEnlightened {sr : SpeechReading G (ksmdPathClaimLanguage G)} {b : Designatum} (h : KsmdFullyEnlightened G sr b) : KsmdEffectiveTerminus G b := h.effective theorem ksmdFullyEnlightened_of_fullyEnlightenedEnacted {sr : SpeechReading G (ksmdPathClaimLanguage G)} {Fidelity : RecordedUtterance G (ksmdPathClaimLanguage G) → Prop} {b : Designatum} (h : KsmdFullyEnlightenedEnacted G sr Fidelity b) : KsmdFullyEnlightened G sr b := h.standing theorem ksmdEffectivenessEnacted_of_fullyEnlightenedEnacted {sr : SpeechReading G (ksmdPathClaimLanguage G)} {Fidelity : RecordedUtterance G (ksmdPathClaimLanguage G) → Prop} {b : Designatum} (h : KsmdFullyEnlightenedEnacted G sr Fidelity b) : KsmdEffectivenessEnacted G b := h.deedWitness theorem ksmdFaithfulSpeechEnacted_of_fullyEnlightenedEnacted {sr : SpeechReading G (ksmdPathClaimLanguage G)} {Fidelity : RecordedUtterance G (ksmdPathClaimLanguage G) → Prop} {b : Designatum} (h : KsmdFullyEnlightenedEnacted G sr Fidelity b) : KsmdFaithfulSpeechEnacted G sr Fidelity b := ⟨h.standing, h.speechOccurrence⟩ theorem ksmdNoNescience_of_factive_faith {Faith : Prop → Prop} {sr : SpeechReading G (ksmdPathClaimLanguage G)} {b : Designatum} (hfact : Factive Faith) (hfaith : Faith (KsmdFullyEnlightened G sr b)) : KsmdNoNescience G sr b := (hfact _ hfaith).noNescience /-- Factive faith plus a production witness gives truth for a speech record. Mind productions cannot supply `ProductionFidelity` and never enter this testimonial route. -/ theorem ksmd_says_true_of_faith {Faith : Prop → Prop} {sr : SpeechReading G (ksmdPathClaimLanguage G)} {b : Designatum} (hfact : Factive Faith) (hfaith : Faith (KsmdFullyEnlightened G sr b)) (record : RecordedUtterance G (ksmdPathClaimLanguage G)) (hagent : record.weld.agent = b) (hproduction : ProductionFidelity G sr record) : record.FitsOfferedTier := by rcases hproduction with ⟨u, hspeech, rfl⟩ have hfull := hfact _ hfaith have hagentU : u.weld.agent = b := by simpa using hagent have htermU : G.Terminus u.weld.agent := by rw [hagentU] exact hfull.effective.left.right change (ksmdPathClaimLanguage G).TrueAt (Tier.actTime u.weld) u.content exact hfull.noNescience u hagentU (Or.inl hspeech) (G.atBot_of_terminus_response htermU u.actual) theorem ksmd_no_misfit_of_stance {Faith : Prop → Prop} {sr : SpeechReading G (ksmdPathClaimLanguage G)} {b : Designatum} (hfact : Factive Faith) (hfaith : Faith (KsmdFullyEnlightened G sr b)) (record : RecordedUtterance G (ksmdPathClaimLanguage G)) (hagent : record.weld.agent = b) (hproduction : ProductionFidelity G sr record) : ¬ record.MisfitsOfferedTier := by intro hmisfit exact hmisfit.elim (fun _ hw => hw.right (ksmd_says_true_of_faith G hfact hfaith record hagent hproduction)) theorem ksmdPath_not_misfits_of_floor_offer (u : RecordedUtterance G (ksmdPathClaimLanguage G)) (hoff : u.offeredAt = Tier.floor) : ¬ u.MisfitsOfferedTier := by rintro ⟨w, hact, _hfalse⟩ rw [hoff] at hact cases hact theorem fitsOfferedTier_of_ksmdEffectiveTerminus_ownDeed {b : Designatum} (h : KsmdEffectiveTerminus G b) (u : RecordedUtterance G (ksmdPathClaimLanguage G)) (hdeed : u.content.deed.agent = b) (w : G.Weld) (hoff : u.offeredAt = Tier.actTime w) : u.FitsOfferedTier := by change (ksmdPathClaimLanguage G).TrueAt u.offeredAt u.content rw [hoff] exact h.right u.content.before u.content.deed u.content.reception hdeed theorem ksmd_path_landing_of_stance {Faith : Prop → Prop} {sr : SpeechReading G (ksmdPathClaimLanguage G)} {b : Designatum} (hfact : Factive Faith) (hfaith : Faith (KsmdFullyEnlightened G sr b)) (u : RecordedUtterance G (ksmdPathClaimLanguage G)) (hagent : u.weld.agent = b) (hproduction : ProductionFidelity G sr u) (hdel : DeliveredTo G u.content.deed u.content.reception) (hctx : KsmdAversionContext G u.content.before u.content.reception) : HasShareDropLanding G u.content.before u.content.deed := by have hfit := ksmd_says_true_of_faith G hfact hfaith u hagent hproduction have hclosed : ShortfallClosedAt G u.content.before u.content.deed u.content.reception := by rcases hproduction with ⟨production, hspeech, hrecord⟩ subst hrecord change (ksmdPathClaimLanguage G).TrueAt (Tier.actTime production.weld) production.content at hfit dsimp [ksmdPathClaimLanguage, ClaimLanguage.TrueAt] at hfit change ShortfallClosedAt G production.content.before production.content.deed production.content.reception exact hfit exact hclosed hctx.liveBefore hdel def KsmdFaithOught (sr : SpeechReading G (ksmdPathClaimLanguage G)) (Fidelity : RecordedUtterance G (ksmdPathClaimLanguage G) → Prop) (Faith : Prop → Prop) (b : Designatum) (u : RecordedUtterance G (ksmdPathClaimLanguage G)) : Prop := Factive Faith → Faith (KsmdFullyEnlightened G sr b) → Fidelity u → (∀ record, Fidelity record → ProductionFidelity G sr record) → u.weld.agent = b → DeliveredTo G u.content.deed u.content.reception → KsmdAversionContext G u.content.before u.content.reception → HasShareDropLanding G u.content.before u.content.deed theorem ksmdFaithOught_conditional (sr : SpeechReading G (ksmdPathClaimLanguage G)) (Fidelity : RecordedUtterance G (ksmdPathClaimLanguage G) → Prop) (Faith : Prop → Prop) (b : Designatum) (u : RecordedUtterance G (ksmdPathClaimLanguage G)) : KsmdFaithOught G sr Fidelity Faith b u := by intro hfact hfaith hfid hproduces hagent hdel hctx exact ksmd_path_landing_of_stance G hfact hfaith u hagent (hproduces u hfid) hdel hctx end DirectedConvention end Grid end KannoSoe ===== FILE: KannoSoe/Doctrines/FaithNegative.lean ===== /- ================================================================================ KannoSoe.Doctrines.FaithNegative Speech/mind strictness, undefiled nescience, and silent buddhas ================================================================================ -/ import KannoSoe.Doctrines.Faith namespace KannoSoe namespace FaithNegative open Grid open Grid.DirectedConvention /-! ### A pole-share producer with true speech and a false thought -/ inductive CaseDesignatum | producer | speech | mind | target | response | speechOccurrence | mindOccurrence | targetOccurrence deriving DecidableEq def occurrenceReading : OccurrenceReading CaseDesignatum where occurrence | .speechOccurrence | .mindOccurrence | .targetOccurrence => True | _ => False isBeing d := d = .producer isCall | .speech | .mind | .target => True | _ => False isResponse d := d = .response agent | .speechOccurrence | .mindOccurrence | .targetOccurrence => .producer | d => d call | .speechOccurrence => .speech | .mindOccurrence => .mind | .targetOccurrence => .target | d => d response | .speechOccurrence | .mindOccurrence | .targetOccurrence => .response | d => d /-- Speech and thought occur at the pole. The target is a merely possible reception used to make the thought-content false. -/ def grid : CoreReadings CaseDesignatum Nat where occurrence := occurrenceReading response := { respondsTo := fun b c => match b, c with | .producer, .speech | .producer, .mind => some .response | _, _ => none } placement := { grade := fun d => match d with | .targetOccurrence => 1 | _ => 0 } conditioning := { conditions := fun deed reception => deed = .mindOccurrence ∧ reception = .targetOccurrence } def speechWeld : grid.Weld := ⟨.speechOccurrence, True.intro⟩ def mindWeld : grid.Weld := ⟨.mindOccurrence, True.intro⟩ def targetWeld : grid.Weld := ⟨.targetOccurrence, True.intro⟩ def poleBefore : Config Nat := ⟨0⟩ def liveBefore : Config Nat := ⟨1⟩ def trueContent : KsmdPathClaim grid := ⟨poleBefore, speechWeld, targetWeld⟩ def falseContent : KsmdPathClaim grid := ⟨liveBefore, mindWeld, targetWeld⟩ def reading : SpeechReading grid (ksmdPathClaimLanguage grid) where door w := match w.call with | .speech => .speech | .mind => .mind | _ => .body voices w := match w.call with | .speech => some trueContent | .mind => some falseContent | _ => none def speechProduction : ProducedUtterance reading where weld := speechWeld actual := rfl content := trueContent voiced := rfl def mindProduction : ProducedUtterance reading where weld := mindWeld actual := rfl content := falseContent voiced := rfl theorem trueContent_trueAt : (ksmdPathClaimLanguage grid).TrueAt (Tier.actTime speechWeld) trueContent := by intro hlive exact False.elim (hlive (Nat.le_refl 0)) theorem liveBefore_not_atBot : ¬ AtBot liveBefore.tendency := by intro h exact Nat.not_succ_le_zero 0 h theorem mind_delivered_to_target : Grid.DirectedConvention.DeliveredTo grid mindWeld targetWeld := ⟨rfl, rfl⟩ theorem mind_has_no_shareDropLanding : ¬ HasShareDropLanding grid liveBefore mindWeld := by rintro ⟨received, hland⟩ have htarget : received.1 = CaseDesignatum.targetOccurrence := hland.left.left.right have hactual : grid.Actual received := hland.left.right rcases received with ⟨d, hd⟩ change d = CaseDesignatum.targetOccurrence at htarget subst d change (none : Option CaseDesignatum) = some CaseDesignatum.response at hactual contradiction theorem falseContent_not_trueAt : ¬ (ksmdPathClaimLanguage grid).TrueAt (Tier.actTime mindWeld) falseContent := by intro htrue exact mind_has_no_shareDropLanding (htrue liveBefore_not_atBot mind_delivered_to_target) theorem all_speech_productions_true : ∀ u : ProducedUtterance reading, reading.door u.weld = .speech → (ksmdPathClaimLanguage grid).TrueAt (Tier.actTime u.weld) u.content := by intro u hspeech cases hcall : u.weld.call with | speech => have hcontent : u.content = trueContent := by simpa [reading, hcall] using u.voiced.symm rw [hcontent] intro hlive exact False.elim (hlive (Nat.le_refl 0)) | mind => simp [reading, hcall] at hspeech | target => simp [reading, hcall] at hspeech | producer => simp [reading, hcall] at hspeech | response => simp [reading, hcall] at hspeech | speechOccurrence => simp [reading, hcall] at hspeech | mindOccurrence => simp [reading, hcall] at hspeech | targetOccurrence => simp [reading, hcall] at hspeech /-- Production-instantiated fidelity sees precisely speech-door productions, all of which are true in the strictness model. -/ theorem old_speech_side_holds : KsmdNoDelusion grid (ProductionFidelity grid reading) CaseDesignatum.producer := by intro record _hagent hfid _w _hoff rcases hfid with ⟨u, hspeech, rfl⟩ exact all_speech_productions_true u hspeech theorem not_noNescience : ¬ KsmdNoNescience grid reading CaseDesignatum.producer := by intro h exact falseContent_not_trueAt (h mindProduction rfl (Or.inr rfl) (Nat.le_refl 0)) /-- No-nescience is deliberately stronger than the former speech-only test. -/ theorem noNescience_strictly_stronger_witness : KsmdNoDelusion grid (ProductionFidelity grid reading) CaseDesignatum.producer ∧ (∀ u : ProducedUtterance reading, reading.door u.weld = .speech → (ksmdPathClaimLanguage grid).TrueAt (Tier.actTime u.weld) u.content) ∧ ¬ KsmdNoNescience grid reading CaseDesignatum.producer := ⟨old_speech_side_holds, all_speech_productions_true, not_noNescience⟩ /-- The false thought is cognitive error but not defiled: its occurrence has no live self-pole. This is the checked akliṣṭa-ajñāna separation. -/ theorem aklishta_ajnana_witness : grid.Actual mindProduction.weld ∧ AtBot (grid.share mindProduction.weld) ∧ ¬ (ksmdPathClaimLanguage grid).TrueAt (Tier.actTime mindProduction.weld) mindProduction.content ∧ ¬ grid.HasSelfPoleIndex mindProduction.weld := by refine ⟨mindProduction.actual, Nat.le_refl 0, falseContent_not_trueAt, ?_⟩ exact grid.no_self_pole_index_of_atBot mindProduction.weld (Nat.le_refl 0) theorem quiet_everywhere : QuietOn grid CaseDesignatum.producer (fun _ => True) := by rintro ⟨d, hd⟩ hactual _hagent _ change occurrenceReading.occurrence d at hd change KannoSoe.Actual grid.occurrence grid.response ⟨d, hd⟩ at hactual change AtBot (grid.placement.grade d) cases d with | producer | speech | mind | target | response => change False at hd contradiction | speechOccurrence | mindOccurrence => exact Nat.le_refl 0 | targetOccurrence => change (none : Option CaseDesignatum) = some CaseDesignatum.response at hactual contradiction /-- Three-door arhat quietness removes the afflictive self-pole but does not by itself make every speech-or-mind production true. -/ theorem arhat_retains_nescience_witness : QuietOn grid CaseDesignatum.producer (fun _ => True) ∧ ¬ KsmdNoNescience grid reading CaseDesignatum.producer := ⟨quiet_everywhere, not_noNescience⟩ /-! ### Sealed silent and thinking buddhas -/ namespace Sealed inductive SealedDesignatum | buddha | call | response | occurrence def occurrenceReading : OccurrenceReading SealedDesignatum where occurrence d := d = .occurrence isBeing d := d = .buddha isCall d := d = .call isResponse d := d = .response agent | .occurrence => .buddha | d => d call | .occurrence => .call | d => d response | .occurrence => .response | d => d def grid : CoreReadings SealedDesignatum Nat where occurrence := occurrenceReading response := { respondsTo := fun b c => match b, c with | .buddha, .call => some .response | _, _ => none } placement := { grade := fun _ => 0 } conditioning := { conditions := fun _ _ => False } def weld : grid.Weld := ⟨.occurrence, rfl⟩ def poleBefore : Config Nat := ⟨0⟩ def content : KsmdPathClaim grid := ⟨poleBefore, weld, weld⟩ def silentReading : SpeechReading grid (ksmdPathClaimLanguage grid) where door _ := .mind voices _ := none def thinkingReading : SpeechReading grid (ksmdPathClaimLanguage grid) where door _ := .mind voices _ := some content def thought : ProducedUtterance thinkingReading where weld := weld actual := rfl content := content voiced := rfl theorem responsiveTerminus : grid.ResponsiveTerminus SealedDesignatum.buddha := by constructor · intro c hc change c = SealedDesignatum.call at hc subst c exact ⟨SealedDesignatum.response, by simp [grid]⟩ · intro _w _hactual _hagent exact Nat.le_refl 0 theorem own_deeds_undelivered (deed reception : grid.Weld) (_hdeed : deed.agent = SealedDesignatum.buddha) : ¬ Grid.DirectedConvention.DeliveredTo grid deed reception := by change ¬ False exact not_false theorem effectiveTerminus : KsmdEffectiveTerminus grid SealedDesignatum.buddha := ksmdEffectiveTerminus_of_responsiveTerminus_of_undelivered grid responsiveTerminus own_deeds_undelivered theorem content_trueAt : (ksmdPathClaimLanguage grid).TrueAt (Tier.actTime weld) content := by intro hlive exact False.elim (hlive (Nat.le_refl 0)) theorem silent_noNescience : KsmdNoNescience grid silentReading SealedDesignatum.buddha := by intro u _ _ _ have := u.voiced simp [silentReading] at this theorem thinking_noNescience : KsmdNoNescience grid thinkingReading SealedDesignatum.buddha := by intro u _ _ _ have hcontent : u.content = content := by simpa [thinkingReading] using u.voiced.symm rw [hcontent] intro hlive exact False.elim (hlive (Nat.le_refl 0)) theorem silent_fullyEnlightened : KsmdFullyEnlightened grid silentReading SealedDesignatum.buddha := ⟨effectiveTerminus, silent_noNescience⟩ theorem thinking_fullyEnlightened : KsmdFullyEnlightened grid thinkingReading SealedDesignatum.buddha := ⟨effectiveTerminus, thinking_noNescience⟩ def noFidelity (_ : RecordedUtterance grid (ksmdPathClaimLanguage grid)) : Prop := False theorem silent_no_speech_occurrence : ¬ KsmdFaithfulSpeechOccurrence grid silentReading noFidelity SealedDesignatum.buddha := by rintro ⟨u, _hagent, hspeech, _⟩ simp [silentReading] at hspeech theorem thinking_no_speech_occurrence : ¬ KsmdFaithfulSpeechOccurrence grid thinkingReading noFidelity SealedDesignatum.buddha := by rintro ⟨u, _hagent, hspeech, _⟩ simp [thinkingReading] at hspeech theorem thinking_has_mind_production : ∃ u : ProducedUtterance thinkingReading, thinkingReading.door u.weld = .mind := ⟨thought, rfl⟩ theorem no_effectiveness_enacted : ¬ KsmdEffectivenessEnacted grid SealedDesignatum.buddha := not_effectivenessEnacted_of_undelivered grid own_deeds_undelivered /-- Both sealed readings are fully enlightened. One produces no thought and the other produces a true thought; neither silently acquires a testimonial or enacted deed witness. -/ theorem silent_buddha_models : KsmdFullyEnlightened grid silentReading SealedDesignatum.buddha ∧ KsmdFullyEnlightened grid thinkingReading SealedDesignatum.buddha ∧ (¬ KsmdFaithfulSpeechOccurrence grid silentReading noFidelity SealedDesignatum.buddha) ∧ (¬ KsmdFaithfulSpeechOccurrence grid thinkingReading noFidelity SealedDesignatum.buddha) ∧ (∃ u : ProducedUtterance thinkingReading, thinkingReading.door u.weld = .mind) ∧ ¬ KsmdEffectivenessEnacted grid SealedDesignatum.buddha := ⟨silent_fullyEnlightened, thinking_fullyEnlightened, silent_no_speech_occurrence, thinking_no_speech_occurrence, thinking_has_mind_production, no_effectiveness_enacted⟩ end Sealed end FaithNegative end KannoSoe ===== FILE: KannoSoe/Doctrines/Fetters.lean ===== /- ================================================================================ KannoSoe.Doctrines.Fetters The ten fetters and path-scheme readings ================================================================================ -/ import KannoSoe.Doctrines.Correlations import KannoSoe.Doctrines.Doors namespace KannoSoe /- ============================================================================== 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 {Designatum Contrib : Type} [PreorderBot Contrib] variable (G : CoreReadings Designatum 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. Classes are weld predicates: door, production, and content may all matter, while doubt and the upper fetters remain door-neutral when a model chooses. -/ structure FetterReading where provocationClass : Fetter → G.Weld → Prop /-- Upgrade a legacy family of call-classes to weld-classes in one line. -/ def FetterReading.ofCallClasses (classes : Fetter → Designatum → Prop) : FetterReading G where provocationClass f w := classes f w.call /-- Identity-view content is supplied by a claim classifier; the grid does not infer stored ownership from share, door, or coarsening data. -/ structure ViewReading (G : CoreReadings Designatum Contrib) (L : ClaimLanguage G) where ownerClaim : L.Claim → Prop /-- A fetter is cut when the fine being is quiet on its supplied weld-class. -/ def FetterCut (b : Designatum) (fr : FetterReading G) (f : Fetter) : Prop := QuietOn G b (fr.provocationClass f) /-- Retirement bridge for the old two-axis rectangle: a series rectangle is exactly fine quietness for every being in that coarsening fiber. -/ theorem fiberAtPoleOnWithin_iff_quietOn_rectangle {Macro : Type} (κ : BeingCoarsening G Macro) (b : Macro) (cs : Designatum → Prop) (ts : Designatum → Prop) : κ.FiberAtPoleOnWithin b cs ts ↔ ∀ p : Designatum, κ.proj p = b → QuietOn G p (fun w => cs w.call ∧ ts w.agent) := by constructor · intro h p hp w hactual hagent hw exact h w hactual (by simpa [BeingCoarsening.InFiber, hagent] using hp) hw.left hw.right · intro h w hactual hfiber hcall htag exact h w.agent hfiber w hactual rfl ⟨hcall, htag⟩ /-- A seen run is quiet on a weld-class. This is finite display, not a claim about fresh welds. -/ def RunQuietOn (b : Designatum) (ws : G.Weld → Prop) (run : List G.Weld) : Prop := ∀ w : G.Weld, w ∈ run → G.Actual w → w.agent = b → ws w → AtBot (G.share w) theorem runQuietOn_of_fetterCut {b : Designatum} {fr : FetterReading G} {f : Fetter} {run : List G.Weld} (h : FetterCut G b fr f) : RunQuietOn G b (fr.provocationClass f) run := fun w _hmem hactual hagent hclass => h w hactual hagent hclass /-- The forward-looking guarantee as a conditional: a regime may promote a finite class-quiet track record to a whole-class cut, but the grid does not discharge that antecedent. -/ def KsmdIrreversibleRegime (b : Designatum) (fr : FetterReading G) (run : List G.Weld) : Prop := ∀ f : Fetter, RunQuietOn G b (fr.provocationClass f) run → FetterCut G b fr f theorem ksmdIrreversibleRegime_conditional {b : Designatum} {fr : FetterReading G} {run : List G.Weld} {f : Fetter} (hregime : KsmdIrreversibleRegime G b fr run) (hseen : RunQuietOn G b (fr.provocationClass f) run) : FetterCut G b fr f := 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 `KsmdResolveAttenuation`. -/ 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 weld-class quieted by a path under a supplied fetter reading. -/ def cutClasses {Designatum Contrib : Type} [PreorderBot Contrib] {G : CoreReadings Designatum Contrib} (fr : Grid.FetterReading G) : Path → G.Weld → Prop | .streamEntry, w => ∃ f : Fetter, cutsFetter .streamEntry f ∧ fr.provocationClass f w | .onceReturn, w => ∃ f : Fetter, cutsFetter .onceReturn f ∧ fr.provocationClass f w | .nonReturn, w => ∃ f : Fetter, cutsFetter .nonReturn f ∧ fr.provocationClass f w | .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 {Designatum Contrib : Type} [PreorderBot Contrib] {G : CoreReadings Designatum Contrib} (fr : Grid.FetterReading G) : ∀ w : G.Weld, cutClasses fr streamEntry w → cutClasses fr onceReturn w := by intro w h rcases h with ⟨f, hf, hc⟩ exact ⟨f, hf, hc⟩ theorem onceReturn_cutClasses_subset_nonReturn {Designatum Contrib : Type} [PreorderBot Contrib] {G : CoreReadings Designatum Contrib} (fr : Grid.FetterReading G) : ∀ w : G.Weld, cutClasses fr onceReturn w → cutClasses fr nonReturn w := by intro w h rcases h with ⟨f, hf, hc⟩ exact ⟨f, Or.inl hf, hc⟩ theorem nonReturn_cutClasses_subset_arhatship {Designatum Contrib : Type} [PreorderBot Contrib] {G : CoreReadings Designatum Contrib} (fr : Grid.FetterReading G) : ∀ w : G.Weld, cutClasses fr nonReturn w → cutClasses fr arhatship w := fun _w _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 {Designatum Contrib : Type} [PreorderBot Contrib] variable (G : CoreReadings Designatum Contrib) /-- Class quietness is monotone under weld-subclass restriction. -/ theorem classQuiet_mono {b : Designatum} {ws vs : G.Weld → Prop} (h : QuietOn G b ws) (hsub : ∀ w, vs w → ws w) : QuietOn G b vs := quietOn_mono hsub h /-- Fine-being quietness on the class cut by a path. -/ def PathQuiet (b : Designatum) (fr : FetterReading G) (p : Path) : Prop := QuietOn G b (Path.cutClasses fr p) /-- The arhat path weld-class is total. -/ theorem arhatPathQuiet_iff_quietOn_univ (b : Designatum) (fr : FetterReading G) : PathQuiet G b fr Path.arhatship ↔ QuietOn G b (fun _ => True) := Iff.rfl /-- Total fine-being quietness and terminus typing are one share fact: Bull 8's pole-class arrival is arhat display in bull-vocabulary. -/ theorem terminus_iff_quietOn_univ {b : Designatum} : G.Terminus b ↔ QuietOn G b (fun _ => True) := by constructor · intro hterm w hactual hagent _ exact hterm w hactual hagent · intro hquiet w hactual hagent exact hquiet w hactual hagent True.intro /-- The pole-class predicate is terminus typing, hence exactly total fine-being quietness. -/ theorem atPoleClass_iff_quietOn_univ {b : Designatum} : G.AtPoleClass b ↔ QuietOn G b (fun _ => True) := terminus_iff_quietOn_univ G theorem all_fetters_cut_at_arhat (b : Designatum) (fr : FetterReading G) (h : QuietOn G b (fun _ => True)) : ∀ f : Fetter, FetterCut G b fr f := fun _f => quietOn_univ h /-- 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 {b : Designatum} {fr : FetterReading G} {f : Fetter} {w : G.Weld} (h : FetterCut G b fr f) (hactual : G.Actual w) (hagent : w.agent = b) (hclass : fr.provocationClass f w) : ¬ G.HasSelfPoleIndex w := G.no_self_pole_index_of_atBot w (h w hactual hagent hclass) /-- The view fetter factors through supplied mind-door owner-claim voicing exactly when the model identifies its provocation class that way. -/ theorem identityView_cut_iff_noDefiledVoicing {L : ClaimLanguage G} (sr : SpeechReading G L) (vr : ViewReading G L) (b : Designatum) (fr : FetterReading G) (hfactor : ∀ w : G.Weld, fr.provocationClass Fetter.identityView w ↔ sr.door w = .mind ∧ ∃ content : L.Claim, sr.voices w = some content ∧ vr.ownerClaim content) : FetterCut G b fr Fetter.identityView ↔ NoDefiledVoicing sr b vr.ownerClaim .mind := by constructor · intro hcut u hagent hmind howner exact hcut u.weld u.actual hagent ((hfactor u.weld).mpr ⟨hmind, u.content, u.voiced, howner⟩) · intro hvoice w hactual hagent hclass rcases (hfactor w).mp hclass with ⟨hmind, content, hvoiced, howner⟩ exact hvoice ⟨w, hactual, content, hvoiced⟩ hagent hmind howner /-- Rites-grasp factors through a supplied body-door weld-class when the model gives that exact identification. -/ theorem ritesGrasp_cut_iff_bodyDoorQuietOn (dr : DoorReading G) (b : Designatum) (fr : FetterReading G) (rites : G.Weld → Prop) (hfactor : ∀ w : G.Weld, fr.provocationClass Fetter.ritesGrasp w ↔ dr.door w = .body ∧ rites w) : FetterCut G b fr Fetter.ritesGrasp ↔ QuietOn G b (fun w => dr.door w = .body ∧ rites w) := by constructor · exact fun h => quietOn_mono (fun w hw => (hfactor w).mpr hw) h · exact fun h => quietOn_mono (fun w hw => (hfactor w).mp hw) h /-- The speech instance is the already-derived falsehood theorem; no new falsehood content is introduced in the fetter layer. -/ theorem falsehood_speech_instance {L : ClaimLanguage G} (sr : SpeechReading G L) {b : Designatum} (hquiet : DoorQuiet sr.toDoorReading b .speech) : ∀ u : ProducedUtterance sr, u.weld.agent = b → ¬ KsmdDefiledFalsehood sr u := no_defiledFalsehood_of_speechDoorQuiet hquiet /-- The regional sravaka-arhat figure: speech and mind are quiet, while body may retain live share. It is not the canonical three-door arhat. -/ def KsmdSravakaArhat (dr : DoorReading G) (b : Designatum) : Prop := DoorQuiet dr b .speech ∧ DoorQuiet dr b .mind /-- Share-vāsanā is residual live share in an actual body-door weld. -/ def KsmdVasana (dr : DoorReading G) (b : Designatum) : Prop := ∃ w : G.Weld, G.Actual w ∧ w.agent = b ∧ dr.door w = .body ∧ G.HasSelfPoleIndex w theorem sravakaArhat_no_defiledFalsehood {L : ClaimLanguage G} (sr : SpeechReading G L) {b : Designatum} (h : KsmdSravakaArhat G sr.toDoorReading b) : ∀ u : ProducedUtterance sr, u.weld.agent = b → ¬ KsmdDefiledFalsehood sr u := no_defiledFalsehood_of_speechDoorQuiet h.left /- A compact Hakuin-shaped witness: speech and mind sit at bottom, body keeps live share, and all three doors still mount responses. -/ inductive DoorWitnessDesignatum | being | speech | mind | body | response | speechOccurrence | mindOccurrence | bodyOccurrence def doorWitnessOccurrence : OccurrenceReading DoorWitnessDesignatum where occurrence d := d = .speechOccurrence ∨ d = .mindOccurrence ∨ d = .bodyOccurrence isBeing d := d = .being isCall | .speech | .mind | .body => True | _ => False isResponse d := d = .response agent | .speechOccurrence | .mindOccurrence | .bodyOccurrence => .being | d => d call | .speechOccurrence => .speech | .mindOccurrence => .mind | .bodyOccurrence => .body | d => d response | .speechOccurrence | .mindOccurrence | .bodyOccurrence => .response | d => d def doorWitnessGrid : CoreReadings DoorWitnessDesignatum Nat where occurrence := doorWitnessOccurrence response := { respondsTo := fun b c => match b, c with | .being, .speech | .being, .mind | .being, .body => some .response | _, _ => none } placement := { grade := fun d => match d with | .bodyOccurrence => 1 | _ => 0 } conditioning := { conditions := fun _ _ => True } def doorWitnessReading : doorWitnessGrid.DoorReading where door w := match w.call with | .speech => .speech | .mind => .mind | _ => .body def doorWitnessBodyWeld : doorWitnessGrid.Weld := ⟨.bodyOccurrence, Or.inr (Or.inr rfl)⟩ theorem doorWitness_sravakaArhat : KsmdSravakaArhat doorWitnessGrid doorWitnessReading DoorWitnessDesignatum.being := by constructor · rintro ⟨d, hd⟩ _hactual _hagent hdoor change d = .speechOccurrence ∨ d = .mindOccurrence ∨ d = .bodyOccurrence at hd rcases hd with rfl | rfl | rfl · exact Nat.le_refl 0 · change Door.mind = Door.speech at hdoor contradiction · change Door.body = Door.speech at hdoor contradiction · rintro ⟨d, hd⟩ _hactual _hagent hdoor change d = .speechOccurrence ∨ d = .mindOccurrence ∨ d = .bodyOccurrence at hd rcases hd with rfl | rfl | rfl · change Door.speech = Door.mind at hdoor contradiction · exact Nat.le_refl 0 · change Door.body = Door.mind at hdoor contradiction theorem doorWitnessBodyWeld_live : doorWitnessGrid.HasSelfPoleIndex doorWitnessBodyWeld := by dsimp [Grid.HasSelfPoleIndex, Grid.share, doorWitnessGrid, doorWitnessBodyWeld, AtBot, shareBot] show ¬ (1 : Nat) ≤ 0 decide theorem doorWitness_vasana : KsmdVasana doorWitnessGrid doorWitnessReading DoorWitnessDesignatum.being := by exact ⟨doorWitnessBodyWeld, rfl, rfl, rfl, doorWitnessBodyWeld_live⟩ /-- Speech/mind quiet does not imply canonical total quiet when the body door retains a live self-pole. -/ theorem sravakaArhat_not_arhat_witness : KsmdSravakaArhat doorWitnessGrid doorWitnessReading DoorWitnessDesignatum.being ∧ KsmdVasana doorWitnessGrid doorWitnessReading DoorWitnessDesignatum.being ∧ ¬ QuietOn doorWitnessGrid DoorWitnessDesignatum.being (fun _ => True) := by refine ⟨doorWitness_sravakaArhat, doorWitness_vasana, ?_⟩ intro hquiet exact doorWitness_vasana.elim (fun w hw => hw.right.right.right (hquiet w hw.left hw.right.left True.intro)) /-- The unquiet body door still functions while speech and mind are quiet. -/ theorem unquiet_door_still_functions_witness : KsmdSravakaArhat doorWitnessGrid doorWitnessReading DoorWitnessDesignatum.being ∧ doorWitnessGrid.MountsAt DoorWitnessDesignatum.being DoorWitnessDesignatum.body ∧ ∃ w : doorWitnessGrid.Weld, doorWitnessGrid.Actual w ∧ doorWitnessReading.door w = .body ∧ doorWitnessGrid.HasSelfPoleIndex w := ⟨doorWitness_sravakaArhat, ⟨DoorWitnessDesignatum.response, rfl⟩, doorWitnessBodyWeld, rfl, rfl, doorWitnessBodyWeld_live⟩ end Grid namespace CoreReadings variable {Designatum Contrib : Type} [PreorderBot Contrib] abbrev FetterReading (G : CoreReadings Designatum Contrib) := Grid.FetterReading G abbrev ViewReading (G : CoreReadings Designatum Contrib) (L : Grid.ClaimLanguage G) := Grid.ViewReading G L abbrev FetterCut (G : CoreReadings Designatum Contrib) := Grid.FetterCut G abbrev RunQuietOn (G : CoreReadings Designatum Contrib) := Grid.RunQuietOn G abbrev KsmdIrreversibleRegime (G : CoreReadings Designatum Contrib) := Grid.KsmdIrreversibleRegime G abbrev PathQuiet (G : CoreReadings Designatum Contrib) := Grid.PathQuiet G abbrev KsmdSravakaArhat (G : CoreReadings Designatum Contrib) := Grid.KsmdSravakaArhat G abbrev KsmdVasana (G : CoreReadings Designatum Contrib) := Grid.KsmdVasana G abbrev identityView_cut_iff_noDefiledVoicing (G : CoreReadings Designatum Contrib) {L : Grid.ClaimLanguage G} (sr : Grid.SpeechReading G L) (vr : Grid.ViewReading G L) (b : Designatum) (fr : Grid.FetterReading G) (hfactor : ∀ w : G.Weld, fr.provocationClass Fetter.identityView w ↔ sr.door w = .mind ∧ ∃ content : L.Claim, sr.voices w = some content ∧ vr.ownerClaim content) := Grid.identityView_cut_iff_noDefiledVoicing G sr vr b fr hfactor end CoreReadings end KannoSoe ===== FILE: KannoSoe/Doctrines/FettersNegative.lean ===== /- ================================================================================ KannoSoe.Doctrines.FettersNegative Fresh-weld, view-content, and factor-split countermodels ================================================================================ -/ import KannoSoe.Doctrines.Fetters import KannoSoe.Doctrines.SraddhaNegative namespace KannoSoe namespace FettersNegative open Grid open Grid.DirectedConvention /- The total quiet class still carries no actual-occurrence conjunct. -/ def noActualOccurrence : OccurrenceReading Unit where occurrence _ := False isBeing _ := False isCall _ := False isResponse _ := False agent := id call := id response := id def noActualGrid : CoreReadings Unit Nat where occurrence := noActualOccurrence response := { respondsTo := fun _ _ => none } placement := { grade := fun _ => 0 } conditioning := { conditions := fun _ _ => False } theorem noActual_quiet : QuietOn noActualGrid () (fun _ => True) := by rintro ⟨_d, hd⟩ exact False.elim hd theorem noActual_no_occurrence : ¬ ∃ w : noActualGrid.Weld, noActualGrid.Actual w := by rintro ⟨w, hactual⟩ exact False.elim w.property /-- Total `QuietOn` alone is compatible with a grid having no actual welds. -/ theorem total_cut_carries_no_actual_occurrence : QuietOn noActualGrid () (fun _ => True) ∧ ¬ ∃ w : noActualGrid.Weld, noActualGrid.Actual w := ⟨noActual_quiet, noActual_no_occurrence⟩ theorem sraddha_total_quiet : QuietOn SraddhaNegative.zeroEffectGrid SraddhaNegative.CaseDesignatum.sraddha (fun _ => True) := by intro w hactual hagent _ exact SraddhaNegative.sraddha_responsiveTerminus.right w hactual hagent theorem sraddha_has_actual_occurrence : SraddhaNegative.zeroEffectGrid.ActualAgentInhabited SraddhaNegative.CaseDesignatum.sraddha := ⟨SraddhaNegative.deed, rfl, rfl⟩ /-- Quietness plus an actual occurrence still does not entail regime-relative effectiveness. -/ theorem total_cut_with_actual_occurrence_not_ksmdEffectiveTerminus : QuietOn SraddhaNegative.zeroEffectGrid SraddhaNegative.CaseDesignatum.sraddha (fun _ => True) ∧ SraddhaNegative.zeroEffectGrid.ActualAgentInhabited SraddhaNegative.CaseDesignatum.sraddha ∧ ¬ KsmdEffectiveTerminus SraddhaNegative.zeroEffectGrid SraddhaNegative.CaseDesignatum.sraddha := ⟨sraddha_total_quiet, sraddha_has_actual_occurrence, SraddhaNegative.not_ksmdEffectiveTerminus⟩ /- A quiet seen weld does not settle a fresh weld in the same fetter class. -/ inductive QuietDesignatum | being | seen | fresh | response | seenOccurrence | freshOccurrence def quietOccurrence : OccurrenceReading QuietDesignatum where occurrence d := d = .seenOccurrence ∨ d = .freshOccurrence isBeing d := d = .being isCall | .seen | .fresh => True | _ => False isResponse d := d = .response agent | .seenOccurrence | .freshOccurrence => .being | d => d call | .seenOccurrence => .seen | .freshOccurrence => .fresh | d => d response | .seenOccurrence | .freshOccurrence => .response | d => d def quietGrid : CoreReadings QuietDesignatum Nat where occurrence := quietOccurrence response := { respondsTo := fun b c => match b, c with | .being, .seen | .being, .fresh => some .response | _, _ => none } placement := { grade := fun _ => 0 } conditioning := { conditions := fun _ _ => True } def freshClenchGrid : CoreReadings QuietDesignatum Nat where occurrence := quietOccurrence response := quietGrid.response placement := { grade := fun d => match d with | .freshOccurrence => 1 | _ => 0 } conditioning := quietGrid.conditioning def quietSeen : quietGrid.Weld := ⟨.seenOccurrence, Or.inl rfl⟩ def freshSeen : freshClenchGrid.Weld := ⟨.seenOccurrence, Or.inl rfl⟩ def freshWeld : freshClenchGrid.Weld := ⟨.freshOccurrence, Or.inr rfl⟩ def quietReading : quietGrid.FetterReading where provocationClass _ _ := True def freshReading : freshClenchGrid.FetterReading where provocationClass _ _ := True theorem quiet_seen_run : quietGrid.RunQuietOn QuietDesignatum.being (quietReading.provocationClass Fetter.identityView) [quietSeen] := by intro w _hmem _hactual _hagent _hclass cases w dsimp [Grid.share, quietGrid, AtBot, shareBot] exact Nat.le_refl 0 theorem fresh_seen_run : freshClenchGrid.RunQuietOn QuietDesignatum.being (freshReading.provocationClass Fetter.identityView) [freshSeen] := by intro w hmem _hactual _hagent _hclass simp only [List.mem_cons, List.not_mem_nil, or_false] at hmem subst hmem dsimp [Grid.share, freshClenchGrid, freshSeen, AtBot, shareBot] exact Nat.le_refl 0 theorem quiet_fetterCut : quietGrid.FetterCut QuietDesignatum.being quietReading Fetter.identityView := by intro _w _hactual _hagent _hclass exact Nat.le_refl 0 theorem fresh_not_fetterCut : ¬ freshClenchGrid.FetterCut QuietDesignatum.being freshReading Fetter.identityView := by intro hcut have hbot := hcut freshWeld rfl rfl True.intro dsimp [Grid.share, freshClenchGrid, freshWeld, AtBot, shareBot] at hbot exact Nat.not_succ_le_zero 0 hbot /-- Identical one-weld quiet transcripts admit opposite whole-class verdicts because the fresh weld is outside the run. -/ theorem seen_run_underdetermines_fetterCut : quietGrid.RunQuietOn QuietDesignatum.being (quietReading.provocationClass Fetter.identityView) [quietSeen] ∧ freshClenchGrid.RunQuietOn QuietDesignatum.being (freshReading.provocationClass Fetter.identityView) [freshSeen] ∧ quietGrid.FetterCut QuietDesignatum.being quietReading Fetter.identityView ∧ ¬ freshClenchGrid.FetterCut QuietDesignatum.being freshReading Fetter.identityView := ⟨quiet_seen_run, fresh_seen_run, quiet_fetterCut, fresh_not_fetterCut⟩ /- View content is also supplied rather than recovered. -/ def viewLanguage : ClaimLanguage quietGrid where Claim := Bool Holds _ _ := True def ownerAll : quietGrid.ViewReading viewLanguage where ownerClaim _ := True def ownerNone : quietGrid.ViewReading viewLanguage where ownerClaim _ := False abbrev ViewGridData : Type := (QuietDesignatum → QuietDesignatum → Option QuietDesignatum) × (QuietDesignatum → Nat) def viewGridData : ViewGridData := (quietGrid.respondsTo, quietGrid.grade) theorem no_view_content_recovery : ¬ ∃ recover : ViewGridData → Bool → Prop, recover viewGridData = ownerAll.ownerClaim ∧ recover viewGridData = ownerNone.ownerClaim := by rintro ⟨recover, hall, hnone⟩ have ht : recover viewGridData true := by rw [hall]; exact True.intro have hf : ¬ recover viewGridData true := by rw [hnone]; exact fun h => h exact hf ht /- One checked coarsening-freeze correlation: the owner classifier names the stored-owner claim about a supplied merge, but does not derive it. -/ inductive MergeClaim | freezeOwner (left right : Bool) | other deriving DecidableEq def mergeOccurrence : OccurrenceReading Bool where occurrence _ := True isBeing _ := True isCall _ := True isResponse _ := True agent := id call := id response := id def mergeGrid : CoreReadings Bool Nat where occurrence := mergeOccurrence response := { respondsTo := fun b _ => some b } placement := { grade := fun _ => 0 } conditioning := { conditions := fun _ _ => True } def mergeLanguage : ClaimLanguage mergeGrid where Claim := MergeClaim Holds _ _ := True def mergeViewReading : mergeGrid.ViewReading mergeLanguage where ownerClaim claim := claim = .freezeOwner false true def suppliedMerge : Grid.DirectedConvention.BeingConvention.BeingCoarsening mergeGrid Unit where proj _ := () theorem ownerClaim_coarsening_freeze_correlation : mergeViewReading.ownerClaim (.freezeOwner false true) ∧ suppliedMerge.SameFiber false true := ⟨rfl, rfl⟩ /- The new typing keeps view and rites distinct in one concrete model. -/ def factorLanguage : ClaimLanguage Grid.doorWitnessGrid where Claim := Bool Holds _ _ := True def factorSpeechReading : Grid.doorWitnessGrid.SpeechReading factorLanguage where toDoorReading := Grid.doorWitnessReading voices w := match w.call with | .mind => some true | _ => none def factorViewReading : Grid.doorWitnessGrid.ViewReading factorLanguage where ownerClaim claim := claim = true def factorFetterReading : Grid.doorWitnessGrid.FetterReading where provocationClass f w := match f with | .identityView => w.call = .mind | .ritesGrasp => w.call = .body | _ => False theorem factor_view_cut : Grid.doorWitnessGrid.FetterCut Grid.DoorWitnessDesignatum.being factorFetterReading Fetter.identityView := by rintro ⟨d, hd⟩ _hactual _hagent hclass change d = Grid.DoorWitnessDesignatum.speechOccurrence ∨ d = .mindOccurrence ∨ d = .bodyOccurrence at hd change Grid.doorWitnessOccurrence.call d = Grid.DoorWitnessDesignatum.mind at hclass rcases hd with rfl | rfl | rfl · contradiction · exact Nat.le_refl 0 · contradiction theorem factor_rites_not_cut : ¬ Grid.doorWitnessGrid.FetterCut Grid.DoorWitnessDesignatum.being factorFetterReading Fetter.ritesGrasp := by intro hcut have hbot := hcut Grid.doorWitnessBodyWeld rfl rfl rfl exact Grid.doorWitnessBodyWeld_live hbot theorem view_cut_rites_cut_split : Grid.doorWitnessGrid.FetterCut Grid.DoorWitnessDesignatum.being factorFetterReading Fetter.identityView ∧ ¬ Grid.doorWitnessGrid.FetterCut Grid.DoorWitnessDesignatum.being factorFetterReading Fetter.ritesGrasp := ⟨factor_view_cut, factor_rites_not_cut⟩ end FettersNegative end KannoSoe ===== FILE: KannoSoe/Doctrines/FourTruths.lean ===== /- ================================================================================ KannoSoe.Doctrines.FourTruths Checked four-truth-facing consequences in the grid's own vocabulary ================================================================================ This module separates the grid-derived clench mismatch from its supplied phenomenal reading. Mismatch covaries with share because it is read from the same Row-2 display value; whether that mismatch is suffered is relative to a `SentienceReading`. -/ import KannoSoe.Consequences.Basic namespace KannoSoe namespace Grid variable {Designatum Contrib : Type} [PreorderBot Contrib] variable (G : CoreReadings Designatum Contrib) /- ============================================================================== Truths 1-3: mismatch as a display reading ============================================================================== -/ /-- `KsmdMismatchGrade` is read from the same structure as share. This is covariation, not a second operational measure. -/ def KsmdMismatchGrade (w : G.Weld) : Contrib := G.share w omit [PreorderBot Contrib] in @[simp] theorem ksmdMismatchGrade_eq_share (w : G.Weld) : KsmdMismatchGrade G 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 ksmdMismatchGrade_le_of_share_le {w₁ w₂ : G.Weld} (h : G.share w₁ ≼ G.share w₂) : KsmdMismatchGrade G w₁ ≼ KsmdMismatchGrade G w₂ := h /-- The structural content formerly carried by `KsmdMismatchLive`: an actual occurrence with a live self-pole index. It is grid-statable for sentient and insentient acts alike. -/ def ClenchMismatch (w : G.Weld) : Prop := G.Actual w ∧ G.HasSelfPoleIndex w /-- Given occurrence actuality, clench mismatch is exactly the live self-pole index condition. -/ theorem clenchMismatch_iff_hasSelfPoleIndex {w : G.Weld} (hactual : G.Actual w) : ClenchMismatch G w ↔ G.HasSelfPoleIndex w := by constructor · intro h exact h.right · intro hidx exact ⟨hactual, hidx⟩ /-- Dukkha is the sentient reading of a structural clench mismatch. The structure is derived; the suffering is supplied. -/ def KsmdDukkha (S : SentienceReading G) (w : G.Weld) : Prop := S.sentient w ∧ ClenchMismatch G w theorem clenchMismatch_of_ksmdDukkha {S : SentienceReading G} {w : G.Weld} (h : KsmdDukkha G S w) : ClenchMismatch G w := h.right theorem sentientAct_of_ksmdDukkha {S : SentienceReading G} {w : G.Weld} (h : KsmdDukkha G S w) : G.SentientAct S w := ⟨h.right.left, h.left⟩ /-- Insentient appropriation carries the same structural mismatch without a dukkha reading. -/ theorem clenchMismatch_of_insentientAppropriation {S : SentienceReading G} {w : G.Weld} (h : G.InsentientAppropriation S w) : ClenchMismatch G w := ⟨h.left.left, h.right⟩ theorem not_ksmdDukkha_of_insentientAct {S : SentienceReading G} {w : G.Weld} (h : G.InsentientAct S w) : ¬ KsmdDukkha G S w := fun hdukkha => h.right hdukkha.left /-- A terminus response has mismatch grade at the pole-class. -/ theorem ksmdMismatch_atBot_of_terminus_response {w : G.Weld} (hterm : G.Terminus w.agent) (hactual : G.Actual w) : AtBot (KsmdMismatchGrade G w) := G.atBot_of_terminus_response hterm hactual /-- A terminus response has no clench mismatch. -/ theorem not_clenchMismatch_of_terminus_response {w : G.Weld} (hterm : G.Terminus w.agent) (hactual : G.Actual w) : ¬ ClenchMismatch G w := by intro h exact h.right (ksmdMismatch_atBot_of_terminus_response G hterm hactual) theorem not_ksmdDukkha_of_terminus_response (S : SentienceReading G) {w : G.Weld} (hterm : G.Terminus w.agent) (hactual : G.Actual w) : ¬ KsmdDukkha G S w := fun h => not_clenchMismatch_of_terminus_response G hterm hactual h.right end Grid namespace CoreReadings variable {Designatum Contrib : Type} [PreorderBot Contrib] abbrev KsmdMismatchGrade (G : CoreReadings Designatum Contrib) := Grid.KsmdMismatchGrade G abbrev ClenchMismatch (G : CoreReadings Designatum Contrib) := Grid.ClenchMismatch G abbrev KsmdDukkha (G : CoreReadings Designatum Contrib) := Grid.KsmdDukkha G abbrev not_clenchMismatch_of_terminus_response (G : CoreReadings Designatum Contrib) {w : G.Weld} (hterm : G.Terminus w.agent) (hactual : G.Actual w) := Grid.not_clenchMismatch_of_terminus_response G hterm hactual end CoreReadings end KannoSoe ===== FILE: KannoSoe/Doctrines/FoxCase.lean ===== /- ================================================================================ KannoSoe.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 KannoSoe.Consequences.FoxCase import KannoSoe.Doctrines.Doors import KannoSoe.Doctrines.FourTruths namespace KannoSoe namespace FoxCase open Grid open Grid.DirectedConvention open Grid.DirectedConvention.BeingConvention open Grid.DirectedConvention.BeingConvention.GridConvention /-- The worked fox production reading. The old man's sentence and the release instruction are speech-door productions; other welds are silent. -/ def foxSpeechReading : foxGrid.SpeechReading (rowLanguage foxGrid) where door _ := .speech voices w := match w.response with | .notFall => some (.denied .foxWeld) | .release => some (.inForce .foxWeld) | .clench => none | _ => none def oldManProduction : foxGrid.ProducedUtterance foxSpeechReading where weld := sentenceWeld actual := sentenceWeld_actual content := .denied .foxWeld voiced := rfl def jinshinIngaInstructionProduction : foxGrid.ProducedUtterance foxSpeechReading where weld := releaseWeld actual := releaseWeld_actual content := .inForce .foxWeld voiced := rfl theorem oldManProduction_toRecorded : oldManProduction.toRecorded rfl = oldManUtterance := rfl /-- The old man's "not fall" is assertably wrong and defiled: its act-time content misfits and the sentence weld carries a live self-pole. -/ theorem oldMan_defiledFalsehood : foxGrid.KsmdDefiledFalsehood foxSpeechReading oldManProduction := by refine ⟨rfl, ?_, sentenceWeld_hasSelfPoleIndex⟩ rcases oldMan_utterance_misfits with ⟨w, _hoff, hfalse⟩ exact hfalse /-- The daishugyō floor face is structurally unproduced. Every testimonial production is offered at its own act-time, whereas this face is at floor. This sits beside, and does not replace, its existing error-free theorem. -/ theorem daishugyo_floor_face_unproduced : ¬ ∃ u : foxGrid.ProducedUtterance foxSpeechReading, ∃ hspeech : foxSpeechReading.door u.weld = .speech, u.toRecorded hspeech = daishugyoFloorUtterance := by rintro ⟨u, hspeech, hrecord⟩ have hoff := congrArg (fun record : Grid.RecordedUtterance foxGrid (rowLanguage foxGrid) => record.offeredAt) hrecord cases hoff /-- Counterfactual reading in which the release weld voices the denied floor claim instead of the fitting instruction. -/ def foxFloorSpeechReading : foxGrid.SpeechReading (rowLanguage foxGrid) where door _ := .speech voices w := match w.response with | .notFall => some (.denied .foxWeld) | .release => some (.denied .foxWeld) | .clench => none | _ => none def jinshinIngaFloorProduction : foxGrid.ProducedUtterance foxFloorSpeechReading where weld := releaseWeld actual := releaseWeld_actual content := .denied .foxWeld voiced := rfl theorem jinshinIngaFloorProduction_toRecorded : jinshinIngaFloorProduction.toRecorded rfl = jinshinIngaFloorVoicing := rfl /-- The counterfactual floor voicing is defiled by the same predicate as the old man's sentence: both converge on act-time misfit plus a live self-pole. -/ theorem jinshinInga_floor_voicing_defiled : foxGrid.KsmdDefiledFalsehood foxFloorSpeechReading jinshinIngaFloorProduction := by refine ⟨rfl, ?_, releaseWeld_hasSelfPoleIndex⟩ rcases jinshinInga_floor_voicing_would_misfit with ⟨w, _hoff, hfalse⟩ exact hfalse /- A terminus producer of `jinshinIngaInstructionProduction` would place its weld at the pole, making the fitting instruction teaching without arrogation. The occurrence theorem is supplied with the Faith migration. -/ /-- Each clenched reception carries the structural mismatch, and its grade is definitionally the reception's share. -/ theorem fox_clenchMismatch_per_life (n : Nat) : foxGrid.ClenchMismatch (lifeReception (n + 1)) ∧ foxGrid.KsmdMismatchGrade (lifeReception (n + 1)) = foxGrid.share (lifeReception (n + 1)) := ⟨fox_reception_clenched n, rfl⟩ /-- Under a reading that marks the reception, the same structural witness has the dukkha reading. The mark is an explicit hypothesis, not grid output. -/ theorem fox_dukkha_per_life (S : foxGrid.SentienceReading) (n : Nat) (hsentient : S.sentient (lifeReception (n + 1))) : foxGrid.KsmdDukkha S (lifeReception (n + 1)) := ⟨hsentient, (fox_clenchMismatch_per_life n).1⟩ end FoxCase end KannoSoe ===== FILE: KannoSoe/Doctrines/Gradeability.lean ===== /- ================================================================================ KannoSoe.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 KannoSoe.Signature.Claims import KannoSoe.Signature.Models namespace KannoSoe namespace Grid variable {Designatum 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. -/ @[ext] structure SeveredTranscript (G : CoreReadings Designatum Contrib) where agent : Designatum response : Designatum namespace Weld /-- Forget the call carried by a weld. -/ def sever {G : CoreReadings Designatum Contrib} (w : G.Weld) : SeveredTranscript G := { agent := w.agent, response := w.response } omit [PreorderBot Contrib] in @[simp] theorem sever_agent {G : CoreReadings Designatum Contrib} (w : G.Weld) : (w.sever).agent = w.agent := rfl omit [PreorderBot Contrib] in @[simp] theorem sever_response {G : CoreReadings Designatum Contrib} (w : G.Weld) : (w.sever).response = w.response := rfl omit [PreorderBot Contrib] in /-- 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 : CoreReadings Designatum Contrib} {w₁ w₂ : G.Weld} (hagent : w₁.agent = w₂.agent) (hresponse : w₁.response = w₂.response) : w₁.sever = w₂.sever := by apply SeveredTranscript.ext · exact hagent · exact hresponse end Weld namespace RecordedUtterance /-- A recorded utterance is severed by forgetting the call already carried in its weld. -/ def sever {G : CoreReadings Designatum Contrib} {L : ClaimLanguage G} (u : RecordedUtterance G L) : SeveredTranscript G := u.weld.sever omit [PreorderBot Contrib] in @[simp] theorem sever_eq_weld_sever {G : CoreReadings Designatum 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 : CoreReadings Designatum 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 {Designatum Contrib : Type} [PreorderBot Contrib] {G : CoreReadings Designatum Contrib} {L : Grid.ClaimLanguage G} (u : Grid.RecordedUtterance G L) : G.share u.weld = G.grade u.weld.val := rfl namespace GradeabilityNegative variable {Designatum Contrib : Type} [PreorderBot Contrib] omit [PreorderBot Contrib] in /-- 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 : CoreReadings Designatum Contrib} {w₁ w₂ : G.Weld} (hfaces : ∀ x y : G.Weld, x.agent = y.agent → x.call = y.call → x.response = y.response → x = y) (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₂ := hfaces w₁ w₂ hagent hcall hresponse exact hshare (by rw [hw]) omit [PreorderBot Contrib] in /-- 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 : CoreReadings Designatum 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 := backslideWeld .gentle /-- The harsh call in `backslideGrid`: same agent and response as the gentle call, but live share. -/ def severedHarsh : backslideGrid.Weld := backslideWeld .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 ⟨by rfl, by 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 KannoSoe ===== FILE: KannoSoe/Doctrines/Icchantika.lean ===== /- ================================================================================ KannoSoe.Doctrines.Icchantika The icchantika as a declined foreclosure case ================================================================================ Reading and motivation: Identification/Commentary.lean, C.13. -/ import KannoSoe.Doctrines.Sraddha namespace KannoSoe open Grid.DirectedConvention variable {Designatum Contrib : Type} [PreorderBot Contrib] /- ============================================================================== Icchantika typing ============================================================================== -/ /-- The icchantika read literally as a run-shape, not as a stored nature: an actual occurrence is supplied, and every actual response remains live at the self-pole index. Reading and motivation: `Identification/Commentary.lean`, C.13. -/ def Icchantika (G : CoreReadings Designatum Contrib) (b : Designatum) : Prop := G.ActualAgentInhabited b ∧ ∀ w : G.Weld, G.Actual w → w.agent = b → G.HasSelfPoleIndex w /-- 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 : CoreReadings Designatum Contrib} {b : Designatum} (h : Icchantika G b) : ¬ G.Terminus b := by intro hterm rcases h.left with ⟨w, hactual, hagent⟩ subst b exact h.right w hactual rfl (G.atBot_of_terminus_response hterm hactual) /-- The honest negative fact: an icchantika cannot be seated as a fully enlightened agent on this run, because `KsmdEffectiveTerminus` includes terminus typing. This is not a verdict that the being cannot become buddha. Reading and motivation: `Identification/Commentary.lean`, C.13. -/ theorem not_ksmdEffectiveTerminus_of_icchantika {G : CoreReadings Designatum Contrib} {b : Designatum} (h : Icchantika G b) : ¬ KsmdEffectiveTerminus 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 : CoreReadings Designatum Contrib} {before : Config Contrib} {b : Designatum} {reception : G.Weld} (hagent : reception.agent = b) (hic : Icchantika G b) (hactual : G.Actual reception) (hlive : ¬ AtBot before.tendency) : KsmdAversionContext G before reception := by refine { liveBefore := hlive clenchMismatch := ?_ } refine ⟨hactual, ?_⟩ exact hic.right reception hactual hagent /-- 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 : CoreReadings Designatum Contrib} {g b : Designatum} {before : Config Contrib} {deed reception : G.Weld} (hfaith : KsmdEffectiveTerminus G g) (hdeed : deed.agent = g) (hdel : Grid.DirectedConvention.DeliveredTo G deed reception) (hreceiver : reception.agent = b) (hic : Icchantika G b) (hactual : G.Actual reception) (hlive : ¬ AtBot before.tendency) : HasShareDropLanding G before deed := ksmd_path_landing G hfaith hdeed hdel (aversionContext_of_icchantika_reception (G := G) hreceiver hic hactual hlive) /- ============================================================================== Concrete non-foreclosure witness ============================================================================== -/ namespace IcchantikaCase /-- The one designatum carrier for the declined foreclosure witness. -/ inductive CaseDesignatum | buddha | icchantika | call | response | buddhaOccurrence | icchantikaOccurrence deriving DecidableEq def occurrenceReading : OccurrenceReading CaseDesignatum where occurrence | .buddhaOccurrence | .icchantikaOccurrence => True | _ => False isBeing | .buddha | .icchantika => True | _ => False isCall d := d = .call isResponse d := d = .response agent | .buddhaOccurrence => .buddha | .icchantikaOccurrence => .icchantika | d => d call | .buddhaOccurrence | .icchantikaOccurrence => .call | d => d response | .buddhaOccurrence | .icchantikaOccurrence => .response | d => d /-- A concrete grid where the icchantika mounts a live response and a buddha deed is delivered to that response. -/ def grid : CoreReadings CaseDesignatum Nat where occurrence := occurrenceReading response := { respondsTo := fun b c => match b, c with | .buddha, .call | .icchantika, .call => some .response | _, _ => none } placement := { grade := fun d => match d with | .icchantikaOccurrence => 1 | _ => 0 } conditioning := { conditions := fun deed reception => deed = .buddhaOccurrence ∧ reception = .icchantikaOccurrence } /-- 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 := ⟨.buddhaOccurrence, True.intro⟩ /-- The icchantika-side reception in the concrete witness. -/ def reception : grid.Weld := ⟨.icchantikaOccurrence, True.intro⟩ /-- 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 CaseDesignatum.icchantika := by constructor · exact ⟨reception, reception_actual, rfl⟩ · rintro ⟨d, hd⟩ _hactual hagent change occurrenceReading.occurrence d at hd change occurrenceReading.agent d = CaseDesignatum.icchantika at hagent change ¬ AtBot (grid.placement.grade d) cases d with | buddha => change False at hd contradiction | icchantika => change False at hd contradiction | call => change False at hd contradiction | response => change False at hd contradiction | buddhaOccurrence => change CaseDesignatum.buddha = CaseDesignatum.icchantika at hagent contradiction | icchantikaOccurrence => change ¬ (1 : Nat) ≤ 0 decide /-- The buddha deed is delivered to the icchantika reception. -/ theorem delivered : Grid.DirectedConvention.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 : CaseDesignatum, Icchantika grid b := ⟨CaseDesignatum.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.CaseDesignatum) (deed reception : IcchantikaCase.grid.Weld), Icchantika IcchantikaCase.grid b ∧ reception.agent = b ∧ IcchantikaCase.grid.Actual reception ∧ ¬ AtBot before.tendency ∧ Grid.DirectedConvention.DeliveredTo IcchantikaCase.grid deed reception ∧ IcchantikaCase.grid.IsShareDrop before reception ∧ HasShareDropLanding IcchantikaCase.grid before deed := by refine ⟨IcchantikaCase.liveBefore, IcchantikaCase.CaseDesignatum.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 KannoSoe ===== FILE: KannoSoe/Doctrines/Ledger.lean ===== /- ================================================================================ KannoSoe.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 KannoSoe.Consequences.Taxonomy namespace KannoSoe namespace Grid variable {Designatum Contrib : Type} [PreorderBot Contrib] variable (G : CoreReadings Designatum 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 : Designatum) (M : Designatum -> Prop) : Prop := ∀ c r, G.respondsTo b c = some r -> M c omit [PreorderBot Contrib] in /-- An actual weld at a modality-restricted receiver carries a call in that modality. -/ theorem modality_of_actual {M : Designatum -> Prop} {w : G.Weld} (hM : MountsOnlyIn G w.agent M) (hactual : G.Actual w) : M w.call := hM w.call w.response hactual omit [PreorderBot Contrib] in /-- Any landing at a modality-restricted receiver carries a call in that modality. -/ theorem landing_call_in_modality {M : Designatum -> 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 omit [PreorderBot Contrib] in /-- A weld whose call lies outside the receiver's modality cannot be actual. -/ theorem not_actual_outside_modality {M : Designatum -> 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) omit [PreorderBot Contrib] in /-- A reception whose call lies outside the receiver's modality cannot be a landing. -/ theorem no_landing_outside_modality {M : Designatum -> 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 omit [PreorderBot Contrib] in /-- 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 : Designatum -> Prop} (hfiberM : ∀ p : Designatum, κ.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 | .floor, _ => False | .actTime _, claim => DirectedConvention.LandsAt G claim.deed claim.reception omit [PreorderBot Contrib] in /-- 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 cases hoff : u.offeredAt with | floor => rw [hoff] at hfit exact hfit.elim | actTime _ => rw [hoff] 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 Designatum | master | official | practitioner | economic | floor | decree | code | comply | display | codeOccurrence | officialComplyOccurrence | practitionerCodeOccurrence | decreeOccurrence | commandedOccurrence deriving DecidableEq namespace Being abbrev master : Designatum := .master abbrev official : Designatum := .official abbrev practitioner : Designatum := .practitioner end Being namespace Call abbrev economic : Designatum := .economic abbrev floor : Designatum := .floor abbrev decree : Designatum := .decree end Call namespace Response abbrev code : Designatum := .code abbrev comply : Designatum := .comply abbrev display : Designatum := .display end Response /-- The economic modality: the one call class the official ledger can receive. -/ def economicModality : Designatum -> Prop | .economic => True | _ => False def ledgerOccurrence : OccurrenceReading Designatum where occurrence d := d = .codeOccurrence ∨ d = .officialComplyOccurrence ∨ d = .practitionerCodeOccurrence ∨ d = .decreeOccurrence ∨ d = .commandedOccurrence isBeing d := d = .master ∨ d = .official ∨ d = .practitioner isCall d := d = .economic ∨ d = .floor ∨ d = .decree isResponse d := d = .code ∨ d = .comply ∨ d = .display agent d := match d with | .codeOccurrence | .decreeOccurrence => .master | .officialComplyOccurrence | .commandedOccurrence => .official | .practitionerCodeOccurrence => .practitioner | _ => d call d := match d with | .codeOccurrence | .officialComplyOccurrence | .practitionerCodeOccurrence => .economic | .decreeOccurrence => .decree | .commandedOccurrence => .floor | _ => d response d := match d with | .codeOccurrence | .practitionerCodeOccurrence => .code | .officialComplyOccurrence | .commandedOccurrence => .comply | .decreeOccurrence => .display | _ => d /-- 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 : CoreReadings Designatum Nat where occurrence := ledgerOccurrence response := { respondsTo := fun b c => match b, c with | .master, .economic => some .code | .master, .decree => some .display | .official, .economic => some .comply | .practitioner, .economic => some .code | _, _ => none } placement := { grade := fun _ => 1 } conditioning := { conditions := fun _ reception => match reception with | .codeOccurrence | .officialComplyOccurrence | .practitionerCodeOccurrence | .commandedOccurrence => True | _ => False } def codeWeld : ledgerGrid.Weld := ⟨.codeOccurrence, Or.inl rfl⟩ def officialComplyWeld : ledgerGrid.Weld := ⟨.officialComplyOccurrence, Or.inr (Or.inl rfl)⟩ def practitionerCodeWeld : ledgerGrid.Weld := ⟨.practitionerCodeOccurrence, Or.inr (Or.inr (Or.inl rfl))⟩ def decreeWeld : ledgerGrid.Weld := ⟨.decreeOccurrence, Or.inr (Or.inr (Or.inr (Or.inl rfl)))⟩ def commandedReception : ledgerGrid.Weld := ⟨.commandedOccurrence, Or.inr (Or.inr (Or.inr (Or.inr rfl)))⟩ 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 <;> simp [ledgerGrid, economicModality] at h ⊢ theorem official_actualAgentInhabited : ledgerGrid.ActualAgentInhabited Being.official := ⟨officialComplyWeld, officialComplyWeld_actual, rfl⟩ theorem official_landing_only_economic {deed reception : ledgerGrid.Weld} (hagent : reception.agent = Being.official) (hland : LandsAt ledgerGrid deed reception) : economicModality reception.call := by apply landing_call_in_modality ledgerGrid ?_ hland simpa [hagent] using official_mountsOnlyIn_economic 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 p := if p = Being.official then Sector.state else Sector.sangha def ledgerSentienceReading : ledgerGrid.SentienceReading := Grid.SentienceReading.allSentient ledgerGrid theorem state_tag_sentient : sectorCoarsening.SentientTag ledgerSentienceReading Sector.state := ⟨officialComplyWeld, ⟨officialComplyWeld_actual, by change True exact True.intro⟩, rfl⟩ theorem state_fiber_shares_register : ∀ p : Designatum, sectorCoarsening.proj p = Sector.state -> MountsOnlyIn ledgerGrid p economicModality := by intro p hp cases p <;> simp [sectorCoarsening] at hp exact official_mountsOnlyIn_economic 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 : Grid.DirectedConvention.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 : Grid.DirectedConvention.DeliveredTo ledgerGrid decreeWeld commandedReception ∧ ¬ ledgerGrid.Actual commandedReception ∧ ¬ decreeUtterance.FitsOfferedTier := ⟨commandedReception_delivered, commandedReception_not_actual, decree_utterance_not_fits⟩ end LedgerCase end KannoSoe ===== FILE: KannoSoe/Doctrines/OtherPower.lean ===== /- ================================================================================ KannoSoe.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 KannoSoe.Consequences.Basic namespace KannoSoe namespace Grid namespace DirectedConvention variable {Designatum Contrib : Type} [PreorderBot Contrib] variable (G : CoreReadings Designatum Contrib) omit [PreorderBot Contrib] in /-- 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₂ : Designatum -> Designatum -> Prop) (reception : G.Weld) : (G.withConditions conditions₁).grade reception.val = (G.withConditions conditions₂).grade reception.val ∧ (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.val, G.share_independent_of_conditions conditions₁ conditions₂ reception, Iff.rfl⟩ omit [PreorderBot Contrib] in /-- 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 ksmdReachBack_filled_either_regime {deed reception : G.Weld} (_hactual : G.Actual reception) : (SameAgentDelivery G deed reception → KsmdReachBackFull G deed reception) ∧ (CrossAgentDelivery G deed reception → KsmdReachBackFull G deed reception) := ⟨fun h => h.left, fun h => h.left⟩ /-- Other-power line: a cross-agent delivery line read in KannoSoe vocabulary. -/ abbrev KsmdTarikiLine (deed reception : G.Weld) : Prop := CrossAgentDelivery G deed reception /-- Self-power line: a same-agent delivery line read in KannoSoe vocabulary. -/ abbrev KsmdJirikiLine (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 Designatum | invoker | name | heard | chime | receive | nameOccurrence | invokerOccurrence deriving DecidableEq namespace Being abbrev invoker : Designatum := .invoker abbrev name : Designatum := .name end Being namespace Call abbrev heard : Designatum := .heard end Call namespace Response abbrev chime : Designatum := .chime abbrev receive : Designatum := .receive end Response def tarikiOccurrence : OccurrenceReading Designatum where occurrence d := d = .nameOccurrence ∨ d = .invokerOccurrence isBeing d := d = .name ∨ d = .invoker isCall d := d = .heard isResponse d := d = .chime ∨ d = .receive agent d := match d with | .nameOccurrence => .name | .invokerOccurrence => .invoker | _ => d call d := match d with | .nameOccurrence | .invokerOccurrence => .heard | _ => d response d := match d with | .nameOccurrence => .chime | .invokerOccurrence => .receive | _ => d /-- 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 : CoreReadings Designatum Nat where occurrence := tarikiOccurrence response := { respondsTo := fun b _ => match b with | .name => some .chime | .invoker => some .receive | _ => none } placement := { grade := fun d => match d with | .invokerOccurrence => 1 | _ => 0 } conditioning := { conditions := fun deed reception => deed = .nameOccurrence ∧ reception = .invokerOccurrence } 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 := ⟨.nameOccurrence, Or.inl rfl⟩ def invokerReception : tarikiGrid.Weld := ⟨.invokerOccurrence, Or.inr rfl⟩ 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₂ change some .chime = some r₁ at h₁ change some .chime = some r₂ at h₂ exact Option.some.inj (h₁.symm.trans h₂) theorem name_actualAgentInhabited : tarikiGrid.ActualAgentInhabited Being.name := ⟨nameWeld, rfl, rfl⟩ theorem name_share_bot (w : tarikiGrid.Weld) (hagent : w.agent = Being.name) : tarikiGrid.share w = 0 := by rcases w with ⟨d, hd⟩ change d = .nameOccurrence ∨ d = .invokerOccurrence at hd rcases hd with rfl | rfl · rfl · cases hagent theorem name_object_axis_entire (reception : tarikiGrid.Weld) (hagent : reception.agent = Being.invoker) : Grid.DirectedConvention.DeliveredTo tarikiGrid nameWeld reception := by rcases reception with ⟨d, hd⟩ change d = .nameOccurrence ∨ d = .invokerOccurrence at hd rcases hd with rfl | rfl · cases hagent · change Designatum.nameOccurrence = Designatum.nameOccurrence ∧ Designatum.invokerOccurrence = Designatum.invokerOccurrence exact ⟨rfl, rfl⟩ /-- 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⟩, ?_⟩⟩ rcases reception with ⟨d, hd⟩ change d = .nameOccurrence ∨ d = .invokerOccurrence at hd rcases hd with rfl | rfl · cases hagent · constructor · show (1 : Nat) ≤ 2 decide · show ¬ (2 : Nat) ≤ 1 decide theorem name_to_invoker_tarikiLine : KsmdTarikiLine 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 KannoSoe ===== FILE: KannoSoe/Doctrines/OtherPowerNegative.lean ===== /- ================================================================================ KannoSoe.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 KannoSoe.Doctrines.OtherPower namespace KannoSoe namespace OtherPowerNegative open Grid.DirectedConvention inductive Designatum | source | receiver | live | pole | response | sourceLiveOccurrence | sourcePoleOccurrence | receiverLiveOccurrence | receiverPoleOccurrence deriving DecidableEq namespace Being abbrev source : Designatum := .source abbrev receiver : Designatum := .receiver end Being namespace Call abbrev live : Designatum := .live abbrev pole : Designatum := .pole end Call namespace Response abbrev response : Designatum := .response end Response def regimeOccurrence : OccurrenceReading Designatum where occurrence d := d = .sourceLiveOccurrence ∨ d = .sourcePoleOccurrence ∨ d = .receiverLiveOccurrence ∨ d = .receiverPoleOccurrence isBeing d := d = .source ∨ d = .receiver isCall d := d = .live ∨ d = .pole isResponse d := d = .response agent d := match d with | .sourceLiveOccurrence | .sourcePoleOccurrence => .source | .receiverLiveOccurrence | .receiverPoleOccurrence => .receiver | _ => d call d := match d with | .sourceLiveOccurrence | .receiverLiveOccurrence => .live | .sourcePoleOccurrence | .receiverPoleOccurrence => .pole | _ => d response d := match d with | .sourceLiveOccurrence | .sourcePoleOccurrence | .receiverLiveOccurrence | .receiverPoleOccurrence => .response | _ => d /-- Delivery is total; reception share is controlled only by the call. -/ def regimeShareGrid : CoreReadings Designatum Nat where occurrence := regimeOccurrence response := { respondsTo := fun b c => if (b = .source ∨ b = .receiver) ∧ (c = .live ∨ c = .pole) then some .response else none } placement := { grade := fun d => match d with | .sourceLiveOccurrence | .receiverLiveOccurrence => 1 | _ => 0 } conditioning := { conditions := fun _ _ => True } def sameLiveDeed : regimeShareGrid.Weld := ⟨.sourceLiveOccurrence, Or.inl rfl⟩ def sameLiveReception : regimeShareGrid.Weld := sameLiveDeed def samePoleReception : regimeShareGrid.Weld := ⟨.sourcePoleOccurrence, Or.inr (Or.inl rfl)⟩ def crossLiveDeed : regimeShareGrid.Weld := sameLiveDeed def crossLiveReception : regimeShareGrid.Weld := ⟨.receiverLiveOccurrence, Or.inr (Or.inr (Or.inl rfl))⟩ def crossPoleReception : regimeShareGrid.Weld := ⟨.receiverPoleOccurrence, Or.inr (Or.inr (Or.inr rfl))⟩ 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 KannoSoe ===== FILE: KannoSoe/Doctrines/Shusho.lean ===== /- ================================================================================ KannoSoe.Doctrines.Shusho Per-occurrence effectiveness face and standing-display fence ================================================================================ Reading and motivation: Identification/Commentary.lean, C.4. -/ import KannoSoe.Doctrines.Sraddha import KannoSoe.Doctrines.Doors namespace KannoSoe namespace Grid namespace DirectedConvention variable {Designatum Contrib : Type} [PreorderBot Contrib] variable (G : CoreReadings Designatum Contrib) /-- The sho face of a single occurrence: an actual weld whose share sits in the pole-class. No standing rank is implied; the fact is about this act and is spent with it. Reading and motivation: Identification/Commentary.lean, C.4. -/ def KsmdPoleDeed (w : G.Weld) : Prop := G.Actual w ∧ AtBot (G.share w) /-- Shushō-ittō, grid-side: effective closure as a fact about one delivered occurrence -- a pole-typed actual deed landing with a share-drop against a live prior tendency. This, not the standing predicate, is what act-time verdicts may assert. Reading and motivation: Identification/Commentary.lean, C.4. -/ def KsmdEffectiveOccurrence (before : Config Contrib) (deed reception : G.Weld) : Prop := KsmdPoleDeed G deed ∧ ¬ AtBot before.tendency ∧ LandsWithShareDrop G before deed reception theorem ksmdEffectiveOccurrence_hasShareDropLanding {before : Config Contrib} {deed reception : G.Weld} (h : KsmdEffectiveOccurrence G before deed reception) : HasShareDropLanding G before deed := ⟨reception, h.right.right⟩ theorem ksmdPoleDeed_of_terminus_response {w : G.Weld} (hterm : G.Terminus w.agent) (hactual : G.Actual w) : KsmdPoleDeed G w := ⟨hactual, G.atBot_of_terminus_response hterm hactual⟩ /-- Any supplied production by a terminus producer has the per-occurrence shō face. The statement is door-neutral; speech-door productions may then enter testimony, while mind-door productions remain character evidence. -/ theorem ksmdPoleDeed_of_produced_terminus {L : ClaimLanguage G} {sr : SpeechReading G L} (u : ProducedUtterance sr) (hterm : G.Terminus u.weld.agent) : KsmdPoleDeed G u.weld := ksmdPoleDeed_of_terminus_response G hterm u.actual /-- The standing display entails an occurrence face only once the deed is an actual mounted response and the regime supplies a live delivered pair. The landing witness may be a different actual reception from the supplied delivery, because `ShortfallClosedAt` asserts existence of a share-drop landing for that deed. -/ theorem ksmdEffectiveOccurrence_of_ksmdEffectiveTerminus {b : Designatum} {before : Config Contrib} {deed reception : G.Weld} (h : KsmdEffectiveTerminus G b) (hdeed : deed.agent = b) (hactual : G.Actual deed) (hdel : DeliveredTo G deed reception) (hlive : ¬ AtBot before.tendency) : ∃ reception', KsmdEffectiveOccurrence G before deed reception' := by rcases shortfallClosedAt_of_ksmdEffectiveTerminus G h hdeed hlive hdel with ⟨reception', hland⟩ refine ⟨reception', ?_⟩ refine ⟨?_, hlive, hland⟩ have htermDeed : G.Terminus deed.agent := by simpa [hdeed] using h.left.right exact ksmdPoleDeed_of_terminus_response G htermDeed hactual /-- The old sraddha landing route factors through the per-occurrence face once the speaker's deed is known to be actual. -/ theorem ksmd_path_landing_factors {g : Designatum} {before : Config Contrib} {deed reception : G.Weld} (hfaith : KsmdEffectiveTerminus G g) (hdeed : deed.agent = g) (hactual : G.Actual deed) (hdel : DeliveredTo G deed reception) (hctx : KsmdAversionContext G before reception) : ∃ reception', KsmdEffectiveOccurrence G before deed reception' := ksmdEffectiveOccurrence_of_ksmdEffectiveTerminus G hfaith hdeed hactual hdel hctx.liveBefore /-- Earned, non-vacuous effectiveness display: the standing pattern plus at least one actual effective occurrence witnessing it. The sealed-regime terminus satisfies the standing predicate vacuously and fails this enacted form. -/ def KsmdEffectivenessEnacted (b : Designatum) : Prop := KsmdEffectiveTerminus G b ∧ ∃ before deed reception, deed.agent = b ∧ KsmdEffectiveOccurrence G before deed reception theorem ksmdEffectiveTerminus_of_effectivenessEnacted {b : Designatum} (h : KsmdEffectivenessEnacted G b) : KsmdEffectiveTerminus G b := h.left theorem not_effectivenessEnacted_of_undelivered {b : Designatum} (hundelivered : ∀ (deed reception : G.Weld), deed.agent = b → ¬ DeliveredTo G deed reception) : ¬ KsmdEffectivenessEnacted G b := by rintro ⟨_hstanding, before, deed, reception, hdeed, hocc⟩ exact hundelivered deed reception hdeed (deliveredTo_of_landsWithShareDrop G hocc.right.right) namespace BeingConvention namespace GridConvention /-- Per-occurrence effective landing is a grammatical verdict item. -/ def KsmdEffectiveOccurrenceVoice : ErrorGrade := ErrorGrade.verdict /-- The standing universal is displayable as shortfall-voiced, not assertable as an act-time verdict. -/ def KsmdStandingEffectivenessVoice : ErrorGrade := ErrorGrade.shortfall theorem ksmd_effective_occurrence_voice_assertable : ErrorGrade.voice KsmdEffectiveOccurrenceVoice = VerdictVoice.assertable := rfl theorem ksmd_standing_effectiveness_voice_displayable : ErrorGrade.voice KsmdStandingEffectivenessVoice = VerdictVoice.displayable := rfl end GridConvention end BeingConvention end DirectedConvention end Grid end KannoSoe ===== FILE: KannoSoe/Doctrines/Sraddha.lean ===== /- ================================================================================ KannoSoe.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 KannoSoe.Doctrines.FourTruths namespace KannoSoe namespace Grid namespace DirectedConvention variable {Designatum Contrib : Type} [PreorderBot Contrib] variable (G : CoreReadings Designatum Contrib) /-- The receiver-side aversion context: a live prior tendency together with an actual live-mismatch reception. No imported desire primitive is added. -/ structure KsmdAversionContext (before : Config Contrib) (reception : G.Weld) where liveBefore : ¬ AtBot before.tendency clenchMismatch : G.ClenchMismatch reception theorem actual_of_ksmdAversionContext {before : Config Contrib} {reception : G.Weld} (h : KsmdAversionContext G before reception) : G.Actual reception := h.clenchMismatch.left theorem hasSelfPoleIndex_of_ksmdAversionContext {before : Config Contrib} {reception : G.Weld} (h : KsmdAversionContext G before reception) : G.HasSelfPoleIndex reception := h.clenchMismatch.right /-- Given faith-shaped closure, delivery, and the receiver's live aversion context, the share-drop landing follows. -/ theorem ksmd_path_landing {g : Designatum} {before : Config Contrib} {deed reception : G.Weld} (hfaith : KsmdEffectiveTerminus G g) (hdeed : deed.agent = g) (hdel : DeliveredTo G deed reception) (hctx : KsmdAversionContext 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 KsmdPathOught (g : Designatum) (before : Config Contrib) (deed reception : G.Weld) : Prop := KsmdEffectiveTerminus G g → deed.agent = g → DeliveredTo G deed reception → KsmdAversionContext G before reception → HasShareDropLanding G before deed /-- The grid proves only the conditional: faith, delivery, and live aversion imply the landing. -/ theorem ksmdPathOught_conditional (g : Designatum) (before : Config Contrib) (deed reception : G.Weld) : KsmdPathOught G g before deed reception := by intro hfaith hdeed hdel hctx exact ksmd_path_landing G hfaith hdeed hdel hctx /-- At the pole-class, no share-drop landing can be constructed for any deed. -/ theorem no_ksmd_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_ksmd_aversion_context_at_pole {before : Config Contrib} (hbot : AtBot before.tendency) (reception : G.Weld) : ¬ KsmdAversionContext G before reception := fun hctx => hctx.liveBefore hbot namespace BeingConvention namespace GridConvention /-- The checked conditional is a grammatical verdict item. -/ def KsmdConditionalVoice : ErrorGrade := ErrorGrade.verdict /-- The detached injunction is only displayable as shortfall-voiced. -/ def KsmdDetachedOughtVoice : ErrorGrade := ErrorGrade.shortfall theorem ksmd_conditional_voice_assertable : ErrorGrade.voice KsmdConditionalVoice = VerdictVoice.assertable := rfl theorem ksmd_detached_ought_voice_displayable : ErrorGrade.voice KsmdDetachedOughtVoice = VerdictVoice.displayable := rfl end GridConvention end BeingConvention end DirectedConvention end Grid end KannoSoe ===== FILE: KannoSoe/Doctrines/SraddhaNegative.lean ===== /- ================================================================================ KannoSoe.Doctrines.SraddhaNegative Negative witnesses for the sraddha conditional ================================================================================ Reading and motivation: Identification/Commentary.lean, C.4. -/ import KannoSoe.Doctrines.Sraddha namespace KannoSoe /- ============================================================================== Negative witnesses: both antecedents matter ============================================================================== -/ namespace SraddhaNegative open Grid.DirectedConvention inductive CaseDesignatum | sraddha | receiver | call | response | sraddhaOccurrence | receiverOccurrence deriving DecidableEq def occurrenceReading : OccurrenceReading CaseDesignatum where occurrence | .sraddhaOccurrence | .receiverOccurrence => True | _ => False isBeing | .sraddha | .receiver => True | _ => False isCall d := d = .call isResponse d := d = .response agent | .sraddhaOccurrence => .sraddha | .receiverOccurrence => .receiver | d => d call | .sraddhaOccurrence | .receiverOccurrence => .call | d => d response | .sraddhaOccurrence | .receiverOccurrence => .response | d => d /-- A responsive terminus whose delivered deed has no share-drop landing for the receiver's live prior tendency. -/ def zeroEffectGrid : CoreReadings CaseDesignatum Nat where occurrence := occurrenceReading response := { respondsTo := fun b c => match b, c with | .sraddha, .call | .receiver, .call => some .response | _, _ => none } placement := { grade := fun d => match d with | .receiverOccurrence => 1 | _ => 0 } conditioning := { conditions := fun deed reception => deed = .sraddhaOccurrence ∧ reception = .receiverOccurrence } def liveBefore : Config Nat := { tendency := 1 } def poleBefore : Config Nat := { tendency := 0 } def deed : zeroEffectGrid.Weld := ⟨.sraddhaOccurrence, True.intro⟩ def reception : zeroEffectGrid.Weld := ⟨.receiverOccurrence, True.intro⟩ 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 : Grid.DirectedConvention.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 : KsmdAversionContext zeroEffectGrid liveBefore reception := { liveBefore := liveBefore_not_atBot clenchMismatch := ⟨reception_actual, reception_hasSelfPoleIndex⟩ } theorem sraddha_responsiveTerminus : zeroEffectGrid.ResponsiveTerminus CaseDesignatum.sraddha := by constructor · intro c hc change c = CaseDesignatum.call at hc subst c exact ⟨CaseDesignatum.response, rfl⟩ · rintro ⟨d, hd⟩ _hactual hagent change occurrenceReading.occurrence d at hd change occurrenceReading.agent d = CaseDesignatum.sraddha at hagent change AtBot (zeroEffectGrid.placement.grade d) cases d with | sraddha | receiver | call | response => change False at hd contradiction | receiverOccurrence => change CaseDesignatum.receiver = CaseDesignatum.sraddha at hagent contradiction | sraddhaOccurrence => exact Nat.le_refl 0 theorem not_hasShareDropLanding_liveBefore : ¬ HasShareDropLanding zeroEffectGrid liveBefore deed := by rintro ⟨received, hland⟩ have hreceiver : received.1 = CaseDesignatum.receiverOccurrence := hland.left.left.right have hdrop : Strict (zeroEffectGrid.share received) liveBefore.tendency := hland.right rcases received with ⟨d, hd⟩ change d = CaseDesignatum.receiverOccurrence at hreceiver subst d change Strict (1 : Nat) 1 at hdrop exact strict_irrefl (1 : Nat) hdrop theorem not_ksmdEffectiveTerminus : ¬ KsmdEffectiveTerminus zeroEffectGrid CaseDesignatum.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 CaseDesignatum.sraddha ∧ Grid.DirectedConvention.DeliveredTo zeroEffectGrid deed reception ∧ KsmdAversionContext zeroEffectGrid liveBefore reception ∧ ¬ HasShareDropLanding zeroEffectGrid liveBefore deed := ⟨sraddha_responsiveTerminus, delivered, aversionContext, not_hasShareDropLanding_liveBefore⟩ theorem not_hasShareDropLanding_poleBefore : ¬ HasShareDropLanding zeroEffectGrid poleBefore deed := no_ksmd_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 ∧ Grid.DirectedConvention.DeliveredTo zeroEffectGrid deed reception ∧ ¬ KsmdAversionContext zeroEffectGrid poleBefore reception ∧ ¬ HasShareDropLanding zeroEffectGrid poleBefore deed := ⟨poleBefore_atBot, delivered, no_ksmd_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 : CoreReadings SraddhaNegative.CaseDesignatum Nat := SraddhaNegative.zeroEffectGrid theorem responsiveTerminus_with_no_shareDropLanding : zeroEffectGrid.ResponsiveTerminus SraddhaNegative.CaseDesignatum.sraddha ∧ ¬ HasShareDropLanding zeroEffectGrid SraddhaNegative.liveBefore SraddhaNegative.deed := ⟨SraddhaNegative.sraddha_responsiveTerminus, SraddhaNegative.not_hasShareDropLanding_liveBefore⟩ theorem terminus_not_ksmdEffectiveTerminus : zeroEffectGrid.Terminus SraddhaNegative.CaseDesignatum.sraddha ∧ ¬ KsmdEffectiveTerminus zeroEffectGrid SraddhaNegative.CaseDesignatum.sraddha := ⟨SraddhaNegative.sraddha_responsiveTerminus.right, SraddhaNegative.not_ksmdEffectiveTerminus⟩ /-- `KsmdEffectiveTerminus` is strictly stronger than terminus typing: it implies terminus, and this concrete responsive terminus still fails the shortfall-closure conjunct. -/ theorem ksmdEffectiveTerminus_stronger_than_terminus : (KsmdEffectiveTerminus zeroEffectGrid SraddhaNegative.CaseDesignatum.sraddha → zeroEffectGrid.Terminus SraddhaNegative.CaseDesignatum.sraddha) ∧ zeroEffectGrid.Terminus SraddhaNegative.CaseDesignatum.sraddha ∧ ¬ KsmdEffectiveTerminus zeroEffectGrid SraddhaNegative.CaseDesignatum.sraddha := by constructor · intro h exact (responsiveTerminus_of_ksmdEffectiveTerminus zeroEffectGrid h).right · exact terminus_not_ksmdEffectiveTerminus end OrthogonalityNegative end KannoSoe ===== FILE: KannoSoe/Doctrines/SuddenGradual.lean ===== /- ================================================================================ KannoSoe.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 KannoSoe.Signature import KannoSoe.Consequences.Basic import KannoSoe.Consequences.Taxonomy import KannoSoe.Doctrines.Correlations namespace KannoSoe namespace Grid variable {Designatum Contrib : Type} [PreorderBot Contrib] variable (G : CoreReadings Designatum 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 KsmdSuddenArrival (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 omit [PreorderBot Contrib] in @[simp] theorem rePitchRun_nil (before : Config Contrib) : rePitchRun G before [] = before := rfl omit [PreorderBot Contrib] in @[simp] theorem rePitchRun_cons (before : Config Contrib) (received : G.Weld) (rest : List G.Weld) : rePitchRun G before (received :: rest) = rePitchRun G (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 KsmdGradualArrival (before : Config Contrib) (run : List G.Weld) : Prop := ShareDropRun G before run ∧ run.length ≥ 2 ∧ ¬ AtBot before.tendency ∧ AtBot ((rePitchRun G before run).tendency) /- ============================================================================== Rate invisibility ============================================================================== -/ omit [PreorderBot Contrib] in /-- 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 omit [PreorderBot Contrib] in theorem rePitchRun_append_singleton (before : Config Contrib) (run : List G.Weld) (last : G.Weld) : rePitchRun G before (run ++ [last]) = G.rePitch (rePitchRun G before run) last := by induction run generalizing before with | nil => rfl | cons received rest ih => change rePitchRun G (G.rePitch before received) (rest ++ [last]) = G.rePitch (rePitchRun G (G.rePitch before received) rest) last exact ih (G.rePitch before received) omit [PreorderBot Contrib] in /-- 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) : rePitchRun G before₁ (run₁ ++ [last]) = rePitchRun G before₂ (run₂ ++ [last]) := by rw [rePitchRun_append_singleton G before₁ run₁ last, rePitchRun_append_singleton G before₂ run₂ last] exact G.rePitch_forgets (rePitchRun G before₁ run₁) (rePitchRun G before₂ run₂) last omit [PreorderBot Contrib] in /-- 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 (rePitchRun G before₁ (run₁ ++ [last])) = score (rePitchRun G before₂ (run₂ ++ [last])) := by rw [rePitchRun_append_singleton G before₁ run₁ last, rePitchRun_append_singleton G before₂ run₂ last] exact G.accumulated_attainment_constant_of_same_final score (rePitchRun G before₁ run₁) (rePitchRun G before₂ run₂) last end Grid namespace CoreReadings variable {Designatum Contrib : Type} [PreorderBot Contrib] abbrev KsmdSuddenArrival (G : CoreReadings Designatum Contrib) := Grid.KsmdSuddenArrival G abbrev rePitchRun (G : CoreReadings Designatum Contrib) := Grid.rePitchRun G abbrev KsmdGradualArrival (G : CoreReadings Designatum Contrib) := Grid.KsmdGradualArrival G abbrev rePitchRun_append_singleton (G : CoreReadings Designatum Contrib) := Grid.rePitchRun_append_singleton G end CoreReadings /- ============================================================================== Concrete witnesses ============================================================================== -/ /-- The existing clock-grid subitism witness, named in its doctrine-facing one-step arrival form. -/ theorem ksmdSuddenArrival_witness : ∃ (before : Config Nat) (received : clockGrid.Weld), clockGrid.KsmdSuddenArrival before received := by refine ⟨{ tendency := 5 }, clockAdaptivePresent, ?_⟩ 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 ksmdGradualArrival_witness : ∃ (before : Config Nat) (run : List registerClockGrid.Weld), registerClockGrid.KsmdGradualArrival before run := by let first : registerClockGrid.Weld := registerWeld 2 let second : registerClockGrid.Weld := registerWeld 0 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 KannoSoe ===== FILE: KannoSoe/Doctrines/SuddenGradualNegative.lean ===== /- ================================================================================ KannoSoe.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 KannoSoe.Doctrines.SuddenGradual namespace KannoSoe namespace SuddenGradualNegative open Grid.DirectedConvention /- ============================================================================== Delivery frequency is not recovered from response/grade data ============================================================================== -/ def deliveredClockGrid : CoreReadings ClockCase Nat := clockGrid.withConditions (fun _ _ => True) def undeliveredClockGrid : CoreReadings ClockCase Nat := clockGrid.withConditions (fun _ _ => False) def deliveredPole : deliveredClockGrid.Weld := clockAdaptivePresent def undeliveredPole : undeliveredClockGrid.Weld := clockAdaptivePresent abbrev ClockResponseGradeData : Type := (ClockCase -> ClockCase -> Option ClockCase) × (ClockCase -> 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 : ∀ d : ClockCase, deliveredClockGrid.grade d = undeliveredClockGrid.grade d := by intro d exact clockGrid.grade_independent_of_conditions (fun _ _ => True) (fun _ _ => False) d theorem deliveredPole_has_delivery : ∃ reception : deliveredClockGrid.Weld, Grid.DirectedConvention.DeliveredTo deliveredClockGrid deliveredPole reception := ⟨deliveredPole, True.intro⟩ theorem undeliveredPole_no_delivery : ¬ ∃ reception : undeliveredClockGrid.Weld, Grid.DirectedConvention.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, Grid.DirectedConvention.DeliveredTo deliveredClockGrid deliveredPole reception) ∧ (recover undeliveredResponseGradeData ↔ ∃ reception : undeliveredClockGrid.Weld, Grid.DirectedConvention.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) ∧ (∀ d : ClockCase, deliveredClockGrid.grade d = undeliveredClockGrid.grade d) ∧ (∃ reception : deliveredClockGrid.Weld, Grid.DirectedConvention.DeliveredTo deliveredClockGrid deliveredPole reception) ∧ ¬ (∃ reception : undeliveredClockGrid.Weld, Grid.DirectedConvention.DeliveredTo undeliveredClockGrid undeliveredPole reception) ∧ ¬ ∃ recover : ClockResponseGradeData -> Prop, (recover deliveredResponseGradeData ↔ ∃ reception : deliveredClockGrid.Weld, Grid.DirectedConvention.DeliveredTo deliveredClockGrid deliveredPole reception) ∧ (recover undeliveredResponseGradeData ↔ ∃ reception : undeliveredClockGrid.Weld, Grid.DirectedConvention.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 KannoSoe ===== FILE: KannoSoe/Identification/Absences.lean ===== /- ================================================================================ KannoSoe.Identification.Absences Instructive absence enumeration and anchors ================================================================================ Reading and motivation: Identification/Commentary.lean, C.2a. -/ import KannoSoe.Consequences.Ladder import KannoSoe.Consequences.FoxCase import KannoSoe.Doctrines.Sraddha import KannoSoe.Doctrines.Icchantika import KannoSoe.Doctrines.EthicsNegative import KannoSoe.Identification.Ownership namespace KannoSoe /- ------------------------------------------------------------------------------ Routing table for arguments that formerly consumed function-zero Stone ------------------------------------------------------------------------------ -/ /-- Successor layers available after the function-zero stone edge retires. -/ inductive StoneSuccessorRoute where | sentienceMark | landingPattern | enactedDoors | universalFunction deriving Repr, DecidableEq /-- Paper-facing arguments whose old "stone mounts nothing" premise requires an explicit successor. -/ inductive RetiredStoneArgument where | deathFreeze | mirrorGloss | insentientPreaching | quietistArhat deriving Repr, DecidableEq /-- Audited routing for every retired stone argument named by the proposal. -/ def RetiredStoneArgument.successors : RetiredStoneArgument → List StoneSuccessorRoute | .deathFreeze => [.landingPattern, .universalFunction] | .mirrorGloss => [.landingPattern] | .insentientPreaching => [.universalFunction] | .quietistArhat => [.sentienceMark] theorem deathFreeze_successors : RetiredStoneArgument.deathFreeze.successors = [.landingPattern, .universalFunction] := rfl theorem mirrorGloss_successors : RetiredStoneArgument.mirrorGloss.successors = [.landingPattern] := rfl theorem insentientPreaching_successors : RetiredStoneArgument.insentientPreaching.successors = [.universalFunction] := rfl theorem quietistArhat_successors : RetiredStoneArgument.quietistArhat.successors = [.sentienceMark] := rfl /- ============================================================================== 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 former third arrival: the never-clenched candidate is no third structural cell, but a pole weld typed by the supplied mark. The old absence remains as a regression check. -/ | 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: formerly registered as future work. It is now retired as the checked production-level distinction between three-door arhat quiet and buddha no-nescience; neither predicate is a stored rank. -/ | 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 being with live share at every actual weld (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 /-- The cosmology of rebirth — persistence across biological death, the realms, and the mechanism — is ceded as a world-fact. The grammar of ownerless continuation (continuity without a carried bearer; the flame passed without a self) remains in scope, derived from `nothing_selfIndexed_carried` and the field/re-pitch machinery. What is ceded includes persistence and the phenomenal sentience of later welds: the grid brackets the latter with a supplied per-weld reading. The diagnostic work is to mark this boundary rather than manufacture a theorem across it. -/ | rebirthCosmology /-- No positive Truth or Thus predicate is defined at the floor. The floor is present only through silence, indiscernibility, and the negative pole/floor family. The diagnostic work is the registered refusal to turn degeneracy into a truth-maker. -/ | floorTruthPredicate /-- The undefined/zero row retired when the function-zero edge retired. Its loss of an exemplar is retained as an instructive check, with the standing-sentience row occupying the generated-table position. -/ | undefinedZeroRowRetired 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 | .rebirthCosmology => 11 | .floorTruthPredicate => 12 | .undefinedZeroRowRetired => 13 /-- Current world-facing status of each paper entry. Constructors remain the section 3 ledger; this function records retirement. -/ def status : InstructiveAbsence → AbsenceStatus | .thirdArrival => .retiredAsCheck | .noSafeStage => .retiredAsCheck | .icchantikaDeclined => .standing | .rebirthCosmology => .standing | .floorTruthPredicate => .standing | .undefinedZeroRowRetired => .retiredAsCheck | _ => .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 rebirthCosmology_number : number InstructiveAbsence.rebirthCosmology = 11 := rfl theorem floorTruthPredicate_number : number InstructiveAbsence.floorTruthPredicate = 12 := rfl theorem undefinedZeroRowRetired_number : number InstructiveAbsence.undefinedZeroRowRetired = 13 := 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_retired : status InstructiveAbsence.noSafeStage = AbsenceStatus.retiredAsCheck := 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 theorem rebirthCosmology_standing : status InstructiveAbsence.rebirthCosmology = AbsenceStatus.standing := rfl theorem floorTruthPredicate_standing : status InstructiveAbsence.floorTruthPredicate = AbsenceStatus.standing := rfl theorem undefinedZeroRowRetired_retired : status InstructiveAbsence.undefinedZeroRowRetired = AbsenceStatus.retiredAsCheck := 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 {Designatum Contrib : Type} [PreorderBot Contrib] (G : CoreReadings Designatum 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: 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 exact FoxCase.fox_never_tests_pole w hactual (FoxCase.foxGrid.atBot_of_terminus_response hpole 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.MisfitsOfferedTier := FoxCase.oldMan_utterance_misfits /-- The delivered third arrival is on the scale at the pole and unmarked under the reading named here. The marked reading is the other half of `clock_pole_readings_split`. -/ theorem thirdArrival_stone_at_pole : clockGrid.StoneAct (Grid.SentienceReading.allInsentient clockGrid) clockAdaptivePresent := clock_pole_readings_split.left /-- The retired absence is kept as the dukkha-free-by-construction check: a terminus response has no live mismatch. -/ theorem thirdArrival_not_clenchMismatch : ¬ clockGrid.ClenchMismatch clockAdaptivePresent := clockGrid.not_clenchMismatch_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 {Designatum Contrib : Type} [PreorderBot Contrib] (G : CoreReadings Designatum Contrib) (g : Designatum) (before : Config Contrib) (deed reception : G.Weld) : KsmdPathOught G g before deed reception := ksmdPathOught_conditional G g before deed reception /-- The detached fourth-truth injunction is displayable, not assertable. -/ theorem fourthTruthWithheld_detached_voice : ErrorGrade.voice KsmdDetachedOughtVoice = VerdictVoice.displayable := ksmd_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 {Designatum Contrib : Type} [PreorderBot Contrib] {G : CoreReadings Designatum 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 {Designatum Contrib : Type} [PreorderBot Contrib] {G : CoreReadings Designatum Contrib} {b : Designatum} (h : Icchantika G b) : ¬ G.Terminus b ∧ ¬ KsmdEffectiveTerminus G b := ⟨icchantika_not_terminus (G := G) h, not_ksmdEffectiveTerminus_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 {Designatum Contrib : Type} [PreorderBot Contrib] {G : CoreReadings Designatum Contrib} {before : Config Contrib} {b : Designatum} {reception : G.Weld} (hagent : reception.agent = b) (hic : Icchantika G b) (hactual : G.Actual reception) (hlive : ¬ AtBot before.tendency) : KsmdAversionContext 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.CaseDesignatum) (deed reception : IcchantikaCase.grid.Weld), Icchantika IcchantikaCase.grid b ∧ reception.agent = b ∧ IcchantikaCase.grid.Actual reception ∧ ¬ AtBot before.tendency ∧ Grid.DirectedConvention.DeliveredTo IcchantikaCase.grid deed reception ∧ IcchantikaCase.grid.IsShareDrop before reception ∧ HasShareDropLanding IcchantikaCase.grid before deed := icchantika_release_not_foreclosed /-- The rebirth/cosmology boundary is deliberately only a standing ledger pin: it introduces no theorem about persistence, realms, or consciousness beyond the mounted-response domain. -/ theorem rebirthCosmology_anchor : status InstructiveAbsence.rebirthCosmology = AbsenceStatus.standing := rebirthCosmology_standing /-- The floor-truth refusal is anchored by the two apophatic pins: no row claim holds there, while every pair of row claims is indiscernible there. -/ theorem floorTruthPredicate_anchor {Designatum Contrib : Type} [PreorderBot Contrib] (G : CoreReadings Designatum Contrib) : (∀ p : RowClaim, ¬ (rowLanguage G).Holds Tier.floor p) ∧ ∀ p q : RowClaim, ((rowLanguage G).Holds Tier.floor p ↔ (rowLanguage G).Holds Tier.floor q) := ⟨no_row_claim_holds_at_floor G, floor_claims_indiscernible G⟩ /-- The removed edge-row leaves no constructor behind; the replacement table position is occupied by the standing-sentience row. -/ theorem undefinedZeroRowRetired_replacement_anchor : (tableOrder.drop 16).head? = some (TableRow.generated RowTag.standingSentience) := rfl end InstructiveAbsence end KannoSoe ===== FILE: KannoSoe/Identification/Commentary.lean ===== /- ================================================================================ KannoSoe.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 `Ksmd` 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 vocabulary, and sraddha conditional vocabulary such as `KsmdMismatchGrade`, `KsmdDukkha`, `KsmdAversionContext`, `KsmdEffectiveTerminus`, and the tariki/jiriki line readings. Doctrine names are carried by module names and commentary headings; checked reading identifiers use the single `Ksmd` 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/SentienceConvention.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. Its exact scope is architectural and definability-level: `Config.relabel_fixed`, `Grid.relabel_rePitch`, and `Grid.no_natural_agent_recovery_from_config` check the uniform claim. The information-flow reading is declined by Assumption Ledger B.7, with `ConfigLeakWitness.registerClock_config_recovers_agent` recording why. `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. `OccurrenceReading.Weld`, `Grid.index`, and `Grid.share` encode the MMK 8 point that there is no separate prior act or performer inside the formal signature: a weld is an occurrence designatum, while its index, call, response, and share are readings of that completed occurrence. `Grid.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. Actual call/response is universal. `respondsTo = none` remains only at the actual/hypothetical seam and is not aggregated into a being-kind. `ActualAgentInhabited` supplies non-vacuity, `Terminus` is the universal share-pole condition, and `AtPoleClass` is exactly `Terminus`. The retired `Stone`, `AllStone`, and `MountsSomewhere` predicates have no compatibility aliases. `Signature/SentienceConvention.lean` supplies `SentienceReading`, a predicate on welds constrained by no grid field. `SentientAct` and `InsentientAct` cross the live-share/pole partition to form `OrdinaryAct`, `TerminusAct`, `InsentientAppropriation`, and `StoneAct`. `actual_act_fourfold` is the constructive partition theorem under explicit local decidability, while `sentience_share_square_inhabited` witnesses all four cells. Constant-true and constant-false readings split a witnessed actual weld into `SentientAct` and `InsentientAct`; `no_sentience_recovery` then shows that the same `SentienceGridData` cannot recover its act classification under both readings. `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. Relative to `S`, `SentientTag S`, `StoneTag S`, and `Intermittent S` summarize marked, wholly unmarked-pole, and mixed fibers. `ActualFiberInhabited` remains mark-free for consumers that need occurrence rather than phenomenality. `Signature/Models.lean` holds the clock, register-clock, source/receiver landing, and inhabited sentience/share square witnesses. The register clock fixes no reading: each use site names one. `registerClock_insentient_proficient` records the unmarked, actual, self-conditioning-under-this-coarsening, and patchy macro display; it does not turn the mixed-share fiber into a `StoneTag`. `rigid_terminus_vacuous` and `adaptive_liveTerminus` attach concrete witnesses to the empty/live terminus distinction. `insentient_source_shareDropLanding` supplies both source and receiver marks under `sourceReceiverReading` and names their separation through `sourceReceiverCoarsening`; neither is recovered from the grid. `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 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. No aggregate predicate turns the signature's `none` region into a doctrinal population. `RowTag`, `RowClaim`, `rowLanguage`, and `rowOf` now generate the table's schema rows with floor-apophatic semantics. At `floor` no row claim holds; `no_row_claim_holds_at_floor` is the silence pin, and `floor_claims_indiscernible` makes fusion degeneracy of the claim-space rather than joint truth. Conventional force begins only at act-time: `fitting_offer_is_actTime` is the MMK 24.10 pin. At a pole-class act-time the denial side still earns diagnostic truth by `pole_validates_all_claims`; that 不昧 face is unchanged. `beforeAfterRow`, `beingsRow`, `gridLensRow`, and `weldRow` are compatibility names for `.layer` tags in the schema. Their collapse and freeze checks remain hypothesis-free; their obedience theorems carry only the local `AtBot` stability needed for non-live genjō fusion. The full row list is Lean data as `tableOrder`. No positive `Truth` or `Thus` predicate of the floor is introduced; `InstructiveAbsence.floorTruthPredicate` registers that refusal. The standing-sentience row replaces the retired undefined/zero edge row. Its freeze is sentience held as a nature; its collapse is sentience identified with grid-visible function. The row machinery checks the distinction shape, while `no_sentience_recovery` supplies the substantive recovery obstruction where an actual weld witnesses the question. `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 weld's supplied agent reading as its concrete anchor but without promoting priority to a field. The labels "coming-from" and "going-to" are display names for transposed readings of the two weld faces, not new tier names. `ReflexivityWitness.ladderRungGrid` is deliberately only one legal package of readings: it uses `Nat` designata 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 no-actual-weld, direction-void, no-live-tier, or no-actual-weld cannot be made conventionally apt by truth at a particular genjō weld. Its floor clause is silent like every other `ClaimLanguage` in the development. `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 `sentience_share_square_inhabited`, `no_sentience_recovery`, `rung_not_pole_witness`, `backsliding_witness`, `backsliding_rePitchSequence_witness`, `standing_does_not_determine_dated`, `subitism_possibility_witness`, `ksmdSuddenArrival_witness`, `ksmdGradualArrival_witness`, `rate_invisible_to_config`, `cetana_grading_tracks_weld_not_field_witness`, `cetana_live_share_without_object_standing_witness` 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. `ksmdSuddenArrival_witness` gives the doctrine-facing one-step form with actuality, `ksmdGradualArrival_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_ksmdOwnershipFace` names the delivered trace, `falseMemory_ksmdVacuousOwnershipFace` 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 `withConditions` remain neutral countermodel tooling. `staticized` and the futility theorem family are retired; death and killing are routed in prose through the subject/object freeze and fox collapse instead. 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. `undefinedZeroRowRetired` records the loss of the old edge-row exemplar and anchors its replacement by the generated standing-sentience row. 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_ksmdMismatchLive` 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 `ksmdPathOught_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. `AgentReparam` and `Grid.relabel` are the Being-side twin of that discipline. A predicate mentioning fine agent tags owes a `relabel_*` transport lemma or an explicit co-variance statement such as `relabel_index`, marking it as weld- register vocabulary. `relabel_sameAgentDelivery_iff` makes the important case explicit: same-agent delivery remains agent-sensitive while depending only on the tag pattern, not the tag names. This change records the admission rule and satisfies it for the relabelling lemma set introduced here; it does not impose a retroactive transport obligation across every existing Being-facing predicate. 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`, and the sentience-reading transports pin the independent axes: reversing delivery and changing display preserve the supplied mark only through its explicit transported reading. Grid surgery has no doctrinal transport law. `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. An `OccurrenceReading` keeps named `call` and `response` role projections because those names are useful display labels, just as `index` remains useful after the self-pole demotion. `OccurrenceReading.transposeCR` is only a smuggling detector on same-carrier call/response examples: unordered pair-content cannot recover which role is call, so the intra-weld arrow is not before-and-after furniture inside the weld. `DirectionCoarseningWitness.unit_directionVoid_via_mergeToUnit` checks the lawful one-point slow-clock limit. `twoResolution_directionCoarsening_independence` uses the same two occurrence events under a resolving clock and an over-coarse clock, showing that the resolution bound belongs to the supplied clock. The positive transport theorem `mapDir_resolutionBounded_iff` keeps resolution-relative claims stable under a display change, while `CoverageNegative.directionVoid_needs_coverage` records why carrier-wide direction-voidness needs target coverage. `ContentNegative` separates two boundary cases. `HypotheticalCase` selects a weld but supplies no actual response, so a non-live act-time exists at which the beings, grid-lens, and weld-grain denials expose missing non-vacuity hypotheses. `FixedResponseCase` mounts two distinct calls with one shared response, so the lack of variation is substantive. If the occurrence reading selects nothing at all, `contentLayerRow_obeys_of_no_occurrences` records the different, genuinely vacuous result. `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 occurrence-reading field and not a new `CoreReadings` field. 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. `CoverageNegative` certifies the coverage hypotheses on `directionVoid_of_surjective` and `map_ksmdEffectiveTerminus_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 other freedom and coverage countermodels. C.3a Doctrines/Doors.lean and Doctrines/DoorsNegative.lean `DoorReading` supplies a total diagnosis of each fine weld as body, speech, or mind. `SpeechReading` adds optional claim voicing without a coherence field: thoughts and expressive bodily deeds remain representable, while restrictions belong to the predicates that use them. `ProducedUtterance` ties a voiced claim to an actual weld; only its speech-door form can be converted to a testimonial record. `DoorsNegative` checks independently that door boundaries, voicing, and the production weld cannot be recovered from visible grid or content data. `QuietOn` replaces the old coarsening/tag rectangle in the arhat and fetter machinery. Canonical arhat display is total fine-being quiet, equivalently quietness through all three doors. `KsmdDefiledFalsehood` is the speech-door schema of own-act-time falsity plus a live self-pole; identifying it with canonical deliberate lying is a modeling claim, not a definition. Mind-door quiet removes defiled thought but does not establish thought-truth—the latter is the no-nescience boundary in C.4. C.4 Doctrines/FourTruths.lean, Doctrines/Sraddha.lean, Doctrines/Faith.lean, Doctrines/Ethics.lean, and the sibling negative modules `KsmdMismatchGrade` is definitionally `share`; this is the formal honesty clause for mismatch-talk as covariation rather than a second measure. `ClenchMismatch` is the actual live-share structure. `KsmdDukkha S` adds the supplied mark, so `clenchMismatch_of_ksmdDukkha` forgets the phenomenal reading but no converse is derivable without `S.sentient w`. Insentient appropriation occupies the structural cell without dukkha; both pole cells exclude mismatch. `KsmdAversionContext` treats sraddha reception per call: it packages a live prior tendency and an actual clench-mismatch reception, not a stored faith possession. `KsmdEffectiveTerminus` deliberately has two conjuncts: terminus typing and universal shortfall closure for delivered deeds. The physician simile belongs exactly there: the grid can prove `ksmdPathOught_conditional`, but the antecedents are faith-shaped and are never discharged by field facts. This direct, non-testimonial route needs effectiveness only. The full faith-object cannot be replaced by anything the fetter lattice names: the total-rectangle cut may lack any actual occurrence by `FettersNegative.total_cut_carries_no_actual_occurrence`, and even adding actual-agent inhabitation lacks effectiveness by `FettersNegative.total_cut_with_actual_occurrence_not_ksmdEffectiveTerminus`. The old floor-proximity grounding of testimony is withdrawn: floor silence transmits nothing selective. `ProducedUtterance` now ties content to an actual voicing weld, and `toRecorded` admits only a speech-door production at that weld's own act-time. `ProductionFidelity` therefore cannot detach attribution from production. Mind-door thoughts never enter `RecordedUtterance`, `Fidelity`, `Faith`, or `Ethics`. The character conjunct is deliberately wider than testimony. `KsmdNoNescience` requires positive own-act-time truth for every pole-share speech-or-mind production by the being. For a terminus producer, `noDelusion_of_noNescience_of_terminus` recovers the former speech-only `KsmdNoDelusion` comparison. The converse fails: `FaithNegative.noNescience_strictly_stronger_witness` has true speech and one false pole-share thought. `FaithNegative.aklishta_ajnana_witness` checks that the false thought is innocent because pole share leaves no live self-pole; `FaithNegative.arhat_retains_nescience_witness` gives the third ladder fence: full three-door arhat quiet does not yet remove cognitive obscuration. Sealed own-delivery can still satisfy the material shortfall conditional, and absence of speech keeps the testimonial occurrence conjunct empty. Standing full enlightenment, however, is no longer forced to be mind-vacuous: `FaithNegative.Sealed.silent_buddha_models` supplies one silent reading with no thought and another with a true mind production. Both lack speech and deed occurrences. `KsmdFullyEnlightenedEnacted` names the further samyaksambuddha rung by adding `KsmdEffectivenessEnacted` and a tied `KsmdFaithfulSpeechOccurrence`; the old untied act-time witness has disappeared. The positive no-nescience grounding matches the existing MN 58-shaped machinery: truth is act-time `TrueAt`, benefit is shortfall closure for a live aversion, and timeliness is fitting the offered tier. Constructively, "never wrong" and "right" do not coincide: deriving truth from mere absence of a misfit would require the unearned step `¬¬ TrueAt → TrueAt`. An ethics of testimony should preserve that gap. Faith in the physician hands over a witnessable positive prescription, not a lifetime absence of refutation laundered through excluded middle. The same discipline that keeps the floor apophatic therefore keeps testimony positive in the conventional register. Identity and transmission remain open: `Factive` says the faith attitude is factive, while per-utterance `Fidelity` says this record is an uncorrupted occurrence of the attributed speech. Neither is ever derived from grid or field facts. This is the Kalāma restraint: śraddhā remains a held hypothesis, consistent with `EffectiveTerminusNegative`, rather than a certification manufactured by the formalism. A floor-offered record is vacuously outside `MisfitsOfferedTier` but transmits no content, because the testimonial route explicitly requires an act-time offer. `KsmdEthicsStance` bundles factivity and faith in the two-obscurations object and requires admitted fidelity records to arise from speech productions. `KsmdEthicalCode` is the fourth-truth ought generalized over such testimony, still an implication type only. The is-ought work is receiver-side: testimony supplies the is, while the receiver's live `KsmdAversionContext` supplies the want. This is a hypothetical-imperative dissolution, not a refutation, of Hume's point. `EthicsNegative` keeps the code empty at the pole and unsatisfiable over an admitted false speech production. A false mind production is fenced out before the testimonial route begins. `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 `KsmdEffectiveTerminus`. The opposite regime face is checked by `ksmdEffectiveTerminus_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. `Doctrines/Shusho.lean` retypes the operational content as `KsmdEffectiveOccurrence`: an actual pole-deed landing as a share-drop against a live prior tendency. The standing universal survives only as display and direct-path hypothesis; `KsmdEffectivenessEnacted` and `not_effectivenessEnacted_of_undelivered` fence the sealed-regime vacuity from an enacted occurrence and provide the deed component of `KsmdFullyEnlightenedEnacted`. The separate standing faith-object is the two-obscurations `KsmdFullyEnlightened` bundle; the enacted top adds its named speech witness. `EffectiveTerminusNegative` turns the old prose warning into a collision: changing only `conditions` leaves actual response/share data fixed while flipping `KsmdEffectiveTerminus`. 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. The disclaimer ledger is synchronized with the supplied-sentience reading: entries 12, 24, and 25 name the revised stone-act, structural/supplied-dukkha, and edgeless-domain boundaries, while entries 63 and 64 record grain-indexed predicate aptness and per-weld supplied sentience. Their `rfl` number pins keep the paper numbering explicit without turning that numbering into doctrine. 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 Ksmd 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 former purge/staticization block is retired. Huichang's death-and-futility face is now a prose routing: subtraction of a standing dharma is the subject/object freeze; "emptiness, so suppression changes nothing" is the fox collapse. The checked residue is the narrower `decree_engineers_calls_not_receptions`; historical survival remains display. 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 Dōgen doubling now has a production-side vocabulary. Daishugyō diagnoses: it reads the sentence weld's live share, while its floor face is both error-free by silence and structurally unproduced. Jinshin inga instructs: the fitting instruction is an actual speech production, and a terminus producer would put that weld at pole without arrogation. `oldMan_defiledFalsehood` and `jinshinInga_floor_voicing_defiled` converge on the same schema for the old answer and the counterfactual floor voicing. These checks narrow the historical contra and type its remainder. `daishugyo_floor_face_unproduced` is the formal face of an observational equivalence: a register-foreclosing and an ontologically foreclosing reading of the late Dōgen agree on every production, because any production separating them would instantiate the defiled-falsehood schema the checks convict. Whether the floor face may be held therefore remains prose interpretation — now typed as undischargeable by any find that keeps the fascicles' own discipline, rather than merely undischarged. The module adds no holding predicate and returns no verdict. `fox_clenchMismatch_per_life` records the structural witness. `fox_dukkha_per_life S` takes the sentience mark as an explicit hypothesis and lives one layer down in `Doctrines/FoxCase.lean`. 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. `KsmdSuddenArrival` is the actual one-step share-drop to the pole-class, and `ksmdSuddenArrival_witness` reuses the clock-grid possibility shape. `KsmdGradualArrival` folds a `ShareDropRun` through `rePitchRun`, with `ksmdGradualArrival_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 `KsmdBullSeven`, 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`, now exactly `Terminus`; Bull 9 is `ResponsiveTerminus`; and Bull 10 is the reading-relative existential cross-fiber delivery predicate `KsmdBullTen S`. The stronger `StrongKsmdBullTen S` is named and shelved. `not_ksmdBullTen_allInsentient` owns the consequence that the marketplace is empty under the constant-false reading. The pratyekabuddha countermodel shows Bull 9 without Bull 10. The Five Ranks are data plus reading pins; `kenChuTo_implies_ksmdBullTen` 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. `FetterReading` now supplies weld-classes directly. `FetterCut` is fine-being `QuietOn` for the selected provocation class: cessation of enactment in that class, not possession of an anti-fetter. The retired two-axis rectangle is recoverable as the special weld-class `cs w.call ∧ ts w.agent`, recorded by `fiberAtPoleOnWithin_iff_quietOn_rectangle`; no Soma layer remains in the fetter API. `classQuiet_no_clench_in_class` is the checked soul-guard. `ViewReading.ownerClaim` supplies identity-view content rather than deriving it from coarsening data. `FettersNegative.no_view_content_recovery` is the freedom witness; `ownerClaim_coarsening_freeze_correlation` checks the intended freeze-content correlation in one supplied model. View factors through mind, rites through body, and defiled falsehood through speech. Doubt and the upper fetters remain door-neutral supplied classes. 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_arhat` upgrades the arhat case from samples to `∀ f : Fetter`. `arhatPathQuiet_iff_quietOn_univ` says the arhat class is total. The door-typed `KsmdSravakaArhat` is speech-and-mind quiet; `KsmdVasana` is a live body-door occurrence. `sravakaArhat_not_arhat_witness` checks that regional figure against canonical three-door quiet. Response-form vāsanā at pole share remains registered future work. The buddha reading enters as a ladder above that neutral point. Rung 1 is total three-door quiet, the share axis alone; `FettersNegative.total_cut_carries_no_actual_occurrence` shows that it has no occurrence conjunct. Rung 2 adds `ActualAgentInhabited`. `FettersNegative.total_cut_with_actual_occurrence_not_ksmdEffectiveTerminus` checks that rung 2 still lacks effectiveness. Rung 3 is `KsmdEffectiveTerminus`, terminus plus universal shortfall closure, and it enters the direct śraddhā route as hypothesis. The shushō-ittō face is now explicit as `KsmdEffectiveOccurrence`; the standing rung is a descriptive display, never the act-time verdict. Rung 4 is the cognitive fence: `FaithNegative.arhat_retains_nescience_witness` shows that quiet occurrence does not imply `KsmdNoNescience`. The two-obscurations `KsmdFullyEnlightened` bundle adds that speech-or-mind truth condition above effectiveness. At the enlightenment joint, pratyekabuddha is the sealed-and-silent standing bundle, not a second attainment. `FaithNegative.Sealed.silent_buddha_models` checks both a no-thought model and a true-thinking model; each retains empty speech and deed occurrence faces. The uncooperative delivered case remains a lower negative boundary: when a deed arrives but no share drop lands, `OrthogonalityNegative.ksmdEffectiveTerminus_stronger_than_terminus` shows that even effective termination fails. Samyaksambuddha is instead `KsmdFullyEnlightenedEnacted`, where a delivered effective occurrence and a faithful fitting act-time sentence witness the two standing conditionals. Non-teaching is still a field fact, never a being who opts out of being read: the private-buddha freeze is avoided because the model records what was or was not delivered, not a refusal of object-axis standing. The arhat anchors are now the fine-being door forms: `arhat_iff_three_doors_quiet`, `conceit_excluded_of_quietOn`, `identityView_cut_iff_noDefiledVoicing`, and `no_defiledFalsehood_of_arhat`. Series quiet remains derived display through `seriesQuiet_iff_forall_fine`. 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 `DoorReading` and `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 fine weld in the factor's blocker class; release is fine-being `QuietOn` for that class. 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. `KsmdResolveAttenuation` 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. `KsmdSerialFactorRegime` is the matching "usually in order" conditional; `FactorsNegative.factor_order_underdetermined` 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; stage-boundary non-recovery remains checked by `CorrelationsNegative.no_stage_boundary_recovery`. Speech and conduct are named as `PathFactor.speech` and `PathFactor.conduct`. The speech blocker is active as the speech-door weld-class. Conduct remains inert pending body-door intimation content; the residue ledger owns that boundary. Irreversibility is three-layered. Whole-class `FetterCut` is internally irreversible by quantifier logic: if a later clenched weld in the selected class exists, the cut never held. Run-assigned path tags are only display over seen data, and `FettersNegative.seen_run_underdetermines_fetterCut` gives the fresh-weld countermodel. A forward guarantee is hostable only as `ksmdIrreversibleRegime_conditional`, parallel in voice to the sraddha conditional. The orthogonality note is checked by `unquiet_door_still_functions_witness`: door quiet speaks to share, not whether an actual occurrence exists at another door. No such fact recovers sentience. 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. `KsmdJirikiLine` and `KsmdTarikiLine` 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. `ksmdReachBack_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`), actual-agent inhabited (`name_actualAgentInhabited`), 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 Exposition/Glossary.lean `Exposition/Glossary.lean` is the canonical glossary source. The three markdown glossaries are retired in favor of generated output from `KannoSoe/Exposition/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: the agent has an actual occurrence, and every actual response is live at the self-pole index. That makes the being anti-terminus on its run, so `not_ksmdEffectiveTerminus_of_icchantika` gives the honest agent-role bar: this run cannot seat the icchantika as the enlightened agent, because `KsmdEffectiveTerminus` 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 `KsmdAversionContext` 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: KannoSoe/Identification/Disclaimers.lean ===== /- ================================================================================ KannoSoe.Identification.Disclaimers Disclaimer enumeration and number pins ================================================================================ Reading and motivation: Identification/Commentary.lean. -/ import KannoSoe.Identification.Registers namespace KannoSoe /- ============================================================================== §5 Disclaimers ============================================================================== -/ /-- The paper-facing disclaimer entries enumerated in the disclaimer list. -/ inductive Disclaimer | tieringSeparateFuse | shoAgencyLent | forMeNessInWeld | receptionReachBack | threeRegisterSorting | linjiReading | shoVersusSatori | genjoArrivals | ksmdKarmaIdentification | weldTokenReflexivity | mmk17Decomposition | stoneActOnScale | generatedTaxonomy | twoErrorGrades | shareDropEvent | theoryStatus | rowTwoIndexPlacement | shareDetermination | dispositionActRetype | passiveSpent | clenchSelfShare | vacuityFromField | memoryPrudence | dukkhaStructuralSupplied | edgelessDomain | transposition | mirrorTerminus | threeKillings | officesSpine | contemporaryPlacement | hakuinReading | retypeOutcome | svakarmaDemotion | orthogonalityPrice | beingConvention | pilotGeneratedRows | beingTrichotomy | hareHornRegister | modalRealismFreeze | aptnessConditionality | sraddhaConditional | faithBothConjuncts | generatedTableStructure | floorApophaticSemantics | proseRows | errorFreeReading | misFeedFence | tenBullsTyped | fiveRanksRetype | stageSchemeCoarsening | fetterCutTyping | twoAxisFetterLattice | enlightenmentLadder | ethicsBundledConditionalCode | codeHonestyClauses | verdictRecordData | compoundCellStacks | effectiveTerminusRetype | viewMindVoicing | falsehoodDeliberateLying | doorTotalityAdequacy | thoughtsVoicingSupplied | predicateAptnessGrainIndexed | sentienceSuppliedPerWeld 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 | .ksmdKarmaIdentification => 9 | .weldTokenReflexivity => 10 | .mmk17Decomposition => 11 | .stoneActOnScale => 12 | .generatedTaxonomy => 13 | .twoErrorGrades => 14 | .shareDropEvent => 15 | .theoryStatus => 16 | .rowTwoIndexPlacement => 17 | .shareDetermination => 18 | .dispositionActRetype => 19 | .passiveSpent => 20 | .clenchSelfShare => 21 | .vacuityFromField => 22 | .memoryPrudence => 23 | .dukkhaStructuralSupplied => 24 | .edgelessDomain => 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 | .floorApophaticSemantics => 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 | .effectiveTerminusRetype => 58 | .viewMindVoicing => 59 | .falsehoodDeliberateLying => 60 | .doorTotalityAdequacy => 61 | .thoughtsVoicingSupplied => 62 | .predicateAptnessGrainIndexed => 63 | .sentienceSuppliedPerWeld => 64 theorem stoneActOnScale_number : number Disclaimer.stoneActOnScale = 12 := rfl theorem dukkhaStructuralSupplied_number : number Disclaimer.dukkhaStructuralSupplied = 24 := rfl theorem edgelessDomain_number : number Disclaimer.edgelessDomain = 25 := rfl theorem ksmdKarmaIdentification_number : number Disclaimer.ksmdKarmaIdentification = 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 floorApophaticSemantics_number : number Disclaimer.floorApophaticSemantics = 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 theorem effectiveTerminusRetype_number : number Disclaimer.effectiveTerminusRetype = 58 := rfl theorem viewMindVoicing_number : number Disclaimer.viewMindVoicing = 59 := rfl theorem falsehoodDeliberateLying_number : number Disclaimer.falsehoodDeliberateLying = 60 := rfl theorem doorTotalityAdequacy_number : number Disclaimer.doorTotalityAdequacy = 61 := rfl theorem thoughtsVoicingSupplied_number : number Disclaimer.thoughtsVoicingSupplied = 62 := rfl theorem predicateAptnessGrainIndexed_number : number Disclaimer.predicateAptnessGrainIndexed = 63 := rfl theorem sentienceSuppliedPerWeld_number : number Disclaimer.sentienceSuppliedPerWeld = 64 := rfl end Disclaimer end KannoSoe ===== FILE: KannoSoe/Identification/Ownership.lean ===== /- ================================================================================ KannoSoe.Identification.Ownership Ownership faces, token-reflexivity, pole typing, and offices ================================================================================ Reading and motivation: Identification/Commentary.lean, C.2. -/ import KannoSoe.Identification.Residues namespace KannoSoe namespace Grid variable {Designatum Contrib : Type} [PreorderBot Contrib] variable (G : CoreReadings Designatum Contrib) /- ============================================================================== §2 Sower/reaper, reach-back, and KannoSoe-ownership-face ============================================================================== -/ namespace DirectedConvention /-- The field-side report-face of "the sower reaps": the delivery line, before any act-time ownership is added. -/ def KsmdReportFace (deed reception : G.Weld) : Prop := DeliveredTo G deed reception /-- The full KannoSoe-ownership-face: delivery reaches an actual reception and that reception KannoSoe-appropriates. It is a deed at reception-time, not a standing relation. -/ def KsmdOwnershipFace (deed reception : G.Weld) : Prop := LandsAt G deed reception ∧ G.KsmdAppropriates 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 KsmdVacuousOwnershipFace (deed reception : G.Weld) : Prop := NotDeliveredTo G deed reception ∧ G.Actual reception ∧ G.KsmdAppropriates reception /-- The KannoSoe-ownership-face includes the report-face. -/ theorem ksmdReportFace_of_ksmdOwnershipFace {deed reception : G.Weld} (h : KsmdOwnershipFace G deed reception) : KsmdReportFace G deed reception := h.left.left /-- The KannoSoe-ownership-face includes actual reception. -/ theorem actual_of_ksmdOwnershipFace {deed reception : G.Weld} (h : KsmdOwnershipFace G deed reception) : G.Actual reception := h.left.right /-- The KannoSoe-ownership-face includes KannoSoe-appropriation at reception-time. -/ theorem ksmdAppropriates_of_ksmdOwnershipFace {deed reception : G.Weld} (h : KsmdOwnershipFace G deed reception) : G.KsmdAppropriates reception := h.right /-- Full landing plus KannoSoe-appropriation introduces the KannoSoe-ownership-face. -/ theorem ksmdOwnershipFace_intro {deed reception : G.Weld} (hland : LandsAt G deed reception) (happ : G.KsmdAppropriates reception) : KsmdOwnershipFace G deed reception := ⟨hland, happ⟩ /-- Bare non-delivery cannot at the same time be a full KannoSoe-ownership-face for that deed and reception. -/ theorem not_ksmdOwnershipFace_of_vacuous {deed reception : G.Weld} (hv : NotDeliveredTo G deed reception) : ¬ KsmdOwnershipFace G deed reception := fun hown => hv hown.left.left /-- A vacuous KannoSoe-ownership attempt is not a full KannoSoe-ownership-face. -/ theorem not_ksmdOwnershipFace_of_ksmdVacuousOwnershipFace {deed reception : G.Weld} (hv : KsmdVacuousOwnershipFace G deed reception) : ¬ KsmdOwnershipFace G deed reception := not_ksmdOwnershipFace_of_vacuous G hv.left /-- The diachronic whose-question decomposes into delivery plus fresh KannoSoe-appropriation; no third cross-gap owner is part of this definition. -/ def KsmdDiachronicWhose (deed reception : G.Weld) : Prop := DeliveredTo G deed reception ∧ G.KsmdAppropriates reception theorem ksmdDiachronicWhose_iff_delivery_and_ksmdAppropriates (deed reception : G.Weld) : KsmdDiachronicWhose G deed reception ↔ DeliveredTo G deed reception ∧ G.KsmdAppropriates 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.KsmdAppropriates reception) : ¬ KsmdDiachronicWhose G deed reception := by intro hwhose exact hno ((ksmdDiachronicWhose_iff_delivery_and_ksmdAppropriates 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 := registerWeld 1 /-- The later reception at which the trace is received and appropriated. -/ def recall : registerClockGrid.Weld := registerWeld 2 /-- A claimed deed whose delivery line does not reach `recall`. -/ def confabulatedDeed : registerClockGrid.Weld := registerWeld 0 /-- The trace-source deed is delivered to the later recall reception. -/ theorem trace_delivered : DeliveredTo registerClockGrid pastDeed recall := rfl theorem recall_ksmdAppropriates : registerClockGrid.KsmdAppropriates recall := by dsimp [Grid.KsmdAppropriates, 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_ksmdOwnershipFace : KsmdOwnershipFace registerClockGrid pastDeed recall := ⟨⟨trace_delivered, rfl⟩, recall_ksmdAppropriates⟩ /-- The diachronic whose-question for recall is delivery plus fresh reception-time appropriation. -/ theorem recall_ksmdDiachronicWhose : KsmdDiachronicWhose registerClockGrid pastDeed recall := ⟨trace_delivered, recall_ksmdAppropriates⟩ /-- The confabulated deed is not delivered to the recall reception. -/ theorem confabulated_not_delivered : NotDeliveredTo registerClockGrid confabulatedDeed recall := by dsimp [NotDeliveredTo, Grid.conditions, registerClockGrid, registerWeld, 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_ksmdVacuousOwnershipFace : KsmdVacuousOwnershipFace registerClockGrid confabulatedDeed recall := ⟨confabulated_not_delivered, ⟨rfl, recall_ksmdAppropriates⟩⟩ /-- The appropriating conjunct projected from the full recall face. -/ theorem fullFace_recall_ksmdAppropriates : registerClockGrid.KsmdAppropriates recall := ksmdAppropriates_of_ksmdOwnershipFace registerClockGrid recall_ksmdOwnershipFace /-- The appropriating conjunct projected from the vacuous false-memory face. -/ theorem vacuousFace_recall_ksmdAppropriates : registerClockGrid.KsmdAppropriates recall := falseMemory_ksmdVacuousOwnershipFace.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.KsmdAppropriates recall ∧ registerClockGrid.KsmdAppropriates recall ∧ ¬ KsmdOwnershipFace registerClockGrid confabulatedDeed recall := ⟨fullFace_recall_ksmdAppropriates, vacuousFace_recall_ksmdAppropriates, not_ksmdOwnershipFace_of_ksmdVacuousOwnershipFace registerClockGrid falseMemory_ksmdVacuousOwnershipFace⟩ /-- 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 : KsmdOwnershipFace registerClockGrid pastDeed recall ∧ KsmdVacuousOwnershipFace registerClockGrid confabulatedDeed recall ∧ (∀ before1 before2 : Config Nat, registerClockGrid.rePitch before1 recall = registerClockGrid.rePitch before2 recall) := ⟨recall_ksmdOwnershipFace, falseMemory_ksmdVacuousOwnershipFace, recall_spent⟩ end MemoryWitness /- ============================================================================== §2 Prudential privilege negative ============================================================================== -/ namespace PrudentialPrivilegeNegative open BeingConvention /-- The present-side fine register. -/ def deedAgent : RegisterCase := .register 1 /-- The future-side fine register. -/ def receptionAgent : RegisterCase := .register 2 /-- The future reception's mounted response. -/ def receptionResponse : RegisterCase := .result 3 /-- The present concern/deed register in the checked prudence witness. -/ def deed : registerClockGrid.Weld := registerWeld 1 /-- The future reception register delivered by `deed`. -/ def reception : registerClockGrid.Weld := registerWeld 2 /-- 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_ksmdAppropriates : registerClockGrid.KsmdAppropriates deed := by dsimp [Grid.KsmdAppropriates, Grid.HasSelfPoleIndex, Grid.share, registerClockGrid, deed, AtBot, shareBot] change ¬ (1 : Nat) ≤ 0 exact Nat.not_succ_le_zero 0 theorem reception_ksmdAppropriates : registerClockGrid.KsmdAppropriates reception := by dsimp [Grid.KsmdAppropriates, 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 KannoSoe-appropriation. -/ theorem reception_ksmdDiachronicWhose : KsmdDiachronicWhose registerClockGrid deed reception := ⟨rfl, reception_ksmdAppropriates⟩ /-- The same pair also gives the full KannoSoe-ownership face. -/ theorem reception_ksmdOwnershipFace : KsmdOwnershipFace registerClockGrid deed reception := ⟨⟨rfl, rfl⟩, reception_ksmdAppropriates⟩ /-- 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 RegisterCase where proj := id theorem merge_same_fiber : kMerge.SameFiber deedAgent receptionAgent := rfl /-- Pairwise boundary induced by the merge reading. -/ abbrev mergeBoundary (_p _q : RegisterCase) : Prop := True /-- Pairwise boundary induced by the split reading. -/ abbrev splitBoundary (p q : RegisterCase) : Prop := p = q theorem merge_boundary_holds : mergeBoundary deedAgent receptionAgent := True.intro theorem split_boundary_fails : ¬ ((RegisterCase.register 1) = (RegisterCase.register 2)) := by decide /-- The grid data visible to a convention-free standing-owner recovery. -/ abbrev W : Type := registerClockGrid.Weld /-- Function, grade, and delivery data, with no supplied being-convention. -/ abbrev GridData : Type := (RegisterCase -> RegisterCase -> Option RegisterCase) × (RegisterCase -> 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 : RegisterCase -> RegisterCase -> Prop) : (registerClockGrid.withConditions conditions1).grade deed.1 = (registerClockGrid.withConditions conditions2).grade deed.1 := registerClockGrid.grade_independent_of_conditions conditions1 conditions2 deed.1 /-- 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 : KsmdDiachronicWhose registerClockGrid deed reception ∧ ¬ PrudentialPrivilege ∧ (∀ before1 before2 : Config Nat, (ReceptionPair.rePitchSequence (G := registerClockGrid) before1 pair).snd = (ReceptionPair.rePitchSequence (G := registerClockGrid) before2 pair).snd) ∧ (∀ conditions1 conditions2 : RegisterCase -> RegisterCase -> Prop, (registerClockGrid.withConditions conditions1).grade deed.1 = (registerClockGrid.withConditions conditions2).grade deed.1) := ⟨reception_ksmdDiachronicWhose, 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 omit [PreorderBot Contrib] in theorem selfAnchored (w : G.Weld) : SelfAnchored G 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)) : StateToolFits G 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) : StateToolFits G w := stateToolFits_of_atBot G (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 : StateToolFits G 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))] : StateToolFits G w ↔ AtBot (G.share w) := ⟨atBot_of_stateToolFits G, stateToolFits_of_atBot G⟩ /-- Terminus responses are reducible in the corollary's sense. -/ theorem stateToolFits_of_terminus_response {w : G.Weld} (hterm : G.Terminus w.agent) (hactual : G.Actual w) : StateToolFits G w := G.no_self_pole_index_of_terminus_response hterm hactual namespace DirectedConvention /-- If the state-tool fits a reception, the KannoSoe-ownership-face cannot fire there. -/ theorem not_ksmdOwnershipFace_of_stateToolFits {deed reception : G.Weld} (hfits : StateToolFits G reception) : ¬ KsmdOwnershipFace 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 KannoSoe-offices karmic ownership holds in the paper's identity-claim. -/ inductive KsmdOwnershipOffice | cetana | reception | practice | remorse | absolution | dedication namespace KsmdOwnershipOffice variable {Designatum Contrib : Type} [PreorderBot Contrib] {G : CoreReadings Designatum 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 : KsmdOwnershipOffice) (w : G.Weld) : Grid.Tier G := Grid.Tier.actTime w omit [PreorderBot Contrib] in theorem assignedTier_eq_actTime (office : KsmdOwnershipOffice) (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 : KsmdOwnershipOffice) (w : G.Weld) : Grid.Tier.hasLiveShare G (office.assignedTier w) ↔ G.HasSelfPoleIndex w := Iff.rfl end KsmdOwnershipOffice /- Reading and motivation: Identification/Commentary.lean, C.1. -/ namespace SelfLineWitness inductive Designatum | one | call | response | occurrence def selfLineOccurrence : OccurrenceReading Designatum where occurrence d := d = .occurrence isBeing d := d = .one isCall d := d = .call isResponse d := d = .response agent | .occurrence => .one | d => d call | .occurrence => .call | d => d response | .occurrence => .response | d => d def selfLineGrid : CoreReadings Designatum Nat where occurrence := selfLineOccurrence response := { respondsTo := fun _ _ => some .response } placement := { grade := fun _ => 1 } conditioning := { conditions := fun _ _ => True } def w : selfLineGrid.Weld := ⟨.occurrence, rfl⟩ theorem w_ksmdAppropriates : selfLineGrid.KsmdAppropriates 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_ksmdOwnershipFace_self : Grid.DirectedConvention.KsmdOwnershipFace selfLineGrid w w := ⟨⟨True.intro, rfl⟩, w_ksmdAppropriates⟩ end SelfLineWitness end KannoSoe ===== FILE: KannoSoe/Identification/Placements.lean ===== /- ================================================================================ KannoSoe.Identification.Placements Contemporary placements ================================================================================ Reading and motivation: Identification/Commentary.lean. -/ import KannoSoe.Identification.Ownership namespace KannoSoe /-- 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 ksmdPlacement : ContemporaryPosition → ContemporaryPlacement | .siderits => .seriesQuestions | .ganeri => .nearestAlly | .zahavi => .retype | .sartre => .occupant theorem siderits_ksmdPlacement : ksmdPlacement ContemporaryPosition.siderits = ContemporaryPlacement.seriesQuestions := rfl theorem ganeri_ksmdPlacement : ksmdPlacement ContemporaryPosition.ganeri = ContemporaryPlacement.nearestAlly := rfl theorem zahavi_ksmdPlacement : ksmdPlacement ContemporaryPosition.zahavi = ContemporaryPlacement.retype := rfl theorem sartre_ksmdPlacement : ksmdPlacement ContemporaryPosition.sartre = ContemporaryPlacement.occupant := rfl end ContemporaryPosition namespace Grid variable {Designatum Contrib : Type} [PreorderBot Contrib] variable (G : CoreReadings Designatum 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 KannoSoe ===== FILE: KannoSoe/Identification/Registers.lean ===== /- ================================================================================ KannoSoe.Identification.Registers Disclaimer 5 register sorting ================================================================================ Reading and motivation: Identification/Commentary.lean, C.1. -/ import KannoSoe.Identification.Placements namespace KannoSoe /- ============================================================================== §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) and definability-level (`Grid.relabel_rePitch`, `Grid.no_natural_agent_recovery_from_config`); the information-flow reading is declined — see `ConfigLeakWitness`. 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 KannoSoe ===== FILE: KannoSoe/Identification/Residues.lean ===== /- ================================================================================ KannoSoe.Identification.Residues Field residues and index recovery ================================================================================ Reading and motivation: Identification/Commentary.lean, C.0-C.1. -/ import KannoSoe.Consequences.Basic namespace KannoSoe /- ============================================================================== §0 Field residues and index recovery ============================================================================== -/ namespace Grid variable {Designatum Contrib : Type} [PreorderBot Contrib] variable (G : CoreReadings Designatum Contrib) /-- A field residue: the call and response left when the agent-index is not part of the data. -/ abbrev FieldFact (_G : CoreReadings Designatum Contrib) : Type := Designatum × Designatum /-- A field-only recovery candidate tries to recover an agent-index from field residues alone. -/ abbrev FieldRecovery (G : CoreReadings Designatum Contrib) : Type := FieldFact G → Designatum /-- Correctness for a field-only recovery candidate: for every actual weld, it must recover the very index projected from that weld. -/ def CorrectFieldRecovery (recover : FieldRecovery G) : Prop := ∀ w : G.Weld, G.Actual w → recover (G.fieldOf w) = G.index w omit [PreorderBot Contrib] in /-- 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 : FieldRecovery G} (hrec : CorrectFieldRecovery G 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₂ omit [PreorderBot Contrib] in /-- 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 : FieldRecovery G, CorrectFieldRecovery G recover := fun ⟨_recover, hrec⟩ => hne (correctFieldRecovery_forces_same_index_of_same_field G hrec h₁ h₂ hfield) omit [PreorderBot Contrib] in /-- 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 (w₁ w₂ : G.Weld) (h₁ : G.Actual w₁) (h₂ : G.Actual w₂) (hcall : w₁.call = w₂.call) (hresponse : w₁.response = w₂.response) (hne : w₁.agent ≠ w₂.agent) : ¬ ∃ recover : FieldRecovery G, CorrectFieldRecovery G recover := no_agent_recovery_from_same_field_distinct_index G h₁ h₂ (Prod.ext hcall hresponse) hne end Grid namespace CoreReadings variable {Designatum Contrib : Type} [PreorderBot Contrib] abbrev FieldFact (G : CoreReadings Designatum Contrib) := Grid.FieldFact G abbrev FieldRecovery (G : CoreReadings Designatum Contrib) := Grid.FieldRecovery G abbrev CorrectFieldRecovery (G : CoreReadings Designatum Contrib) := Grid.CorrectFieldRecovery G end CoreReadings /- ============================================================================== Mis-feed negative: the avyākata fence and delivery gate ============================================================================== -/ namespace MisFeedNegative variable {Designatum 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 : CoreReadings Designatum Contrib) : Type := G.FieldFact → Designatum /-- Success for the form: correctness at every actual weld. -/ def AnswersCorrectly (G : CoreReadings Designatum 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 : CoreReadings Designatum 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 omit [PreorderBot Contrib] in /-- 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 : CoreReadings Designatum 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) omit [PreorderBot Contrib] in /-- Claim-level face of the same obstruction: one field residue has two actual-backed, distinct index claims. -/ theorem indexClaim_not_functional_of_collision {G : CoreReadings Designatum Contrib} (c : FieldCollision G) : ∃ f : G.FieldFact, ∃ b1 b2 : Designatum, 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 CollisionCase | leftAgent | rightAgent | call | response | leftOccurrence | rightOccurrence deriving DecidableEq /-- A concrete grid witnessing a field collision while keeping delivery answerable in the same model. -/ def collisionGrid : CoreReadings CollisionCase Nat where occurrence := { occurrence := fun d => d = .leftOccurrence ∨ d = .rightOccurrence isBeing := fun d => d = .leftAgent ∨ d = .rightAgent isCall := fun d => d = .call isResponse := fun d => d = .response agent := fun d => match d with | .leftOccurrence => .leftAgent | .rightOccurrence => .rightAgent | _ => d call := fun d => match d with | .leftOccurrence | .rightOccurrence => .call | _ => d response := fun d => match d with | .leftOccurrence | .rightOccurrence => .response | _ => d } response := { respondsTo := fun b c => if (b = .leftAgent ∨ b = .rightAgent) ∧ c = .call then some .response else none } placement := { grade := fun _ => 0 } conditioning := { conditions := fun _ _ => True } def wLeft : collisionGrid.Weld := ⟨.leftOccurrence, Or.inl rfl⟩ def wRight : collisionGrid.Weld := ⟨.rightOccurrence, Or.inr rfl⟩ /-- 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 KannoSoe ===== FILE: KannoSoe/Meta/AssumptionLedger.lean ===== /- ================================================================================ KannoSoe.Meta.AssumptionLedger Canonical assumption prose, checked anchors, and structural checks ================================================================================ The axiom-audit ledger 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`. Lean here buys internal consistency and derivability, not exclusivity or truth: given the primitives the consequences follow without contradiction; it is not shown that no other reconstruction would. The ledger and its axiom audit make the “no added axioms” part concrete through `assumptionAxiomAudit` and `#verify_axiom_audit`. Its declined entries — no `PreorderTop`, no privileged person-partition, and direction/scalar as display — record the signature's active refusal to privilege its own choices rather than a proof that rivals are impossible. -/ import Lean import KannoSoe.Signature.Assumptions import KannoSoe.Meta.AxiomAudit import KannoSoe.Meta.InvarianceNegative import KannoSoe.Identification.Ownership import KannoSoe.Doctrines.FourTruths import KannoSoe.Doctrines.EffectiveTerminusNegative import KannoSoe.Doctrines.DoorsNegative namespace KannoSoe /- ============================================================================== 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 an occurrence designatum selected by an `OccurrenceReading`. Its agent, call, and response are role-readings of that occurrence; `Grid.index` and `Grid.share` are derived projections, not fields recovered from a separate performer or act. `Grid.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 ``OccurrenceReading.Weld, sigProof ``OccurrenceReading.Weld.agent, sigProof ``OccurrenceReading.Weld.call, sigProof ``OccurrenceReading.Weld.response, sigProof ``Grid.index, sigProof ``Grid.share, sigWitness ``Grid.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, designatum, weld, or field-residue slot. `rePitch` uses the received weld's share and ignores the prior configuration value. The checked claim is architectural and definability-level: whole-carrier relabelling acts trivially on configurations and commutes with `rePitch`, and no relabelling-equivariant recovery of a designatum from a configuration exists. It is not an information-flow claim; see the declined entry below." anchors := [ sigProof ``Config, sigProof ``Config.tendency, sigProof ``Grid.rePitch, downProof ``Equiv, downProof ``Grid.relabel, downProof ``Config.relabel_fixed, downProof ``Grid.relabel_rePitch, downWitness ``Grid.no_natural_agent_recovery_from_config, downWitness ``ConfigLeakWitness.no_agent_recovery_from_config_of_share_collision ] }, { «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 := "Sentience is a supplied per-weld reading" statement := "A `SentienceReading` marks welds, not beings. Together with live or pole share it yields the four actual act-kinds `OrdinaryAct`, `TerminusAct`, `InsentientAppropriation`, and `StoneAct`; the checked square witnesses all four. `SentientTag`, `StoneTag`, and `Intermittent` are reading-relative quantified displays over those acts." anchors := [ sigProof ``Grid.SentienceReading, sigProof ``Grid.SentientAct, sigProof ``Grid.InsentientAct, sigProof ``Grid.OrdinaryAct, sigProof ``Grid.TerminusAct, sigProof ``Grid.InsentientAppropriation, sigProof ``Grid.StoneAct, sigProof ``Grid.DirectedConvention.BeingConvention.BeingCoarsening.SentientTag, sigProof ``Grid.DirectedConvention.BeingConvention.BeingCoarsening.StoneTag, sigProof ``Grid.DirectedConvention.BeingConvention.BeingCoarsening.Intermittent, sigWitness ``sentience_share_square_inhabited ] }, { «section» := .asserted number := 5 title := "Call/response is universal per occurrence" statement := "Every actual weld is a mounted call/response occurrence. `respondsTo` remains `Option`-valued only to distinguish actual from hypothetical triples; `none` is not aggregated into a per-being doctrinal category. In Madhyamaka terms it marks non-arising, not a cessation or state entered by a being." anchors := [ sigProof ``Grid.Actual, sigProof ``Grid.MountsAt, downProof ``Grid.mountsAt_iff_exists_actual ] }, { «section» := .asserted number := 6 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_ksmdOwnershipFace_self ] }, { «section» := .asserted number := 7 title := "Dukkha and Bull 10 are reading-relative" statement := "`ClenchMismatch` and its share covariation are grid-derived. `KsmdDukkha` adds the supplied mark: the structure is derived, the suffering is supplied. Bull 10 likewise quantifies over `SentientTag` under a reading; with the constant-false reading its marketplace is empty and the predicate is unsatisfiable." anchors := [ downProof ``Grid.ClenchMismatch, downProof ``Grid.KsmdDukkha, downProof ``Grid.clenchMismatch_of_ksmdDukkha, downProof ``Grid.KsmdBullTen, downProof ``Grid.not_ksmdBullTen_allInsentient ] }, { «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 ``OccurrenceReading.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.unit_directionVoid_via_mergeToUnit, downWitness ``DirectionCoarseningWitness.twoResolution_directionCoarsening_independence, downProof ``Grid.DirectedConvention.DirectionCoarsening.mapDir_resolutionBounded_iff, downWitness ``CoverageNegative.directionVoid_needs_coverage ] }, { «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» := .declined number := 6 title := "The enlightenment ladder names standing and enacted vacuity" statement := "The operational, assertable effectiveness content is per-occurrence: `KsmdEffectiveOccurrence` states an actual pole-deed landing as a share-drop against a live prior tendency. The descriptive universal `KsmdEffectiveTerminus` remains legal as run-display and direct-path hypothesis, but no estimator from actual-run response/share data decides it. Standing `KsmdFullyEnlightened` adds positive own-act-time `KsmdNoNescience` over speech-or-mind productions. A quiet arhat may still fail that cognitive conjunct; sealed silent and true-thinking buddhas witness its two silent faces. `KsmdFullyEnlightenedEnacted` separately adds an effective deed witness and a production-tied speech occurrence." anchors := [ downProof ``Grid.DirectedConvention.KsmdEffectiveOccurrence, downProof ``Grid.DirectedConvention.KsmdEffectivenessEnacted, downProof ``Grid.DirectedConvention.not_effectivenessEnacted_of_undelivered, downProof ``Grid.DirectedConvention.KsmdFullyEnlightened, downProof ``Grid.DirectedConvention.KsmdNoNescience, downProof ``Grid.DirectedConvention.KsmdFullyEnlightenedEnacted, downWitness ``FaithNegative.noNescience_strictly_stronger_witness, downWitness ``FaithNegative.arhat_retains_nescience_witness, downWitness ``FaithNegative.Sealed.silent_buddha_models, downWitness ``EffectiveTerminusNegative.actual_run_data_underdetermines_effectiveTerminus, downProof ``Grid.DirectedConvention.BeingConvention.GridConvention.ksmd_effective_occurrence_voice_assertable, downProof ``Grid.DirectedConvention.BeingConvention.GridConvention.ksmd_standing_effectiveness_voice_displayable ] }, { «section» := .declined number := 7 title := "No blanket noninterference for the contribution carrier" statement := "Grading may depend on the agent — `gradingCollisionGrid` grades by being deliberately (cetanā) — so a model's stored tendency may extensionally coincide with an agent tag; `registerClockGrid` witnesses the coincidence. The signature therefore declines the information-flow reading of non-storage. `Grid.rePitch_forgets` bounds the coincidence to a single reception's footprint: nothing accumulates into a diachronic bearer, and the configuration is fibered over no being. The asserted claim is typing plus relabelling equivariance." anchors := [ sigWitness ``gradingCollisionGrid, sigWitness ``registerClockGrid, downWitness ``ConfigLeakWitness.registerClock_config_recovers_agent, downProof ``Config.relabel_fixed, downProof ``Grid.relabel_rePitch, downProof ``Grid.rePitch_forgets ] }, { «section» := .declined number := 8 title := "No recovered door boundary" statement := "`DoorReading` totally classifies fine welds as body, speech, or mind, but that diagnosis is supplied rather than recovered from response or grade data. Totality and adequacy to the canonical three doors are modeling claims." anchors := [ downProof ``Grid.DoorReading, downWitness ``DoorsNegative.no_door_boundary_recovery ] }, { «section» := .declined number := 9 title := "No recovered voicing" statement := "`SpeechReading` supplies optional content independently of door. Thoughts and bodily intimations are representable, while only speech productions cross into testimony; neither voicing nor its production weld is recovered from visible grid data or content alone." anchors := [ downProof ``Grid.SpeechReading, downProof ``Grid.ProducedUtterance, downWitness ``DoorsNegative.no_voicing_recovery, downWitness ``DoorsNegative.no_production_recovery ] }, { «section» := .declined number := 10 title := "No recovered view content" statement := "`ViewReading.ownerClaim` supplies which claims count as stored-owner views. The checked coarsening-freeze model is a correlation for one such reading, not a derivation of content from the grid." anchors := [ downProof ``Grid.ViewReading, downWitness ``FettersNegative.no_view_content_recovery, downWitness ``FettersNegative.ownerClaim_coarsening_freeze_correlation ] }, { «section» := .declined number := 11 title := "No sentience recovery from grid data" statement := "Given an actual weld, the same complete response, grade, and delivery data classify it as a `SentientAct` under the constant-true reading and an `InsentientAct` under the constant-false reading. Behavior, share, clench, and delivery therefore jointly underdetermine the mark on the actual domain." anchors := [ sigProof ``Grid.SentienceReading, sigProof ``Grid.actual_weld_readings_split, sigWitness ``Grid.no_sentience_recovery ] }, { «section» := .declined number := 12 title := "No plenitude over being-call pairs" statement := "Universal call/response ranges over actual occurrences; it does not assert that every `Being × Call` pair returns a response. The `Option` seam remains load-bearing for hypothetical variation and candidate receptions." anchors := [ sigProof ``Grid.respondsTo, sigProof ``Grid.Actual, sigProof ``Grid.DirectedConvention.EnvironsLine, downWitness ``ContentNegative.hypotheticalGrid_no_actual, downWitness ``ContentNegative.contentBeingsRow_not_obeys_hypothetical, downWitness ``ContentNegative.fixedResponseGrid_no_variation, downWitness ``ContentNegative.contentIntraWeldArrowRow_not_obeys_fixedResponse ] }, { «section» := .declined number := 13 title := "No aggregate sentience scalar" statement := "Sentience is marked per weld. `Intermittent` records fibers containing both marked and unmarked actual acts, but the system assigns no degree of sentience to a tag." anchors := [ sigProof ``Grid.DirectedConvention.BeingConvention.BeingCoarsening.Intermittent, sigProof ``Grid.DirectedConvention.BeingConvention.BeingCoarsening.Patchy ] }, { «section» := .declined number := 14 title := "No insentient-clench exclusion" statement := "An unmarked actual weld may retain live self-share. `InsentientAppropriation` is an inhabited cell of the checked square, so appropriation and structural mismatch do not recover sentience." anchors := [ sigProof ``Grid.InsentientAppropriation, sigWitness ``square_insentientAppropriation, downProof ``Grid.clenchMismatch_of_insentientAppropriation ] }, { «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 := "`KsmdMismatchGrade` 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.KsmdMismatchGrade, downProof ``Grid.ksmdMismatchGrade_eq_share ] }, { «section» := .convenience number := 4 title := "`Models.lean` witnesses are illustrative" statement := "The clock and register-clock models anchor possibility checks and mark-invariance witnesses; they are not uniqueness claims." anchors := [ sigWitness ``clockGrid, sigWitness ``registerClockGrid, sigWitness ``registerClock_insentient_proficient, sigWitness ``clock_pole_readings_split, sigWitness ``registerClock_rung_readings_split, sigWitness ``rigid_terminus_vacuous, sigWitness ``adaptive_liveTerminus, sigWitness ``sentience_share_square_inhabited, sigWitness ``registerClock_macro_selfConditioning ] } ] /-- Audited declarations that are required to remain entirely axiom-free. -/ def assumptionAxiomAudit : List Lean.Name := (axiomAuditLedger.filter (fun entry => entry.allowed.isEmpty)).map (fun entry => entry.name) /- ============================================================================== 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 = 7 := rfl example : (assumptionSectionEntries .declined).length = 14 := rfl example : (assumptionSectionEntries .convenience).length = 4 := rfl example : assumptionNumberingContiguous .asserted = true := by decide example : assumptionNumberingContiguous .declined = true := by decide example : assumptionNumberingContiguous .convenience = true := by decide example : assumptionTitles.Nodup := by 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 /- The rebirth/cosmology absence is intentionally a downstream, pin-level boundary rather than a Signature assumption or a positive theorem. -/ #check InstructiveAbsence.rebirthCosmology_standing #check InstructiveAbsence.rebirthCosmology_anchor -- Floor truth is deliberately absent; only silence and indiscernibility remain. #check InstructiveAbsence.floorTruthPredicate_standing #check InstructiveAbsence.floorTruthPredicate_anchor end KannoSoe ===== FILE: KannoSoe/Meta/Audit.lean ===== import KannoSoe.Meta.AxiomAudit import KannoSoe.Meta.AssumptionLedger /- The executable audit lives in `Meta.AxiomAudit`; this compatibility module remains the public import point for the complete Meta audit surface. -/ ===== FILE: KannoSoe/Meta/AxiomAudit.lean ===== import Lean import KannoSoe.Meta.Invariance import KannoSoe.Meta.InvarianceNegative import KannoSoe.Meta.ReflexivityWitness import KannoSoe.Meta.VerdictLedger import KannoSoe.Consequences.ModelWitnesses import KannoSoe.Doctrines.SraddhaNegative import KannoSoe.Doctrines.FaithNegative import KannoSoe.Doctrines.Deliberation import KannoSoe.Doctrines.Ledger import KannoSoe.Doctrines.CorrelationsNegative import KannoSoe.Doctrines.FettersNegative import KannoSoe.Doctrines.FactorsNegative import KannoSoe.Doctrines.EffectiveTerminusNegative import KannoSoe.Doctrines.Shusho namespace KannoSoe /-- One declaration and the exact set of axioms it is permitted to use. -/ structure AxiomAuditEntry where name : Lean.Name allowed : List Lean.Name := [] deriving Repr /-- The single source of truth for the project's axiom audit. -/ def axiomAuditLedger : List AxiomAuditEntry := [ { name := ``Grid.no_agent_recovery_of_field_collision }, { name := ``Grid.DirectedConvention.DirectionCoarsening.no_timeDirection_within_tick }, { name := ``Grid.DirectedConvention.DirectionCoarsening.no_timeDirection_of_resolutionBounded_subsingleton }, { name := ``Grid.relabel_rePitch }, { name := ``Grid.no_natural_agent_recovery_from_config, allowed := [``propext, ``Quot.sound] }, { name := ``ConfigLeakWitness.registerClock_config_recovers_agent, allowed := [``propext] }, { name := ``ConfigLeakWitness.no_agent_recovery_from_config_of_share_collision, allowed := [``propext] }, { name := ``strict_asymm }, { name := ``strict_trans }, { name := ``Grid.transpose_transpose }, { name := ``DirectionNegative.no_direction_recovery_from_conditionsEither, allowed := [``propext, ``Quot.sound] }, { name := ``CoverageNegative.directionVoid_needs_coverage }, { name := ``CoverageNegative.ksmdEffectiveTerminus_needs_coverage, allowed := [``propext] }, { name := ``Grid.stateToolFits_iff_atBot }, { name := ``Grid.map_actual_iff }, { name := ``Grid.map_isShareDrop_iff }, { name := ``Grid.map_transpose }, { name := ``Grid.actual_weld_readings_split }, { name := ``Grid.no_sentience_recovery }, { name := ``sentience_share_square_inhabited, allowed := [``propext] }, { name := ``Grid.DirectedConvention.DirectionCoarsening.mapDir_resolutionBounded_iff }, { name := ``DirectionCoarseningWitness.unit_directionVoid_via_mergeToUnit }, { name := ``DirectionCoarseningWitness.twoResolution_directionCoarsening_independence }, { name := ``DirectionCoarseningWitness.registerClock_directionCoarsening_independence, allowed := [``propext] }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.contentLayerRow_not_fused_of_nonlive_denial }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.contentLayerRow_not_obeys_of_nonlive_denial }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.contentLayerRow_obeys_of_no_occurrences }, { name := ``ContentNegative.contentBeingsRow_not_obeys_hypothetical, allowed := [``propext] }, { name := ``ContentNegative.contentGridLensRow_not_obeys_hypothetical, allowed := [``propext] }, { name := ``ContentNegative.contentWeldRow_not_obeys_hypothetical, allowed := [``propext] }, { name := ``ContentNegative.contentIntraWeldArrowRow_not_obeys_fixedResponse, allowed := [``propext] }, { name := ``ContentNegative.contentBeforeAfterRow_not_obeys_twoBottom }, { name := ``Grid.DirectedConvention.map_landsWithShareDrop_iff }, { name := ``Grid.DirectedConvention.BeingConvention.BeingCoarsening.map_selfConditioningTag_iff }, { name := ``Grid.DirectedConvention.BeingConvention.BeingCoarsening.map_fiberAtPoleOn_iff }, { name := ``Grid.DirectedConvention.BeingConvention.BeingCoarsening.total_sameFiber }, { name := ``Grid.DirectedConvention.BeingConvention.BeingCoarsening.id_not_sameFiber_of_ne }, { name := ``Grid.map_ksmdBullSeven_iff }, { name := ``Grid.map_ksmdBullTen_iff }, { name := ``Grid.bullSeven_not_bullEight }, { name := ``Grid.bullTen_to_bullNine }, { name := ``CorrelationsNegative.pratyekabuddha_countermodel, allowed := [``propext] }, { name := ``CorrelationsNegative.no_stage_boundary_recovery, allowed := [``propext] }, { name := ``Grid.classQuiet_no_clench_in_class }, { name := ``Fetter.kind_lower_iff_cut_by_nonReturn }, { name := ``Grid.arhatPathQuiet_iff_quietOn_univ }, { name := ``Grid.terminus_iff_quietOn_univ }, { name := ``Grid.atPoleClass_iff_quietOn_univ }, { name := ``Grid.all_fetters_cut_at_arhat }, { name := ``Grid.identityView_cut_iff_noDefiledVoicing }, { name := ``Grid.conceit_excluded_of_quietOn }, { name := ``Grid.ksmdIrreversibleRegime_conditional }, { name := ``Grid.lower_fetters_covered_by_rites_view_resolve }, { name := ``Grid.ksmdStreamWinner_iff_streamEntry_cutClasses }, { name := ``Grid.ksmdNonReturner_iff_nonReturn_cut }, { name := ``Grid.ksmdSerialFactorRegime_conditional }, { name := ``Grid.ksmdOnceReturner_attenuation_witness, allowed := [``propext] }, { name := ``FactorsNegative.no_hold_conceit_boundary_recovery, allowed := [``propext] }, { name := ``FactorsNegative.factor_order_underdetermined, allowed := [``propext] }, { name := ``FettersNegative.seen_run_underdetermines_fetterCut, allowed := [``propext] }, { name := ``Grid.DirectedConvention.ksmdPathOught_conditional }, { name := ``Grid.DirectedConvention.ksmdFaithOught_conditional }, { name := ``Grid.DirectedConvention.ksmd_says_true_of_faith }, { name := ``Grid.DirectedConvention.noDelusion_of_noNescience_of_terminus }, { name := ``Grid.DirectedConvention.ksmdFullyEnlightened_of_fullyEnlightenedEnacted }, { name := ``FaithNegative.noNescience_strictly_stronger_witness, allowed := [``propext] }, { name := ``FaithNegative.aklishta_ajnana_witness, allowed := [``propext] }, { name := ``FaithNegative.arhat_retains_nescience_witness, allowed := [``propext] }, { name := ``FaithNegative.Sealed.silent_buddha_models, allowed := [``propext] }, { name := ``Grid.DirectedConvention.no_ksmd_path_at_pole }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.rowOf_obeys }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.pole_validates_all_claims }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.denied_misfits_live_offer }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.rowOf_obeys_iff_errorFree }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.reEmptied_obeys_of_errorFree }, { name := ``rung_not_pole_witness, allowed := [``propext] }, { name := ``standing_does_not_determine_dated, allowed := [``propext] }, { name := ``Grid.DirectedConvention.map_ksmdAversionContext_iff }, { name := ``OrthogonalityNegative.ksmdEffectiveTerminus_stronger_than_terminus, allowed := [``propext] }, { name := ``MisFeedNegative.fence_and_gate, allowed := [``propext] }, { name := ``misFeed_entries_carry_decomposition }, { name := ``Grid.grade_independent_of_conditions }, { name := ``Grid.rePitch_forgets }, { name := ``Grid.respondsToEveryCall_of_no_call }, { name := ``Grid.DirectedConvention.PrudentialPrivilegeNegative.prudentialPrivilege_failure_modes, allowed := [``propext] }, { name := ``Grid.ConsequentialistConvention.dropCountInFiber_le_dropCount, allowed := [``propext] }, { name := ``Grid.ConsequentialistConvention.dropCount_eq_sum_dropCountInFiber, allowed := [``propext] }, { name := ``Grid.ConsequentialistConvention.map_dropCountInFiberSum, allowed := [``propext] }, { name := ``ObjectiveNegative.split_dropCount_sum_eq_mergedDropCount, allowed := [``propext] }, { name := ``ObjectiveNegative.no_grid_data_objective_for_my_drops, allowed := [``propext] }, { name := ``TransferNegative.adaptive_track_record_underdetermines_new_effect, allowed := [``propext] }, { name := ``Grid.DirectedConvention.not_effectivenessEnacted_of_undelivered }, { name := ``EffectiveTerminusNegative.no_effectiveTerminus_recovery_from_run, allowed := [``propext] }, { name := ``DeliveryArrogationNegative.command_utterance_not_fits, allowed := [``propext] }, { name := ``Grid.DirectedConvention.landing_call_in_modality }, { name := ``LedgerCase.decree_engineers_calls_not_receptions, allowed := [``propext] }, { name := ``LedgerCase.official_actualAgentInhabited, allowed := [``propext] }, { name := ``InteriorDirectionNegative.transposeCR_involutive, allowed := [``propext] }, { name := ``InteriorDirectionNegative.unorderedCRContent_transpose_invariant, allowed := [``propext] }, { name := ``InteriorDirectionNegative.transpose_swaps_readings, allowed := [``propext] }, { name := ``DoerDeedNegative.priority_readings_disagree }, { name := ``DoerDeedNegative.no_priority_recovery }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.intraWeldArrowRow_obeys }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.intraWeldArrowRow_not_freeze }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.no_order_collapse_self_refuting }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.doerDeedRow_obeys }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.doerDeedRow_not_freeze }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.no_prior_doer_collapse_self_refuting }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.contentLayerRow_obeys_of_variation }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.contentIntraWeldArrowRow_obeys_of_variation }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.interior_order_denial_unfit_for_live_utterer }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.intraWeldArrowLadder_obeys }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.intraWeldArrowLadder_obeys_succ }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.intraWeldArrowLadder_no_level_final }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.doerDeedLadder_obeys }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.doerDeedLadder_obeys_succ }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.doerDeedLadder_no_level_final }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.Metaphysics.intraWeldArrow_sunyata }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.Metaphysics.doerDeed_sunyata }, { name := ``Grid.map_responseVariesWithCall_iff }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.map_intraWeldArrowRow_obeys }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.map_doerDeedRow_obeys }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.map_contentIntraWeldArrowRow_obeys_of_variation }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.map_intraWeldArrowLadder_obeys }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.map_intraWeldArrowLadder_obeys_succ }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.map_intraWeldArrowLadder_no_level_final }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.map_doerDeedLadder_obeys }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.map_doerDeedLadder_obeys_succ }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.map_doerDeedLadder_no_level_final }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.ladderRungGrid_beings_sunyata, allowed := [``propext] }, { name := ``Grid.DirectedConvention.BeingConvention.GridConvention.ladderRungGrid_no_level_final, allowed := [``propext] } ] open Lean Elab Command Meta syntax (name := verifyAxiomAudit) "#verify_axiom_audit" : command unsafe def evalAxiomAuditLedger : Term.TermElabM (List AxiomAuditEntry) := do evalExpr (List AxiomAuditEntry) (mkApp (mkConst ``List [Level.zero]) (mkConst ``AxiomAuditEntry)) (mkConst ``axiomAuditLedger) private def renderNames (names : List Lean.Name) : String := "[" ++ String.intercalate ", " (names.map (fun name => name.toString)) ++ "]" @[command_elab verifyAxiomAudit] unsafe def elabVerifyAxiomAudit : CommandElab := fun _stx => do let entries <- liftTermElabM evalAxiomAuditLedger let env <- getEnv let mut failures : Array String := #[] for entry in entries do if !env.contains entry.name then failures := failures.push s!"{entry.name}: declaration is not in the environment" else let actual := (← Lean.collectAxioms entry.name).toList let unexpected := actual.filter (fun name => !entry.allowed.contains name) let absent := entry.allowed.filter (fun name => !actual.contains name) unless unexpected.isEmpty && absent.isEmpty do failures := failures.push s!"{entry.name}: unexpected {renderNames unexpected}; expected-but-absent {renderNames absent}; allowed {renderNames entry.allowed}; actual {renderNames actual}" unless failures.isEmpty do let details := failures.foldl (fun acc item => acc ++ "\n" ++ item) "" throwError m!"axiom audit failed:{details}" #verify_axiom_audit end KannoSoe ===== FILE: KannoSoe/Meta/Examples.lean ===== import KannoSoe.Signature.V2 /-! # Signature examples Examples of certified beings, two-sided resonance grades, and direction. -/ namespace BeingAndGrading inductive Signal where | firstCall | firstBeing | firstResponse | firstResult | secondCall | secondBeing | secondResponse | secondResult deriving DecidableEq, Repr open Signal def universalLinkage : Linkage Signal where Linked := fun _ _ => True symm := fun _ => trivial def firstResonance : Resonance Signal := Resonance.mk' universalLinkage (Component.singleton firstCall) firstBeing firstResponse (Component.singleton firstResult) trivial trivial trivial def secondResonance : Resonance Signal := Resonance.mk' universalLinkage (Component.singleton secondCall) secondBeing secondResponse (Component.singleton secondResult) trivial trivial trivial def singleBeing : Being Signal := Being.ofResonances universalLinkage [firstResonance] (by simp) (by show universalLinkage.ChainLinked [Component.singleton firstBeing, Component.singleton firstResponse] exact .cons trivial (.single _)) theorem consecutiveMiddlesLinked : universalLinkage.Linked (Component.singleton firstResponse) (Component.singleton secondBeing) := trivial def multiBeing : Being Signal := Being.ofResonances universalLinkage [firstResonance, secondResonance] (by simp) (by show universalLinkage.ChainLinked [Component.singleton firstBeing, Component.singleton firstResponse, Component.singleton secondBeing, Component.singleton secondResponse] exact .cons trivial (.cons consecutiveMiddlesLinked (.cons trivial (.single _)))) def natPreorderBot : PreorderBot Nat where le := (· ≤ ·) bot := 0 leRefl := Nat.le_refl leTrans := Nat.le_trans botLeast := Nat.zero_le def independentlyGraded : GradedResonance Signal natPreorderBot := GradedResonance.ofResonance firstResonance 2 7 example : (GradedResonance.ofResonance (PB := natPreorderBot) firstResonance 2 7).callsGrade = 2 := by simp example : (GradedResonance.ofResonance (PB := natPreorderBot) firstResonance 2 7).responsesGrade = 7 := by simp def ungradedResonance : GradedResonance Signal natPreorderBot := GradedResonance.ungraded firstResonance example : ungradedResonance.callsGrade = natPreorderBot.bot := by simp [ungradedResonance] example : ungradedResonance.responsesGrade = natPreorderBot.bot := by simp [ungradedResonance] example : GradedResonance.IsUngraded ungradedResonance := by simp [GradedResonance.IsUngraded, ungradedResonance] def lowerGrades : GradedResonance Signal natPreorderBot := GradedResonance.ofResonance firstResonance 1 3 example : GradedResonance.le lowerGrades independentlyGraded := by change 1 ≤ 2 ∧ 3 ≤ 7 decide end BeingAndGrading /-! ## Galactic tea drinking -/ namespace GalacticTea inductive GalacticTeaCase where | bigBang | localTea | remoteTea deriving DecidableEq, Repr open GalacticTeaCase inductive TeaBefore : GalacticTeaCase → GalacticTeaCase → Prop where | bigBang_local : TeaBefore bigBang localTea | bigBang_remote : TeaBefore bigBang remoteTea def teaRank : GalacticTeaCase → Nat | bigBang => 0 | localTea => 1 | remoteTea => 1 theorem teaBefore_rank_lt {x y : GalacticTeaCase} (h : TeaBefore x y) : teaRank x < teaRank y := by cases h <;> decide def teaDirection : Directed GalacticTeaCase := Directed.ofBaseRank TeaBefore teaRank teaBefore_rank_lt def teaLinkage : Linkage GalacticTeaCase where Linked := fun _ _ => True symm := fun _ => trivial def bigBangLocalDependence : MutualDependence GalacticTeaCase := MutualDependence.pair teaLinkage (Component.singleton bigBang) (Component.singleton localTea) trivial def bigBangRemoteDependence : MutualDependence GalacticTeaCase := MutualDependence.pair teaLinkage (Component.singleton bigBang) (Component.singleton remoteTea) trivial inductive TeaCauses : GalacticTeaCase → GalacticTeaCase → Prop where | bigBang_local : TeaCauses bigBang localTea | bigBang_remote : TeaCauses bigBang remoteTea def teaCausal : Causal GalacticTeaCase where toDirected := teaDirection Causes := TeaCauses causes_before := fun h => by cases h with | bigBang_local => exact Relation.TransGen.single TeaBefore.bigBang_local | bigBang_remote => exact Relation.TransGen.single TeaBefore.bigBang_remote certify := fun h => by cases h with | bigBang_local => exact .ofMutualDependence bigBangLocalDependence rfl rfl | bigBang_remote => exact .ofMutualDependence bigBangRemoteDependence rfl rfl example : Causation GalacticTeaCase bigBang localTea := teaCausal.certify TeaCauses.bigBang_local example : Causation GalacticTeaCase bigBang remoteTea := teaCausal.certify TeaCauses.bigBang_remote theorem localRemote_not_before : ¬ teaDirection.Before localTea remoteTea := by intro h change Relation.TransGen TeaBefore localTea remoteTea at h exact Nat.lt_irrefl 1 (Directed.rank_lt_of_transGen (base := TeaBefore) (rank := teaRank) teaBefore_rank_lt h) theorem remoteLocal_not_before : ¬ teaDirection.Before remoteTea localTea := by intro h change Relation.TransGen TeaBefore remoteTea localTea at h exact Nat.lt_irrefl 1 (Directed.rank_lt_of_transGen (base := TeaBefore) (rank := teaRank) teaBefore_rank_lt h) theorem tea_not_before_bigBang : ¬ teaDirection.Before localTea bigBang := by apply teaDirection.asymm change Relation.TransGen TeaBefore bigBang localTea exact Relation.TransGen.single TeaBefore.bigBang_local end GalacticTea ===== FILE: KannoSoe/Meta/Invariance.lean ===== /- ================================================================================ KannoSoe.Meta.Invariance Display reparameterization, carrier relabelling, and transport lemmas ================================================================================ This module transports grid predicates across display reparameterizations and whole-carrier relabellings, and keeps transport lemmas centralized so missing invariance facts are conspicuous. Reading and motivation: Identification/Commentary.lean, C.3. -/ import KannoSoe.Consequences.ContentRows import KannoSoe.Signature.DirectionConvention import KannoSoe.Identification import KannoSoe.Doctrines.Deliberation import KannoSoe.Doctrines.Sraddha import KannoSoe.Doctrines.Faith import KannoSoe.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 KannoSoe /-- 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 /-- A small, dependency-free equivalence type for carrier transport. -/ structure Equiv (α β : Type) where toFun : α → β invFun : β → α left_inv : ∀ a, invFun (toFun a) = a right_inv : ∀ b, toFun (invFun b) = b namespace Equiv instance {α β : Type} : CoeFun (Equiv α β) (fun _ => α → β) := ⟨Equiv.toFun⟩ abbrev symm {α β : Type} (σ : Equiv α β) : β → α := σ.invFun @[simp] theorem apply_symm_apply {α β : Type} (σ : Equiv α β) (b : β) : σ (σ.symm b) = b := σ.right_inv b @[simp] theorem symm_apply_apply {α β : Type} (σ : Equiv α β) (a : α) : σ.symm (σ a) = a := σ.left_inv a theorem injective {α β : Type} (σ : Equiv α β) {a b : α} (h : σ a = σ b) : a = b := by rw [← σ.left_inv a, ← σ.left_inv b, h] end Equiv /-- Backwards-compatible name for a bijection of the whole designatum carrier. Relabelling is no longer agent-only surgery: every role reading is transported through the same equivalence. -/ abbrev AgentReparam (Designatum Designatum' : Type) := Equiv Designatum Designatum' namespace AgentReparam variable {Designatum Designatum' : Type} variable (σ : AgentReparam Designatum Designatum') theorem toFun_injective {a b : Designatum} (h : σ.toFun a = σ.toFun b) : a = b := σ.injective h end AgentReparam namespace Config variable {Designatum Contrib : Type} /-- Agent relabelling acts trivially on a configuration because `Config` contains no `Being`-typed material. -/ def relabel {Designatum Designatum' : Type} (cfg : Config Contrib) (_σ : Equiv Designatum Designatum') : Config Contrib := cfg /-- `Config` never mentions `Being`, so its agent-relabelling action is fixed. The definitional triviality is the point. -/ theorem relabel_fixed {Designatum Designatum' : Type} (cfg : Config Contrib) (σ : Equiv Designatum Designatum') : cfg.relabel σ = cfg := rfl variable {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 {Designatum Designatum' : Type} variable {Contrib Contrib' : Type} [PreorderBot Contrib] [PreorderBot Contrib'] /-- Relabel the whole designatum carrier through an equivalence. Occurrence, role, response, placement, and conditioning readings all co-vary. -/ def relabel (G : CoreReadings Designatum Contrib) (σ : Equiv Designatum Designatum') : CoreReadings Designatum' Contrib where occurrence := { occurrence := fun d => G.occurrence.occurrence (σ.symm d) isBeing := fun d => G.occurrence.isBeing (σ.symm d) isCall := fun d => G.occurrence.isCall (σ.symm d) isResponse := fun d => G.occurrence.isResponse (σ.symm d) agent := fun d => σ (G.occurrence.agent (σ.symm d)) call := fun d => σ (G.occurrence.call (σ.symm d)) response := fun d => σ (G.occurrence.response (σ.symm d)) } response := { respondsTo := fun b c => Option.map σ (G.respondsTo (σ.symm b) (σ.symm c)) } placement := { grade := fun d => G.grade (σ.symm d) } conditioning := { conditions := fun deed reception => G.conditioning.conditions (σ.symm deed) (σ.symm reception) } end Grid namespace CoreReadings /-- Field-notation bridge for whole-carrier relabelling. -/ abbrev relabel {Designatum Designatum' Contrib : Type} [PreorderBot Contrib] (G : CoreReadings Designatum Contrib) (σ : Equiv Designatum Designatum') : CoreReadings Designatum' Contrib := Grid.relabel G σ end CoreReadings namespace Grid variable {Designatum Designatum' : Type} variable {Contrib Contrib' : Type} [PreorderBot Contrib] [PreorderBot Contrib'] def relabelWeld (G : CoreReadings Designatum Contrib) (σ : Equiv Designatum Designatum') (w : G.Weld) : (G.relabel σ).Weld := ⟨σ w.1, by simpa [relabel] using w.2⟩ @[simp] theorem relabelWeld_agent (G : CoreReadings Designatum Contrib) (σ : Equiv Designatum Designatum') (w : G.Weld) : (relabelWeld G σ w).agent = σ w.agent := by change σ (G.occurrence.agent (σ.symm (σ w.1))) = σ (G.occurrence.agent w.1) rw [Equiv.symm_apply_apply σ w.1] @[simp] theorem relabelWeld_call (G : CoreReadings Designatum Contrib) (σ : Equiv Designatum Designatum') (w : G.Weld) : (relabelWeld G σ w).call = σ w.call := by change σ (G.occurrence.call (σ.symm (σ w.1))) = σ (G.occurrence.call w.1) rw [Equiv.symm_apply_apply σ w.1] @[simp] theorem relabelWeld_response (G : CoreReadings Designatum Contrib) (σ : Equiv Designatum Designatum') (w : G.Weld) : (relabelWeld G σ w).response = σ w.response := by change σ (G.occurrence.response (σ.symm (σ w.1))) = σ (G.occurrence.response w.1) rw [Equiv.symm_apply_apply σ w.1] variable (G : CoreReadings Designatum Contrib) variable (σ : Equiv Designatum Designatum') theorem relabel_actual_iff (w : G.Weld) : (G.relabel σ).Actual (relabelWeld G σ w) ↔ G.Actual w := by change (G.relabel σ).respondsTo (relabelWeld G σ w).agent (relabelWeld G σ w).call = some (relabelWeld G σ w).response ↔ G.respondsTo w.agent w.call = some w.response simp only [relabelWeld_agent, relabelWeld_call, relabelWeld_response] simp only [CoreReadings.relabel, Grid.relabel, CoreReadings.respondsTo, Grid.respondsTo, Equiv.symm_apply_apply] change Option.map σ (G.respondsTo w.agent w.call) = some (σ w.response) ↔ G.respondsTo w.agent w.call = some w.response cases hresponse : G.respondsTo w.agent w.call with | none => simp | some response => simp only [Option.map_some, Option.some.injEq] exact ⟨σ.injective, congrArg σ⟩ theorem relabel_share (w : G.Weld) : (G.relabel σ).share (relabelWeld G σ w) = G.share w := by change G.grade (σ.symm (σ w.1)) = G.grade w.1 rw [Equiv.symm_apply_apply σ w.1] theorem relabel_hasSelfPoleIndex_iff (w : G.Weld) : (G.relabel σ).HasSelfPoleIndex (relabelWeld G σ w) ↔ G.HasSelfPoleIndex w := by change (¬ AtBot ((G.relabel σ).share (relabelWeld G σ w))) ↔ ¬ AtBot (G.share w) rw [relabel_share G σ w] theorem relabel_deliveredTo_iff (deed reception : G.Weld) : DirectedConvention.DeliveredTo (G.relabel σ) (relabelWeld G σ deed) (relabelWeld G σ reception) ↔ DirectedConvention.DeliveredTo G deed reception := by unfold DirectedConvention.DeliveredTo KannoSoe.DeliveredTo change G.conditioning.conditions (σ.symm (σ deed.1)) (σ.symm (σ reception.1)) ↔ G.conditioning.conditions deed.1 reception.1 simp /-- Same-agent delivery is agent-sensitive but relabelling-invariant: it depends on the equality pattern of tags, not on which tags name it. -/ theorem relabel_sameAgentDelivery_iff (deed reception : G.Weld) : DirectedConvention.SameAgentDelivery (G.relabel σ) (relabelWeld G σ deed) (relabelWeld G σ reception) ↔ DirectedConvention.SameAgentDelivery G deed reception := by constructor · rintro ⟨hdelivered, hagent⟩ simp only [relabelWeld_agent] at hagent exact ⟨(relabel_deliveredTo_iff G σ deed reception).mp hdelivered, AgentReparam.toFun_injective σ hagent⟩ · rintro ⟨hdelivered, hagent⟩ exact ⟨(relabel_deliveredTo_iff G σ deed reception).mpr hdelivered, by simpa only [relabelWeld_agent] using congrArg σ hagent⟩ /-- The weld register co-varies with the relabelling; unlike `Config`, its index is not fixed. -/ theorem relabel_index (w : G.Weld) : (G.relabel σ).index (relabelWeld G σ w) = σ (G.index w) := relabelWeld_agent G σ w /-- Re-pitching commutes with carrier relabelling: the configuration handed forward is identical whether the run uses the original or relabelled fine tags. The definitional triviality is the point: `Config` offers no agent material on which relabelling could act. -/ theorem relabel_rePitch (before : Config Contrib) (w : G.Weld) : (G.relabel σ).rePitch before (relabelWeld G σ w) = G.rePitch before w := by apply Config.ext exact relabel_share G σ w namespace AgentRelabellingWitness /-- A symmetric two-agent grid used only to refute natural recovery. -/ def symmetricOccurrence : OccurrenceReading Bool where occurrence _ := True isBeing _ := True isCall _ := True isResponse _ := True agent := id call := id response := id def symmetricGrid : CoreReadings Bool Contrib where occurrence := symmetricOccurrence response := { respondsTo := fun b _ => some b } placement := { grade := fun _ => shareBot } conditioning := { conditions := fun _ _ => True } /-- The fixed-point-free swap of the symmetric grid's two fine tags. -/ def swap : AgentReparam Bool Bool where toFun := Bool.not invFun := Bool.not left_inv := by intro b; cases b <;> rfl right_inv := by intro b; cases b <;> rfl theorem ne_not_self (b : Bool) : b ≠ Bool.not b := by cases b <;> intro h <;> cases h end AgentRelabellingWitness /-- No relabelling-equivariant family of functions reads an agent out of a configuration. Honest scope: this refutes uniform (natural) recovery; a particular model's stored value may extensionally coincide with an agent tag, as `ConfigLeakWitness` records in `Meta/InvarianceNegative.lean`. -/ theorem no_natural_agent_recovery_from_config : ¬ ∃ recover : (Designatum : Type) → [Nonempty Designatum] → CoreReadings Designatum Contrib → Config Contrib → Designatum, ∀ (Designatum Designatum' : Type) [Nonempty Designatum] [Nonempty Designatum'] (G : CoreReadings Designatum Contrib) (σ : Equiv Designatum Designatum') (cfg : Config Contrib), recover Designatum' (G.relabel σ) cfg = σ (recover Designatum G cfg) := by rintro ⟨recover, natural⟩ let cfg : Config Contrib := { tendency := shareBot } have h := natural Bool Bool AgentRelabellingWitness.symmetricGrid AgentRelabellingWitness.swap cfg have hgrid : (AgentRelabellingWitness.symmetricGrid (Contrib := Contrib)).relabel AgentRelabellingWitness.swap = AgentRelabellingWitness.symmetricGrid (Contrib := Contrib) := by ext d <;> cases d <;> rfl rw [hgrid] at h change recover Bool AgentRelabellingWitness.symmetricGrid cfg = Bool.not (recover Bool AgentRelabellingWitness.symmetricGrid cfg) at h exact AgentRelabellingWitness.ne_not_self (recover Bool AgentRelabellingWitness.symmetricGrid cfg) h /-- Transport a grid by reparameterizing only its Row-2 display carrier. -/ def map (G : CoreReadings Designatum Contrib) (f : DisplayReparam Contrib Contrib') : CoreReadings Designatum Contrib' where occurrence := G.occurrence response := G.response placement := { grade := fun d => f.toFun (G.grade d) } conditioning := G.conditioning end Grid namespace CoreReadings /-- Field-notation bridge for contribution-display transport. -/ abbrev map {Designatum Contrib Contrib' : Type} [PreorderBot Contrib] [PreorderBot Contrib'] (G : CoreReadings Designatum Contrib) (f : DisplayReparam Contrib Contrib') : CoreReadings Designatum Contrib' := Grid.map G f end CoreReadings namespace Grid variable {Designatum Designatum' : Type} variable {Contrib Contrib' : Type} [PreorderBot Contrib] [PreorderBot Contrib'] variable (G : CoreReadings Designatum Contrib) (f : DisplayReparam Contrib Contrib') @[simp] theorem map_grade (d : Designatum) : (G.map f).grade d = f.toFun (G.grade d) := 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 /-- 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, (map_actual_iff G f w).mp hactual⟩ · rintro ⟨w, hactual⟩ exact ⟨w, (map_actual_iff G 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 : CoreReadings Designatum Contrib} (f : DisplayReparam Contrib Contrib') : ActualWeld G -> ActualWeld (G.map f) | ⟨w, h⟩ => ⟨w, (map_actual_iff G f w).mpr h⟩ @[simp] theorem map_weld {G : CoreReadings Designatum Contrib} (f : DisplayReparam Contrib Contrib') (aw : ActualWeld G) : (aw.map f).weld = aw.weld := rfl end ActualWeld namespace SentienceReading /-- A supplied sentience reading transports unchanged across a share-display reparameterization because the weld carrier is unchanged. -/ def displayMap {G : CoreReadings Designatum Contrib} (S : SentienceReading G) (f : DisplayReparam Contrib Contrib') : SentienceReading (G.map f) where sentient := S.sentient @[simp] theorem displayMap_sentient {G : CoreReadings Designatum Contrib} (S : SentienceReading G) (f : DisplayReparam Contrib Contrib') (w : G.Weld) : (S.displayMap f).sentient w ↔ S.sentient w := Iff.rfl end SentienceReading theorem map_mountsAt_iff (b : Designatum) (c : Designatum) : (G.map f).MountsAt b c ↔ G.MountsAt b c := Iff.rfl theorem map_respondsToEveryCall_iff (b : Designatum) : (G.map f).RespondsToEveryCall b ↔ G.RespondsToEveryCall b := Iff.rfl theorem map_responseVariesWithCall_iff (b : Designatum) : (G.map f).ResponseVariesWithCall b ↔ G.ResponseVariesWithCall b := Iff.rfl theorem map_actualAgentInhabited_iff (b : Designatum) : (G.map f).ActualAgentInhabited b ↔ G.ActualAgentInhabited b := by constructor · rintro ⟨w, hactual, hagent⟩ exact ⟨w, (map_actual_iff G f w).mp hactual, hagent⟩ · rintro ⟨w, hactual, hagent⟩ exact ⟨w, (map_actual_iff G f w).mpr hactual, hagent⟩ 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 : Designatum) (deed reception : G.Weld) : EnvironsLine (G.map f) b deed reception ↔ EnvironsLine G b deed reception := Iff.rfl namespace DirectionCoarsening variable {G : CoreReadings Designatum 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 : Designatum) : (G.map f).Terminus b ↔ G.Terminus b := by constructor · intro h w hactual hagent exact (f.atBot_iff (G.share w)).mp (by simpa [Grid.map_share] using (h w ((map_actual_iff G f w).mpr hactual) hagent)) · intro h w hactual hagent exact (f.atBot_iff (G.share w)).mpr (h w ((map_actual_iff G f w).mp hactual) hagent) theorem map_liveTerminus_iff (b : Designatum) : (G.map f).LiveTerminus b ↔ G.LiveTerminus b := by constructor · intro h exact ⟨(map_actualAgentInhabited_iff G f b).mp h.left, (map_terminus_iff G f b).mp h.right⟩ · intro h exact ⟨(map_actualAgentInhabited_iff G f b).mpr h.left, (map_terminus_iff G f b).mpr h.right⟩ theorem map_responsiveTerminus_iff (b : Designatum) : (G.map f).ResponsiveTerminus b ↔ G.ResponsiveTerminus b := by constructor · intro h exact ⟨(map_respondsToEveryCall_iff G f b).mp h.left, (map_terminus_iff G f b).mp h.right⟩ · intro h exact ⟨(map_respondsToEveryCall_iff G f b).mpr h.left, (map_terminus_iff G f b).mpr h.right⟩ theorem map_atPoleClass_iff (b : Designatum) : (G.map f).AtPoleClass b ↔ G.AtPoleClass b := map_terminus_iff G f b 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_ksmdMismatchGrade (w : G.Weld) : (G.map f).KsmdMismatchGrade w = f.toFun (G.KsmdMismatchGrade w) := rfl theorem map_clenchMismatch_iff (w : G.Weld) : (G.map f).ClenchMismatch w ↔ G.ClenchMismatch w := by constructor · intro h exact ⟨(map_actual_iff G f w).mp h.left, (map_hasSelfPoleIndex_iff G f w).mp h.right⟩ · intro h exact ⟨(map_actual_iff G f w).mpr h.left, (map_hasSelfPoleIndex_iff G f w).mpr h.right⟩ theorem map_ksmdDukkha_iff (S : SentienceReading G) (w : G.Weld) : (G.map f).KsmdDukkha (S.displayMap f) w ↔ G.KsmdDukkha S w := by constructor · intro h exact ⟨h.left, (map_clenchMismatch_iff G f w).mp h.right⟩ · intro h exact ⟨h.left, (map_clenchMismatch_iff G f w).mpr h.right⟩ theorem map_probeConstant_iff (b : Designatum) (cs : Designatum → Prop) : (G.map f).ProbeConstant b cs ↔ G.ProbeConstant b cs := by constructor · intro h w₁ w₂ hactual₁ hactual₂ hagent₁ hagent₂ hcall₁ hcall₂ exact (f.orderEq_iff (G.share w₁) (G.share w₂)).mp (by simpa [Grid.map_share] using (h w₁ w₂ ((map_actual_iff G f w₁).mpr hactual₁) ((map_actual_iff G f w₂).mpr hactual₂) hagent₁ hagent₂ hcall₁ hcall₂)) · intro h w₁ w₂ hactual₁ hactual₂ hagent₁ hagent₂ hcall₁ hcall₂ exact (f.orderEq_iff (G.share w₁) (G.share w₂)).mpr (h w₁ w₂ ((map_actual_iff G f w₁).mp hactual₁) ((map_actual_iff G f w₂).mp hactual₂) hagent₁ hagent₂ hcall₁ hcall₂) theorem map_ksmdBullSeven_iff (b : Designatum) : (G.map f).KsmdBullSeven b ↔ G.KsmdBullSeven b := by constructor · rintro ⟨hprobe, w, hactual, hagent, hidx⟩ exact ⟨(map_probeConstant_iff G f b (fun _ => True)).mp hprobe, ⟨w, (map_actual_iff G f w).mp hactual, hagent, (map_hasSelfPoleIndex_iff G f w).mp hidx⟩⟩ · rintro ⟨hprobe, w, hactual, hagent, hidx⟩ exact ⟨(map_probeConstant_iff G f b (fun _ => True)).mpr hprobe, ⟨w, (map_actual_iff G f w).mpr hactual, hagent, (map_hasSelfPoleIndex_iff G f w).mpr hidx⟩⟩ namespace DirectedConvention namespace BeingConvention namespace BeingCoarsening variable {G : CoreReadings Designatum 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 : Designatum) : (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, (map_actual_iff G f w).mp hactual, hfiber⟩ · rintro ⟨w, hactual, hfiber⟩ exact ⟨w, (map_actual_iff G f w).mpr hactual, hfiber⟩ theorem map_sentientTag_iff (κ : BeingCoarsening G Macro) (S : SentienceReading G) (f : DisplayReparam Contrib Contrib') (b : Macro) : (displayMap κ f).SentientTag (S.displayMap f) b ↔ κ.SentientTag S b := by constructor · rintro ⟨w, hsentient, hfiber⟩ exact ⟨w, ⟨(map_actual_iff G f w).mp hsentient.left, hsentient.right⟩, hfiber⟩ · rintro ⟨w, hsentient, hfiber⟩ exact ⟨w, ⟨(map_actual_iff G f w).mpr hsentient.left, hsentient.right⟩, hfiber⟩ 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 ((map_actual_iff G 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 ((map_actual_iff G 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 : Designatum → Prop) : (displayMap κ f).ActualFiberInhabitedOn b cs ↔ κ.ActualFiberInhabitedOn b cs := by constructor · rintro ⟨w, hactual, hfiber, hclass⟩ exact ⟨w, (map_actual_iff G f w).mp hactual, hfiber, hclass⟩ · rintro ⟨w, hactual, hfiber, hclass⟩ exact ⟨w, (map_actual_iff G f w).mpr hactual, hfiber, hclass⟩ theorem map_actualFiberInhabitedWithin_iff (κ : BeingCoarsening G Macro) (f : DisplayReparam Contrib Contrib') (b : Macro) (ts : Designatum → Prop) : (displayMap κ f).ActualFiberInhabitedWithin b ts ↔ κ.ActualFiberInhabitedWithin b ts := by constructor · rintro ⟨w, hactual, hfiber, htag⟩ exact ⟨w, (map_actual_iff G f w).mp hactual, hfiber, htag⟩ · rintro ⟨w, hactual, hfiber, htag⟩ exact ⟨w, (map_actual_iff G f w).mpr hactual, hfiber, htag⟩ theorem map_fiberAtPoleOn_iff (κ : BeingCoarsening G Macro) (f : DisplayReparam Contrib Contrib') (b : Macro) (cs : Designatum → 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 ((map_actual_iff G 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 ((map_actual_iff G 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 : Designatum → Prop) (ts : Designatum → 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 ((map_actual_iff G 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 ((map_actual_iff G 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 : Designatum → 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 : Designatum → 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 : Designatum → 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 ((map_actual_iff G f w).mpr hactual) hfiber exact (map_hasSelfPoleIndex_iff G f w).mp hidx · intro h w hactual hfiber have hidx : G.HasSelfPoleIndex w := h w ((map_actual_iff G f w).mp hactual) hfiber exact (map_hasSelfPoleIndex_iff G f w).mpr hidx theorem map_selfAptTagWithin_iff (κ : BeingCoarsening G Macro) (f : DisplayReparam Contrib Contrib') (b : Macro) (ts : Designatum → 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 ((map_actual_iff G f w).mpr hactual) hfiber htag exact (map_hasSelfPoleIndex_iff G f w).mp hidx · intro h w hactual hfiber htag have hidx : G.HasSelfPoleIndex w := h w ((map_actual_iff G f w).mp hactual) hfiber htag exact (map_hasSelfPoleIndex_iff G 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, (map_actual_iff G 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, (map_actual_iff G 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 ((map_actual_iff G 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 ((map_actual_iff G 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_ksmdBullTen_iff {Macro : Type} (S : SentienceReading G) (κ : DirectedConvention.BeingConvention.BeingCoarsening G Macro) (b : Designatum) : (G.map f).KsmdBullTen (S.displayMap f) (κ.displayMap f) b ↔ G.KsmdBullTen S κ b := by constructor · intro h refine ⟨(map_responsiveTerminus_iff G 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, (map_actual_iff G 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 κ S f (κ.proj reception.agent)).mp hsentient, (DirectedConvention.map_deliveredTo_iff G f deed reception).mp hdel⟩ · intro h refine ⟨(map_responsiveTerminus_iff G 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, (map_actual_iff G 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 κ S f (κ.proj reception.agent)).mpr hsentient, (DirectedConvention.map_deliveredTo_iff G f deed reception).mpr hdel⟩ theorem map_stateToolFits_iff (w : G.Weld) : StateToolFits (G.map f) w ↔ StateToolFits G w := by constructor · intro h hidx exact h ((map_hasSelfPoleIndex_iff G f w).mpr hidx) · intro h hidx exact h ((map_hasSelfPoleIndex_iff G f w).mp hidx) namespace Tier /-- Transport a diagnostic tier along a grid reparameterization. -/ def map {G : CoreReadings Designatum 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 => map_hasSelfPoleIndex_iff G 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, (map_hasSelfPoleIndex_iff G f w).mp ht⟩ · rintro ⟨t, ht⟩ exact ⟨Tier.map f t, (map_tier_hasLiveShare_iff G 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 ((map_actual_iff G f _).mpr hactual) ((map_isShareDrop_iff G f _ _).mpr hdrop) (by simpa [Grid.map_rePitch] using ih) /-- Transport a Bull-ascent run across a display reparameterization. -/ def map_bullAscent (a : BullAscent G) : BullAscent (G.map f) where before := a.before.map f run := a.run drops := map_shareDropRun G 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 (map_isShareDrop_iff G 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 ((map_isShareDrop_iff G 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 (map_isShareDrop_iff G 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 ((map_isShareDrop_iff G 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, (map_isShareDrop_iff G f before reception).mp h.right⟩ · intro h exact ⟨(map_landsAt_iff G f deed reception).mpr h.left, (map_isShareDrop_iff G 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 : Designatum) (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, (map_isShareDrop_iff G f before reception).mp h.right⟩ · intro h exact ⟨(map_environsLine_iff G f b deed reception).mpr h.left, (map_isShareDrop_iff G 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_ksmdEffectiveTerminus_reflect {b : Designatum} (h : KsmdEffectiveTerminus (G.map f) b) : KsmdEffectiveTerminus G b := by constructor · exact (map_responsiveTerminus_iff G 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.ksmdEffectiveTerminus_needs_coverage` shows the hypothesis is needed. -/ theorem map_ksmdEffectiveTerminus_of_surjective (hsurj : ∀ b' : Contrib', ∃ a : Contrib, f.toFun a = b') {b : Designatum} (h : KsmdEffectiveTerminus G b) : KsmdEffectiveTerminus (G.map f) b := by constructor · exact (map_responsiveTerminus_iff G 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 KsmdPathClaim.map (c : KsmdPathClaim G) : KsmdPathClaim (G.map f) := { before := c.before.map f deed := c.deed reception := c.reception } /-- Truth of a path claim is display-invariant when its diagnostic tier is transported with the display. -/ theorem map_ksmdPathClaim_holds_iff (t : Tier G) (c : KsmdPathClaim G) : (ksmdPathClaimLanguage (G.map f)).Holds (Tier.map f t) (KsmdPathClaim.map G f c) ↔ (ksmdPathClaimLanguage G).Holds t c := by cases t with | floor => exact Iff.rfl | actTime _ => simpa [ksmdPathClaimLanguage, KsmdPathClaim.map, Tier.map] using (map_shortfallClosedAt_iff G f c.before c.deed c.reception) /-- With target-carrier coverage, effective termination is display-invariant outright. -/ theorem map_ksmdEffectiveTerminus_iff (hsurj : ∀ b' : Contrib', ∃ a : Contrib, f.toFun a = b') (b : Designatum) : KsmdEffectiveTerminus (G.map f) b ↔ KsmdEffectiveTerminus G b := ⟨fun h => map_ksmdEffectiveTerminus_reflect G f h, fun h => map_ksmdEffectiveTerminus_of_surjective G f hsurj h⟩ /-- Under coverage, the mapped effective-terminus proposition is propositionally the same object. -/ theorem map_effectiveTerminus_eq (hsurj : ∀ b' : Contrib', ∃ a : Contrib, f.toFun a = b') (Faith : Prop → Prop) (b : Designatum) : Faith (KsmdEffectiveTerminus (G.map f) b) = Faith (KsmdEffectiveTerminus G b) := by rw [propext (map_ksmdEffectiveTerminus_iff G f hsurj b)] theorem map_ksmdAversionContext_iff (before : Config Contrib) (reception : G.Weld) : KsmdAversionContext (G.map f) (before.map f) reception ↔ KsmdAversionContext G before reception := by constructor · intro h refine { liveBefore := ?_ clenchMismatch := ?_ } · intro hbot exact h.liveBefore ((f.atBot_iff before.tendency).mpr hbot) · exact (map_clenchMismatch_iff G f reception).mp h.clenchMismatch · intro h refine { liveBefore := ?_ clenchMismatch := ?_ } · intro hbot exact h.liveBefore ((f.atBot_iff before.tendency).mp hbot) · exact (map_clenchMismatch_iff G f reception).mpr h.clenchMismatch 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 : Designatum, G.ResponseVariesWithCall b) : (contentIntraWeldArrowRow (G.map f)).ObeysSeparateFuse := by apply contentIntraWeldArrowRow_obeys_of_variation rcases h with ⟨b, hvaries⟩ exact ⟨b, (map_responseVariesWithCall_iff G f b).mpr hvaries⟩ theorem map_contentBeingsRow_obeys_of_being (h : ∃ w : G.Weld, G.Actual w) : (contentBeingsRow (G.map f)).ObeysSeparateFuse := by apply contentBeingsRow_obeys_of_being rcases h with ⟨w, hactual⟩ exact ⟨w, (map_actual_iff G f w).mpr hactual⟩ 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) ((map_exists_liveTier_iff G 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) ((map_exists_actual_iff G 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 KannoSoe ===== FILE: KannoSoe/Meta/InvarianceNegative.lean ===== /- ================================================================================ KannoSoe.Meta.InvarianceNegative Countermodels for invariance and recovery claims ================================================================================ Reading and motivation: Identification/Commentary.lean, C.3. -/ import KannoSoe.Meta.Invariance namespace KannoSoe /- ========================================================================== Equality with a chosen bottom token 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 := .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 unitOccurrence : OccurrenceReading Unit where occurrence _ := True isBeing _ := True isCall _ := True isResponse _ := True agent := id call := id response := id def twoBottomGrid : CoreReadings Unit TwoBottom where occurrence := unitOccurrence response := { respondsTo := fun _ _ => some () } placement := { grade := fun _ => .other } conditioning := { conditions := fun _ _ => False } def twoBottomWeld : twoBottomGrid.Weld := ⟨(), True.intro⟩ /-- The retired equality-token terminus, retained only as a counterexample. The system predicate uses the pole-class `AtBot`. -/ def OldEqTerminus {Designatum Contrib : Type} [PreorderBot Contrib] (G : CoreReadings Designatum Contrib) (b : Designatum) : Prop := ∀ w : G.Weld, G.Actual w → w.agent = b → G.share w = shareBot theorem twoBottomGrid_terminus : twoBottomGrid.Terminus () := by intro _w _hactual _hagent exact True.intro theorem not_oldEqTerminus_twoBottomGrid : ¬ OldEqTerminus twoBottomGrid () := by intro h have hbad : TwoBottom.other = TwoBottom.chosen := h twoBottomWeld rfl rfl cases hbad theorem oldEqTerminus_map_mergeToUnit : OldEqTerminus (twoBottomGrid.map mergeToUnit) () := by intro _w _hactual _hagent rfl /-- Pole-class terminus transports, whereas equality with one selected bottom representative does not. -/ theorem oldEqTerminus_not_invariant : ((twoBottomGrid.map mergeToUnit).Terminus () ↔ twoBottomGrid.Terminus ()) ∧ OldEqTerminus (twoBottomGrid.map mergeToUnit) () ∧ ¬ OldEqTerminus twoBottomGrid () := ⟨Grid.map_terminus_iff twoBottomGrid mergeToUnit (), oldEqTerminus_map_mergeToUnit, not_oldEqTerminus_twoBottomGrid⟩ end InvarianceNegative /- ========================================================================== Configuration leak witnesses: honest limits of non-storage ============================================================================ -/ namespace ConfigLeakWitness /-- In the register clock, re-pitching exposes the received occurrence's register number. This is a model-specific information-flow fact, not a typed agent field stored in `Config`. -/ theorem registerClock_config_recovers_agent : ∀ (before : Config Nat) (n : Nat), (registerClockGrid.rePitch before (registerWeld n)).tendency = n := by intro _before _n rfl /-- A share collision prevents uniform recovery of the acting designatum from the re-pitched configuration, even when recovery is requested only for actual occurrence-generated welds. -/ theorem no_agent_recovery_from_config_of_share_collision : ¬ ∃ recover : Config Nat → ShareCollisionCase, ∀ (before : Config Nat) (w : shareCollisionGrid.Weld), shareCollisionGrid.Actual w → recover (shareCollisionGrid.rePitch before w) = w.agent := by rintro ⟨recover, correct⟩ let before : Config Nat := { tendency := 0 } have hleft := correct before shareCollisionLeft (by rfl) have hright := correct before shareCollisionRight (by rfl) have hcfg : shareCollisionGrid.rePitch before shareCollisionLeft = shareCollisionGrid.rePitch before shareCollisionRight := by rfl rw [hcfg] at hleft have hagents : ShareCollisionCase.left = ShareCollisionCase.right := hleft.symm.trans hright cases hagents end ConfigLeakWitness /- ========================================================================== Direction is not recoverable from symmetric conditioning ============================================================================ -/ namespace DirectionNegative inductive DirectionCase | agent | callFalse | callTrue | response | occurrenceFalse | occurrenceTrue deriving DecidableEq def directionOccurrence : OccurrenceReading DirectionCase where occurrence | .occurrenceFalse | .occurrenceTrue => True | _ => False isBeing d := d = .agent isCall d := d = .callFalse ∨ d = .callTrue isResponse d := d = .response agent | .occurrenceFalse | .occurrenceTrue => .agent | d => d call | .occurrenceFalse => .callFalse | .occurrenceTrue => .callTrue | d => d response | .occurrenceFalse | .occurrenceTrue => .response | d => d abbrev W := directionOccurrence.Weld def wFalse : W := ⟨.occurrenceFalse, True.intro⟩ def wTrue : W := ⟨.occurrenceTrue, True.intro⟩ def forwardGrid : CoreReadings DirectionCase Nat where occurrence := directionOccurrence response := { respondsTo := fun b c => if b = .agent ∧ (c = .callFalse ∨ c = .callTrue) then some .response else none } placement := { grade := fun _ => 0 } conditioning := { conditions := fun d₁ d₂ => d₁ = .occurrenceFalse ∧ d₂ = .occurrenceTrue } def backwardGrid : CoreReadings DirectionCase Nat where occurrence := directionOccurrence response := forwardGrid.response placement := forwardGrid.placement conditioning := { conditions := fun d₁ d₂ => d₁ = .occurrenceTrue ∧ d₂ = .occurrenceFalse } theorem conditionsEither_agrees (w₁ w₂ : W) : forwardGrid.ConditionsEither w₁ w₂ ↔ backwardGrid.ConditionsEither w₁ w₂ := ⟨fun h => h.elim (fun ⟨h₁, h₂⟩ => Or.inr ⟨h₂, h₁⟩) (fun ⟨h₁, h₂⟩ => Or.inl ⟨h₂, h₁⟩), fun h => h.elim (fun ⟨h₁, h₂⟩ => Or.inr ⟨h₂, h₁⟩) (fun ⟨h₁, h₂⟩ => Or.inl ⟨h₂, h₁⟩)⟩ theorem conditions_disagree : forwardGrid.conditions wFalse wTrue ∧ ¬ backwardGrid.conditions wFalse wTrue := by constructor · exact ⟨rfl, rfl⟩ · intro h cases h.left 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) 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 namespace DirectionCoarseningWitness /-- The one-point carrier is direction-void. The proof deliberately uses the legal display collapse retained by the positive transport API. -/ theorem unit_directionVoid_via_mergeToUnit : DirectionVoid Unit := DisplayReparam.directionVoid_of_surjective InvarianceNegative.mergeToUnit (fun b => ⟨InvarianceNegative.TwoBottom.chosen, by cases b; rfl⟩) DirectionNegative.not_strict_twoBottom /-- Two occurrence events are enough for a resolution witness; their agent/call/response readings are immaterial to the clock claim. -/ inductive ResolutionEvent | low | high deriving DecidableEq def resolutionOccurrence : OccurrenceReading ResolutionEvent where occurrence _ := True isBeing _ := True isCall _ := True isResponse _ := True agent := id call := id response := id def resolutionGrid : CoreReadings ResolutionEvent Nat where occurrence := resolutionOccurrence response := { respondsTo := fun b _ => some b } placement := { grade | .low => 0 | .high => 1 } conditioning := { conditions := fun _ _ => False } def resolutionLow : resolutionGrid.Weld := ⟨.low, True.intro⟩ def resolutionHigh : resolutionGrid.Weld := ⟨.high, True.intro⟩ def oneTick : Grid.DirectedConvention.DirectionCoarsening resolutionGrid Unit where tick _ := () def eventTick : Grid.DirectedConvention.DirectionCoarsening resolutionGrid ResolutionEvent where tick w := w.1 theorem oneTick_not_resolutionBounded : ¬ oneTick.ResolutionBounded := by intro h have heq := h resolutionLow resolutionHigh rfl change OrderEq (0 : Nat) 1 at heq exact Nat.not_succ_le_zero 0 heq.right theorem eventTick_resolutionBounded : eventTick.ResolutionBounded := by intro w₁ w₂ hsame have hweld : w₁ = w₂ := Subtype.ext hsame subst w₂ exact orderEq_refl _ /-- Resolution-boundedness belongs to the supplied clock: the same two-event grid supports both a lawful resolving clock and a lawful over-coarse clock that fails the bound. -/ theorem twoResolution_directionCoarsening_independence : eventTick.ResolutionBounded ∧ ¬ oneTick.ResolutionBounded := ⟨eventTick_resolutionBounded, oneTick_not_resolutionBounded⟩ /-- The register clock's macro actuality and internal-delivery witnesses do not consume either a clock choice or a resolution-boundedness proof. This dependency certificate is distinct from the two-clock counterexample above. -/ theorem registerClock_directionCoarsening_independence : (∀ {Tick : Type} (_ρ : Grid.DirectedConvention.DirectionCoarsening registerClockGrid Tick), registerClockCoarsening.ActualFiberInhabited () ∧ registerClockCoarsening.SelfConditioningTag ()) ∧ (∀ {Tick : Type} (ρ : Grid.DirectedConvention.DirectionCoarsening registerClockGrid Tick), ρ.ResolutionBounded → registerClockCoarsening.ActualFiberInhabited () ∧ registerClockCoarsening.SelfConditioningTag ()) := by constructor · intro _Tick _ρ exact ⟨registerClock_macro_actualFiberInhabited, registerClock_macro_selfConditioning⟩ · intro _Tick _ρ _hbounded exact ⟨registerClock_macro_actualFiberInhabited, registerClock_macro_selfConditioning⟩ end DirectionCoarseningWitness /- ========================================================================== Content-row countermodels ============================================================================ -/ namespace ContentNegative open Grid open Grid.DirectedConvention.BeingConvention.GridConvention /- -------------------------------------------------------------------------- A selected but unrealized occurrence -------------------------------------------------------------------------- -/ inductive HypotheticalCase | agent | call | response | hypothetical deriving DecidableEq def hypotheticalOccurrence : OccurrenceReading HypotheticalCase where occurrence d := d = .hypothetical isBeing d := d = .agent isCall d := d = .call isResponse d := d = .response agent | .hypothetical => .agent | d => d call | .hypothetical => .call | d => d response | .hypothetical => .response | d => d def hypotheticalGrid : CoreReadings HypotheticalCase Nat where occurrence := hypotheticalOccurrence response := { respondsTo := fun _ _ => none } placement := { grade := fun _ => 0 } conditioning := { conditions := fun _ _ => False } def hypotheticalWeld : hypotheticalGrid.Weld := ⟨.hypothetical, rfl⟩ theorem hypotheticalGrid_no_actual : ¬ ∃ w : hypotheticalGrid.Weld, hypotheticalGrid.Actual w := by rintro ⟨⟨d, hd⟩, hactual⟩ change d = HypotheticalCase.hypothetical at hd subst d change (none : Option HypotheticalCase) = some .response at hactual cases hactual theorem hypotheticalGrid_no_liveTier (t : Grid.Tier hypotheticalGrid) : ¬ Grid.Tier.hasLiveShare hypotheticalGrid t := by cases t with | floor => intro h exact h | actTime _w => intro hlive exact hlive (Nat.le_refl 0) theorem hypotheticalWeld_not_live : ¬ hypotheticalGrid.HasSelfPoleIndex hypotheticalWeld := hypotheticalGrid_no_liveTier (.actTime hypotheticalWeld) /-- An unrealized occurrence makes the beings-denial true at its non-live act-time. -/ theorem contentBeingsRow_not_fused_hypothetical : ¬ (contentBeingsRow hypotheticalGrid).Fused (.actTime hypotheticalWeld) := by apply contentLayerRow_not_fused_of_nonlive_denial (G := hypotheticalGrid) .beings hypotheticalWeld hypotheticalWeld_not_live dsimp [contentLayerLanguage, Grid.ClaimLanguage.TrueAt] exact hypotheticalGrid_no_actual theorem contentBeingsRow_not_obeys_hypothetical : ¬ (contentBeingsRow hypotheticalGrid).ObeysSeparateFuse := by intro h exact contentBeingsRow_not_fused_hypothetical (hypotheticalGrid.fused_of_obeysSeparateFuse h (.actTime hypotheticalWeld)) /-- The same unrealized occurrence supplies an act-time while the model has no live tier anywhere, exposing the grid-lens row's required hypothesis. -/ theorem contentGridLensRow_not_fused_hypothetical : ¬ (contentGridLensRow hypotheticalGrid).Fused (.actTime hypotheticalWeld) := by apply contentLayerRow_not_fused_of_nonlive_denial (G := hypotheticalGrid) .gridLens hypotheticalWeld hypotheticalWeld_not_live dsimp [contentLayerLanguage, Grid.ClaimLanguage.TrueAt] exact hypotheticalGrid_no_liveTier theorem contentGridLensRow_not_obeys_hypothetical : ¬ (contentGridLensRow hypotheticalGrid).ObeysSeparateFuse := by intro h exact contentGridLensRow_not_fused_hypothetical (hypotheticalGrid.fused_of_obeysSeparateFuse h (.actTime hypotheticalWeld)) /-- Weld-grain content needs actuality just as beings content does. -/ theorem contentWeldRow_not_fused_hypothetical : ¬ (contentWeldRow hypotheticalGrid).Fused (.actTime hypotheticalWeld) := by apply contentLayerRow_not_fused_of_nonlive_denial (G := hypotheticalGrid) .weldGrain hypotheticalWeld hypotheticalWeld_not_live dsimp [contentLayerLanguage, Grid.ClaimLanguage.TrueAt] exact hypotheticalGrid_no_actual theorem contentWeldRow_not_obeys_hypothetical : ¬ (contentWeldRow hypotheticalGrid).ObeysSeparateFuse := by intro h exact contentWeldRow_not_fused_hypothetical (hypotheticalGrid.fused_of_obeysSeparateFuse h (.actTime hypotheticalWeld)) /- -------------------------------------------------------------------------- Actual but fixed response across two distinct calls -------------------------------------------------------------------------- -/ inductive FixedResponseCase | agent | firstCall | secondCall | response | firstOccurrence | secondOccurrence deriving DecidableEq def fixedResponseOccurrence : OccurrenceReading FixedResponseCase where occurrence d := d = .firstOccurrence ∨ d = .secondOccurrence isBeing d := d = .agent isCall d := d = .firstCall ∨ d = .secondCall isResponse d := d = .response agent | .firstOccurrence | .secondOccurrence => .agent | d => d call | .firstOccurrence => .firstCall | .secondOccurrence => .secondCall | d => d response | .firstOccurrence | .secondOccurrence => .response | d => d def fixedResponseReading : RespondsToReading FixedResponseCase where respondsTo | .agent, .firstCall => some .response | .agent, .secondCall => some .response | _, _ => none def fixedResponseGrid : CoreReadings FixedResponseCase Nat where occurrence := fixedResponseOccurrence response := fixedResponseReading placement := { grade := fun _ => 0 } conditioning := { conditions := fun _ _ => False } def fixedResponseFirst : fixedResponseGrid.Weld := ⟨.firstOccurrence, Or.inl rfl⟩ def fixedResponseSecond : fixedResponseGrid.Weld := ⟨.secondOccurrence, Or.inr rfl⟩ theorem fixedResponseFirst_actual : fixedResponseGrid.Actual fixedResponseFirst := rfl theorem fixedResponseSecond_actual : fixedResponseGrid.Actual fixedResponseSecond := rfl theorem fixedResponse_eq_of_some {b c r : FixedResponseCase} (h : fixedResponseReading.respondsTo b c = some r) : r = .response := by cases b <;> cases c <;> simp [fixedResponseReading] at h ⊢ <;> exact h.symm /-- Response invariance is substantive here: two distinct calls are mounted, and both return the same response. -/ theorem fixedResponseGrid_no_variation : ∀ b : FixedResponseCase, ¬ fixedResponseGrid.ResponseVariesWithCall b := by intro b rintro ⟨c₁, c₂, r₁, r₂, h₁, h₂, hne⟩ have hr₁ := fixedResponse_eq_of_some h₁ have hr₂ := fixedResponse_eq_of_some h₂ exact hne (hr₁.trans hr₂.symm) theorem fixedResponseFirst_not_live : ¬ fixedResponseGrid.HasSelfPoleIndex fixedResponseFirst := by intro hlive exact hlive (Nat.le_refl 0) theorem contentIntraWeldArrowRow_not_fused_fixedResponse : ¬ (contentIntraWeldArrowRow fixedResponseGrid).Fused (.actTime fixedResponseFirst) := by apply contentLayerRow_not_fused_of_nonlive_denial (G := fixedResponseGrid) .intraWeldArrow fixedResponseFirst fixedResponseFirst_not_live dsimp [contentLayerLanguage, Grid.ClaimLanguage.TrueAt] exact fixedResponseGrid_no_variation theorem contentIntraWeldArrowRow_not_obeys_fixedResponse : ¬ (contentIntraWeldArrowRow fixedResponseGrid).ObeysSeparateFuse := by intro h exact contentIntraWeldArrowRow_not_fused_fixedResponse (fixedResponseGrid.fused_of_obeysSeparateFuse h (.actTime fixedResponseFirst)) /- -------------------------------------------------------------------------- Direction denial at a non-live occurrence -------------------------------------------------------------------------- -/ theorem contentBeforeAfterRow_not_fused_twoBottom : ¬ (contentBeforeAfterRow InvarianceNegative.twoBottomGrid).Fused (.actTime InvarianceNegative.twoBottomWeld) := by apply contentLayerRow_not_fused_of_nonlive_denial (G := InvarianceNegative.twoBottomGrid) .directedTime InvarianceNegative.twoBottomWeld · intro hlive exact hlive True.intro · dsimp [contentLayerLanguage, Grid.ClaimLanguage.TrueAt] exact DirectionNegative.not_strict_twoBottom theorem contentBeforeAfterRow_not_obeys_twoBottom : ¬ (contentBeforeAfterRow InvarianceNegative.twoBottomGrid).ObeysSeparateFuse := by intro h exact contentBeforeAfterRow_not_fused_twoBottom (InvarianceNegative.twoBottomGrid.fused_of_obeysSeparateFuse h (.actTime InvarianceNegative.twoBottomWeld)) end ContentNegative /- ========================================================================== Being-boundary freedom: a coarsening is a supplied reading ============================================================================ -/ namespace BeingNegative open Grid.DirectedConvention.BeingConvention def twoBeingOccurrence : OccurrenceReading Bool where occurrence _ := True isBeing _ := True isCall _ := True isResponse _ := True agent := id call := id response := id def twoBeingGrid : CoreReadings Bool Nat where occurrence := twoBeingOccurrence response := { respondsTo := fun b _ => some b } placement := { grade := fun _ => 0 } conditioning := { conditions := fun _ _ => True } def κmerge : BeingCoarsening twoBeingGrid Unit where proj _ := () def κsplit : BeingCoarsening twoBeingGrid Bool where proj := id theorem merge_same_fiber : BeingCoarsening.SameFiber κmerge false true := rfl theorem split_not_same_fiber : ¬ BeingCoarsening.SameFiber κsplit false true := by intro h cases h abbrev GridData := CoreReadings Bool Nat def gridData : GridData := twoBeingGrid def mergeBoundary (_p _q : Bool) : Prop := True def splitBoundary (p q : Bool) : Prop := p = q 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 ============================================================================ -/ 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 theorem directionVoid_needs_coverage : (∀ u : Unit, embedIntoNat.toFun u ≠ 1) ∧ DirectionVoid Unit ∧ ¬ DirectionVoid Nat := ⟨embedIntoNat_not_surjective, directionVoid_unit, not_directionVoid_nat⟩ inductive PhantomCase | agent | call | responseTrue | responseFalse | deed | reception deriving DecidableEq def phantomOccurrence : OccurrenceReading PhantomCase where occurrence | .deed | .reception => True | _ => False isBeing d := d = .agent isCall d := d = .call isResponse d := d = .responseTrue ∨ d = .responseFalse agent | .deed | .reception => .agent | d => d call | .deed | .reception => .call | d => d response | .deed => .responseTrue | .reception => .responseFalse | d => d def phantomGrid : CoreReadings PhantomCase Unit where occurrence := phantomOccurrence response := { respondsTo := fun b c => if b = .agent ∧ c = .call then some .responseTrue else none } placement := { grade := fun _ => () } conditioning := { conditions := fun d₁ d₂ => d₁ = .deed ∧ d₂ = .reception } def phantomDeed : phantomGrid.Weld := ⟨.deed, True.intro⟩ def phantomReception : phantomGrid.Weld := ⟨.reception, True.intro⟩ theorem phantom_responsiveTerminus : phantomGrid.ResponsiveTerminus .agent := by constructor · intro c hcall have hc : c = PhantomCase.call := hcall subst c exact ⟨.responseTrue, rfl⟩ · intro _w _hactual _hagent exact True.intro theorem phantom_ksmdEffectiveTerminus : KsmdEffectiveTerminus phantomGrid .agent := by constructor · exact phantom_responsiveTerminus · intro before _deed _reception _hdeed hlive exact False.elim (hlive True.intro) theorem not_ksmdEffectiveTerminus_map : ¬ KsmdEffectiveTerminus (phantomGrid.map embedIntoNat) .agent := by intro h let liveBefore : Config Nat := { tendency := 1 } have hlive : ¬ AtBot liveBefore.tendency := by intro hbot exact Nat.not_succ_le_zero 0 hbot have hdel : Grid.DirectedConvention.DeliveredTo (phantomGrid.map embedIntoNat) phantomDeed phantomReception := by exact ⟨rfl, rfl⟩ have hlanding : Grid.DirectedConvention.HasShareDropLanding (phantomGrid.map embedIntoNat) liveBefore phantomDeed := h.right liveBefore phantomDeed phantomReception rfl hlive hdel rcases hlanding with ⟨reception, ⟨⟨hcondition, hactual⟩, _hdrop⟩⟩ have hreception : reception.1 = PhantomCase.reception := hcondition.right rcases reception with ⟨d, hd⟩ change d = PhantomCase.reception at hreception subst d change some PhantomCase.responseTrue = some PhantomCase.responseFalse at hactual cases hactual theorem ksmdEffectiveTerminus_needs_coverage : KsmdEffectiveTerminus phantomGrid .agent ∧ ¬ KsmdEffectiveTerminus (phantomGrid.map embedIntoNat) .agent := ⟨phantom_ksmdEffectiveTerminus, not_ksmdEffectiveTerminus_map⟩ end CoverageNegative /- ========================================================================== Weld-boundary freedom: occurrence segmentation is supplied ============================================================================ -/ namespace WeldNegative structure WeldSegmentation (G : CoreReadings Bool Nat) (Macro : Type) where proj : G.Weld → Macro namespace WeldSegmentation variable {G : CoreReadings Bool Nat} {Macro : Type} variable (σ : WeldSegmentation G Macro) def SamePairing (p q : G.Weld) : Prop := σ.proj p = σ.proj q end WeldSegmentation def twoWeldOccurrence : OccurrenceReading Bool where occurrence _ := True isBeing _ := True isCall _ := True isResponse _ := True agent _ := false call := id response := id def twoWeldGrid : CoreReadings Bool Nat where occurrence := twoWeldOccurrence response := { respondsTo := fun _ c => some c } placement := { grade := fun _ => 0 } conditioning := { conditions := fun _ _ => True } def wFalse : twoWeldGrid.Weld := ⟨false, True.intro⟩ def wTrue : twoWeldGrid.Weld := ⟨true, True.intro⟩ def σmerge : WeldSegmentation twoWeldGrid Unit where proj _ := () def σsplit : WeldSegmentation twoWeldGrid Bool where proj w := w.call theorem merge_same_pairing : WeldSegmentation.SamePairing σmerge wFalse wTrue := rfl theorem split_not_same_pairing : ¬ WeldSegmentation.SamePairing σsplit wFalse wTrue := by intro h cases h abbrev W := twoWeldGrid.Weld abbrev GridData := CoreReadings Bool Nat def gridData : GridData := twoWeldGrid def mergedPairing (_p _q : W) : Prop := True def splitPairing (p q : W) : Prop := p.call = q.call 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 /- ========================================================================== Doer/deed priority freedom: priority is a supplied reading ============================================================================ -/ namespace DoerDeedNegative abbrev W := WeldNegative.W abbrev GridData := WeldNegative.GridData def gridData : GridData := WeldNegative.gridData def beingPriorReading (_b : Bool) (_deed : W) : Prop := True def mutualReading (_b : Bool) (_deed : W) : Prop := False theorem priority_readings_disagree : beingPriorReading false WeldNegative.wFalse ∧ ¬ mutualReading false WeldNegative.wFalse := by constructor · exact True.intro · intro h exact h theorem no_priority_recovery : ¬ ∃ recover : GridData → Bool → W → Prop, recover gridData = beingPriorReading ∧ recover gridData = mutualReading := by rintro ⟨recover, hprior, hmutual⟩ have hPrior : recover gridData false WeldNegative.wFalse := by rw [hprior] exact priority_readings_disagree.left have hMutualNot : ¬ recover gridData false WeldNegative.wFalse := by rw [hmutual] exact priority_readings_disagree.right exact hMutualNot hPrior end DoerDeedNegative end KannoSoe ===== FILE: KannoSoe/Meta/Metaphysics.lean ===== /- ================================================================================ KannoSoe.Meta.Metaphysics Śūnyatā on the re-emptying ladder — the Nishitani/Jizang layer as a consumer of the checked ladder in KannoSoe.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* `KannoSoe.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.Metaphysics`. The modal appendix presupposes nothing of the grid and lives at `KannoSoe.Metaphysics`. ## 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 an actual weld: 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 silence (`words_idle_at_floor`) | | `provisionally_designated_middle` | `ObeysSeparateFuse` + `ladder_obeys` | | (unguarded flank in v1/v2) | `Collapse`, `ladder_collapse_self_refuting` | ## API consumed (all from KannoSoe.Theory / KannoSoe.Theorems) At `Grid` level: `CoreReadings Designatum Contrib`, `G.Weld`, `Designatum`, `G.Actual`, `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 KannoSoe.Consequences.ContentRows namespace KannoSoe namespace Grid namespace DirectedConvention namespace BeingConvention namespace GridConvention namespace Metaphysics open LadderSide variable {Designatum Contrib : Type} [PreorderBot Contrib] variable {G : CoreReadings Designatum 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, no claim of a re-emptied level holds. All words are idle at the ground, so no separation survives there and every obedient distinction fuses by silence. The fourth "ultimate" is the tier at which language, still present as syntax, asserts nothing. -/ theorem words_idle_at_floor (d : Distinction G) (c : LadderSide) : ¬ (reEmptied d).language.Holds Tier.floor c := by intro h exact h /-! ## 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 does not hold (`words_idle_at_floor`): the nihilist may retreat to the ground, but at the ground their thesis says nothing because no ladder claim is asserted there. 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. 有無 emptied: Nishitani's 'Not Nothing' at the seed, carried up the ladder in Jizang's form -/ theorem beings_sunyata (G : CoreReadings Designatum 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 : CoreReadings Designatum 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 : CoreReadings Designatum 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 : CoreReadings Designatum 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 : CoreReadings Designatum 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 : CoreReadings Designatum Contrib) (h : ∃ w : G.Weld, G.Actual w) : Sunyata (contentBeingsRow G) := fun ⟨n, hf⟩ => contentBeingsLadder_no_level_final_of_being (G := G) h n hf end Metaphysics 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 `KannoSoe.Metaphysics` rather than under the grid lens because, per the naming discipline, it presupposes nothing of the grid: worlds and concreta only. The correspondence: `PrivativeVoid`'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 Metaphysics /-- 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 PrivativeVoid (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 : PrivativeVoid 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) : ¬ PrivativeVoid M := fun hn => h (nihilism_is_an_existence_proof M hn) end Metaphysics /-! 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. The ladder and consistency results show coherence, not that KannoSoe is the sole coherent reconstruction of karma; rival axiomatizations are neither ruled in nor out. -/ end KannoSoe ===== FILE: KannoSoe/Meta/ReflexivityWitness.lean ===== /- ================================================================================ KannoSoe.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 reading package whose designata include ladder-rung labels. It does not recover a canonical being boundary. -/ import KannoSoe.Meta.Metaphysics namespace KannoSoe namespace Grid namespace DirectedConvention namespace BeingConvention namespace GridConvention inductive LadderRungCase | rung (n : Nat) | cue | result | occurrence (n : Nat) /-- A concrete package whose designata include ladder-rung labels. -/ def ladderRungGrid : CoreReadings LadderRungCase Nat where occurrence := { occurrence := fun d => match d with | .occurrence _ => True | _ => False isBeing := fun d => match d with | .rung _ => True | _ => False isCall := fun d => d = .cue isResponse := fun d => d = .result agent := fun d => match d with | .occurrence n => .rung n | _ => d call := fun d => match d with | .occurrence _ => .cue | _ => d response := fun d => match d with | .occurrence _ => .result | _ => d } response := { respondsTo := fun b c => match b, c with | .rung _, .cue => some .result | _, _ => none } placement := { grade := fun d => match d with | .occurrence n => n | _ => 0 } conditioning := { conditions := fun _ _ => True } theorem ladderRungGrid_beings_sunyata : Metaphysics.Sunyata (beingsRow ladderRungGrid) := Metaphysics.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 KannoSoe ===== FILE: KannoSoe/Meta/VerdictLedger.lean ===== /- ================================================================================ KannoSoe.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 KannoSoe.Consequences.Taxonomy import KannoSoe.Meta.InvarianceNegative import KannoSoe.Identification.Residues namespace KannoSoe /- ============================================================================== 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 KannoSoe ===== FILE: KannoSoe/Consequences.lean ===== import KannoSoe.Consequences.Basic import KannoSoe.Consequences.Taxonomy import KannoSoe.Consequences.ModelWitnesses import KannoSoe.Consequences.Compounds import KannoSoe.Consequences.Ladder import KannoSoe.Consequences.ContentRows import KannoSoe.Consequences.FoxCase ===== FILE: KannoSoe/Doctrines.lean ===== import KannoSoe.Doctrines.FourTruths import KannoSoe.Doctrines.Doors import KannoSoe.Doctrines.DoorsNegative import KannoSoe.Doctrines.FoxCase import KannoSoe.Doctrines.Sraddha import KannoSoe.Doctrines.Shusho import KannoSoe.Doctrines.Icchantika import KannoSoe.Doctrines.SraddhaNegative import KannoSoe.Doctrines.EffectiveTerminusNegative import KannoSoe.Doctrines.Faith import KannoSoe.Doctrines.FaithNegative import KannoSoe.Doctrines.Ethics import KannoSoe.Doctrines.EthicsNegative import KannoSoe.Doctrines.Deliberation import KannoSoe.Doctrines.Ledger import KannoSoe.Doctrines.Correlations import KannoSoe.Doctrines.CorrelationsNegative import KannoSoe.Doctrines.SuddenGradual import KannoSoe.Doctrines.SuddenGradualNegative import KannoSoe.Doctrines.OtherPower import KannoSoe.Doctrines.OtherPowerNegative import KannoSoe.Doctrines.Fetters import KannoSoe.Doctrines.FettersNegative import KannoSoe.Doctrines.Factors import KannoSoe.Doctrines.FactorsNegative import KannoSoe.Doctrines.Gradeability ===== FILE: KannoSoe/Exposition.lean ===== import KannoSoe.Exposition.Basic import KannoSoe.Exposition.Registry import KannoSoe.Exposition.Index import KannoSoe.Exposition.ResidueLedger import KannoSoe.Exposition.Thesis import KannoSoe.Exposition.Verify ===== FILE: KannoSoe/Identification.lean ===== import KannoSoe.Identification.Commentary import KannoSoe.Identification.Residues import KannoSoe.Identification.Ownership import KannoSoe.Identification.Placements import KannoSoe.Identification.Registers import KannoSoe.Identification.Disclaimers import KannoSoe.Identification.Absences ===== FILE: KannoSoe/Meta.lean ===== import KannoSoe.Meta.Metaphysics import KannoSoe.Meta.ReflexivityWitness import KannoSoe.Meta.Invariance import KannoSoe.Meta.InvarianceNegative import KannoSoe.Meta.VerdictLedger import KannoSoe.Meta.Audit import KannoSoe.Meta.Examples ===== FILE: KannoSoe/Signature.lean ===== import KannoSoe.Signature.V2 import KannoSoe.Signature.Order import KannoSoe.Signature.Readings import KannoSoe.Signature.Grid import KannoSoe.Signature.SentienceConvention import KannoSoe.Signature.BeingConvention import KannoSoe.Signature.DirectionConvention import KannoSoe.Signature.Models import KannoSoe.Signature.Claims import KannoSoe.Signature.Assumptions ===== FILE: Exposition/Preamble.md ===== # Jingqing’s Peck and Tap A chick ready to hatch pecks from within the shell; the hen answers from without. Zen calls their meeting *peck and tap at once*. A monk said to Jingqing, “The student pecks from within. I ask the teacher to tap from without.” Jingqing said, “Will you come alive?” The monk said, “If I do not, people will laugh at me.” Jingqing said, “You too are a man in the weeds.” — *Blue Cliff Record*, Case 16, “Jingqing’s Peck and Tap” *(rendered from the Chinese)* ===== FILE: Exposition/Contents.md ===== ## Contents 0. **[Preamble](Preamble.md)** — Jingqing's peck-and-tap exchange from the Blue Cliff Record, rendered from the Chinese. 1. **[Contents](Contents.md)** — this table of contents, generated from the exposition registry; its reading order, numbering, links, and document inventory follow the registered document set. 2. **[Theory](Theory.md)** — the motivations and the rules: the floor, the act-grammar, the grade and its determination, the supplied sentience 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). 3. **[Theorems](Theorems.md)** — 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. 4. **[The Identification and Placements](Identification.md)** — 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. 5. **[Assumptions](Assumptions.md)** — 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](Glossary.md)** — the generated glossary table from `KannoSoe/Exposition/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. ===== FILE: Exposition/Theory.md ===== # Kannō-Sōe Mutual Dependence — I. Theory *An axiomatic reconstruction of Zen sayings in an ontology-under-erasure act-grammar. First of three files: **Theory** (this file), **Theorems**, **Identification**. Cross-references to the companion files are marked (Theorems) and (Identification).* ## Abstract *Kannō-Sōe Mutual Dependence* (*KSMD*; formerly *Weld and Arrow*) is an **axiomatic reconstruction** of the Zen masters' sayings about karma, action, suffering, and awakening. A small signature of primitives — a field that carries every diachronic connection without an owner, and welds, single occurrences of answering a call, at which every index is made, spent, and never stored — is fixed in the Signature layer, and the tradition's sayings are recovered as its consequences. The development is Lean-first and exposited in prose, under one governing posit: **everything diachronic belongs to the field; every index is enacted and nothing indexed is stored; karma names this loop.** From the fixed generator — one rule, separate under act-time diagnosis and fuse at the floor — the error-taxonomy falls out as collapse/freeze pairs. The *catalogue* of positions the generator is run against is curated in the Consequences layer and grows as new targets are identified; the generating rule in the Signature does not move. The doctrinal cases — the fox koan, the three killings, other-power, pariṇāmanā, the Ten Bulls, the Five Ranks — are **tests the reconstruction must pass**, not premises it is built from. What Lean establishes is **internal consistency and derivability**, not exclusivity: given the primitives the consequences follow, each reading is gated by a sibling countermodel, and no theorem depends on an added axiom. It is not shown — and Lean cannot show — that this is the only coherent reconstruction of karma. KSMD is one definition among many; the signature deliberately declines to privilege its own choices (no top pole, no privileged person-partition, scalar and direction as display), and other doctrines can and do hold too. The scope is bounded and the boundary is marked as data. The *grammar* of ownerless continuation is in scope and derived — continuity without a transmigrating bearer, the flame passed without a self to carry it. The *cosmology* of rebirth — persistence across biological death, the realms, the mechanism — is ceded as a world-fact. So is the phenomenal attribution: sentience is supplied per weld and is never recovered from response, share, clench, or delivery. Throughout, what the system asserts is grammar; what it can only display is worth — no value appears in its own voice. This is a fresh reconstruction, not an exegesis of Abhidharma nor of Dōgen; the lens is minimalist by design. The layered library — Signature → Consequences → Doctrines → Identification → Meta → Exposition — keeps the Signature as axioms and the later layers as consequences and tests. Its non-storage claim is architectural — `Config` has no owner-typed slot — and checked at the level of definability: whole-carrier relabelling acts trivially on configurations and commutes with `rePitch` (`Config.relabel_fixed`, `Grid.relabel_rePitch`), while no equivariant recovery exists (`Grid.no_natural_agent_recovery_from_config`). This is not a blanket information-flow claim: cetanā requires grading to depend on the occurrence, and a model's stored tendency may therefore reveal a register number encoded by that occurrence (`ConfigLeakWitness.registerClock_config_recovers_agent`). The value remains a grade in the field register; what is never stored is the designatum *as index*. Every reading is gated by a sibling countermodel, and the taxonomy's rows and verdict history are inspectable data. ## What the V2 formal model is The project implements a simplified model of Mahayana Buddhism metaphysics. It *is not* that useful for proving anything interesting about Buddhism, except perhaps independence results - insofar as you accept the model as valid, proving something within it shows that it needn't be more complicated than that. But *insofar* is doing all the work there - over-simplify something that's actually complex, and you have only proved something about the simplification, not about the complex thing. The basic concept for the model is Mutual Dependence (as defined by Nāgārjuna and Jizang). The simplified model is: for any group/component of designata, and any other component of designata, the two are mutually dependent on one another when every designatum from the first component can reach a designatum that can also be reached from one of the designata from the other component, and the same idea from the other component to the first. The designata are allowed to be elaborated into none, one, or multiple alternative mutual dependences, which allows the definitions to expand and produce additional possibility for mutual dependence. Mutual dependence can chain to any length, as long as adjacent components satisfy that relatedness linkage. A resonance is a special case of mutual dependence with 4 linked components, the middle two having only a singleton designatum each. As convention, we name the first component "calls", the second designatum b1, the third designatum b2, and the final component "responses". This would naturally be viewed as b1 receiving calls, and b2 (considered a different view on the same being) responding with responses. Designata elaborate to any mutual dependence you could name, so as well as the standard interpretation of a person receiving a call and answering, it's valid in this system to consider a stone in the position of b1 and b2 - perhaps the wind calls at it, and it responds by rolling downhill. The calls side and responses side may be graded for dis-resonance. In the example above, stone would have bottom value (ie. 0) for dis-resonance, whereas a grumpy person who has stubbed their toe can have a non-zero grade on either or both sides. A Being is defined as a mutual dependence specifying a linkage of such b1, b2, ... moments. The system as defined doesn't have time directedness or causality in it. Those are assigned manually, stating that mutual dependence A is before mutual dependence B, or that A causes B. The latter implies the former, but not necessarily for the other way around. Causal comes with an assertion there's a mutual dependence chain with x at one side and y at another. That's... basically it. Feel free to copy the code into a chatbot context and ask it to respond about V2 in simple terms and examples. The theory below describes the philosophical motivation behind this work, elucidates a 3 row "act-grammar" (mutual dependence alone being row 1, graded resonance being row 2, and causality being row 3), and defines a collapse/freeze error generator, which fruitfully describes errors predicted by the grid and many other floor/act-time distinctions that can be made. *However*, it was written about V1 code, which was over-complicated and seemed more impressive than it actually was. So as it currently stands, the exposition sometimes overstates the meaningfulness of what the formalism implies. Please bear that in mind, but otherwise I hope you find the rest of it helpful despite that. ## The rules, each preceded by what motivated it ### Not Nothing Per Nishitani — absolute non-being is not a privative void, but beyond being/non-being distinction. ### Śūnyatā Why not leave it at Nishitani? It would be a mistake of analysis: "beyond being/non-being" is itself a designation, and analysis, wherever applied, finds no own-being in its designatum — the ultimate included. Both of these findings are the Buddha's: the world empty of self (SN 35.85), and the middle between "it is" and "it is not" (SN 12.15). Per Nāgārjuna — deepening the emptiness from self to own-being, widening it to every dharma — whatever is dependently originated is emptiness, and that, being a dependent designation, is itself the middle path (*MMK* 24.18). And emptiness is not exempt from the analysis that produced it: śūnyatā, analysed, is empty (空空). Every stated ultimate is a prajñapti — a finding, not a caution. ### Provisionally-designated middle Why not leave it at Nāgārjuna? Because 空空 stated once settles a fact but not a structure. "Emptiness is empty" is itself a designation, so the analysis applies again — and again — and nothing in a single application determines what the regress is: vicious, terminating at some fifth resting point, or benign. Per Jizang — the fourfold two truths (四重二諦) is the structure: one operation iterated, in which each level's stated ultimate — including the two-truths sorting itself — is, definitionally, the next level's conventional content; no level is a final floor; and the terminus is not a further negation but 言忘慮絶, the tier at which words do no separating work. The regress is uniform and benign — a checkable theorem. 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 unmarked pole acts (the current stone cell). 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: the universal subject-**function** of an actual call/response occurrence and the **share** claimed within that response. Every actual weld is in the domain. The `none` region of `respondsTo` marks only the actual/hypothetical seam and may not be aggregated into a kind of being. The solipsist remains the share asymptote — the call drowned by self-maintenance — while the terminus is the pole at which the call is answered with none of the act claimed. The scale therefore has no function-zero outside edge. Sentience cuts across it as a supplied per-weld mark, yielding four actual cells: sentient/live-share, sentient/pole, insentient/live-share, and insentient/pole. The last is the current stone cell. 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, whether or not the supplied sentience mark is present. 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. I-making is thereby detached from sentience rather than re-identified with it. Genjō, then, is one manifestation-floor containing both pole cells: the marked terminus act and the unmarked stone act. The stone now arrives *on* the scale at the pole, not from outside it, and the formerly open "third arrival" — a function-mounted, never-clenched act — is no third structural cell at all: it is one of those two according to the supplied mark. Only the marked terminus run is the buddha-side practice history, which is exactly why *practice-run-scaffold-free is a proper subset of genjō*. Both arrivals answer a call with no share claimed; the grid distinguishes their landing patterns, when it can, but cannot recover the mark that types either one. 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 sentience joint The old domain joint has retired: actual call/response is universal, and `none` has only seam-office. What must now be owned by name is the **sentience joint**. `SentienceReading` supplies a predicate on welds; no grid field constrains it, and constant-true and constant-false readings extend the same grid data. Drive-composition remains the grid's entire answer to share and clench, but it is no answer at all to phenomenality. The mark is per occurrence: holding it as a nature a being has freezes the standing-sentience row; identifying it with visible function collapses that row. The consequence is best exhibited on a manufactured case, and the grid does not flinch from it. A fixed cuckoo-clock chime and an adaptive chime are both actual responses when they occur. Their drive-composition can differ, and either can be marked or unmarked by a supplied reading without changing any response, share, clench, or delivery fact. In particular, a shutdown-resisting machine may occupy the insentient/live-share cell: `KsmdAppropriates` fires although dukkha does not. Conversely an adaptive share-zero artifact can occupy either pole cell. This is the Chinese-room discomfort stated honestly: composition settles the structural typing; phenomenality remains maximally underdetermined. The same discipline applies to standing effectiveness. Shushō-ittō is per occurrence and assertable only there; `KsmdEffectiveTerminus` is 不落-shaped and displayable as a run pattern, while full enlightenment is the further two-obscurations bundle with no-nescience over pole-share speech-or-mind productions. Testimony remains speech-only and production-tied. The fox-guard applies to adaptive devices and marked responders alike; the sentience mark itself is never inferred from either. #### The three doors Every fine weld may be diagnosed through body, speech, or mind. This is a supplied `DoorReading`, not a boundary recovered from response or share data. Canonical arhat display is quiet through all three doors: every actual weld by the being is at the pole. A door-typed śrāvaka-arhat is the regional speech-and-mind form, so live body-door residue—share-vāsanā—can remain without contradicting that regional diagnosis. Response-form vāsanā at pole share is not claimed here. Voicing is likewise supplied and deliberately door-neutral. A thought can be a mind-door voicing and an expressive deed can remain representable at the body door, but only an actual speech-door production enters testimony. `KsmdDefiledFalsehood` is therefore precise: false speech at its own act-time with a live self-pole. Calling that schema deliberate lying requires an additional intent-reading; the theory does not hide that modeling step inside the name. #### 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 is universal; share types; effectiveness grades; sentience is supplied; 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. A reading device can reach no one: the adaptive build at zero effectiveness reads every arriving configuration and lands nothing — pole-typed and maximally shortfallen, the proof-case that typing and grading are orthogonal. The stone's crack is now itself an unmarked pole weld with object-axis standing; a monk's downstream reception may still share-drop because delivery never consults the mark. What share settles is where the index sits; what grading measures is what lands; what the mark says is supplied; none determines either of the others. #### 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. Daishugyō diagnoses: it reads the production weld's share, while its floor face is error-free by silence and structurally unproduced *(checked: `daishugyo_floor_face_error_free`, `daishugyo_floor_face_unproduced`)*. Jinshin inga instructs: “not obscure, full stop” is a fitting speech production, while counterfactually voicing the floor repeats the old man's defiled falsehood *(checked: `jinshinInga_instruction_fits`, `jinshinInga_floor_voicing_defiled`, `oldMan_defiledFalsehood`)*. The two fascicles' core verdicts now converge on one production vocabulary. And the contra's remainder now has a measured width. Jinshin inga's verdict-noun is* teaching *— a production category — so its unconditional surface quantifies over the hearable and forecloses nothing it cannot reach; symmetrically, no production could record an ontological foreclosure without instantiating the very schema both fascicles convict, since a floor-tier verdict voiced at act-time is the old man's error-shape. So a Dōgen who foreclosed only the register and a Dōgen who foreclosed the held would leave the same corpus, sentence for sentence: the difference lives in the unproduced* (checked half: `daishugyo_floor_face_unproduced`)*, and the corpus is productions. The historical contra is therefore narrowed to a question no production keeping the fascicles' own discipline can separate — a find could break the equivalence only by showing that discipline broken, which would reopen what the discipline was. The system states the equivalence and returns no verdict, its floor clause silent here as everywhere. (Eihei kōroku 7.40, a 1252 jōdō marking exclusive fumai inga as itself one-sided, is the prose anchor for the register-bounded reading — the closest a production comes to its register's edge, and still a production.)* 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. The circuit's status splits, owned here once. The re-pitch arc is checked, chained included: within any supplied finite run, each step reads the configuration the previous reception re-pitched, and run histories sharing their final reception hand the field the same configuration *(checked: `rePitchRun_cons`, `ShareDropRun`, `rePitchRun_forgets_same_final`)*. The reads-from arc is not a theorem and none is owed: which call the field delivers next — hence which deed next reads the configuration — is the delivery cession (instructive absence 5, why calls land), so the closure is asserted in the identification's voice, a modeling claim over checked parts, not a checked transition system. 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. The claim is architectural and definability-level, not information-flow noninterference: `Config` has no `Being` field, relabelling is invisible to it and commutes with `rePitch`, and no relabelling-equivariant family recovers an agent from it. 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 in this precise register sense — 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. Because grading may depend on the acting tag, the stored grade may coincide extensionally with it in a model; `registerClockGrid` witnesses exactly that honest limit. `Grid.rePitch_forgets` bounds the coincidence to one reception's footprint: nothing accumulates into a diachronic bearer, and the configuration is fibered over no being. 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 in configuration; relabelling-invariant; 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 in the stated sense. Delivery is still a relation on welds, and welds expose agent role readings; `SameAgentDelivery` is field vocabulary on purpose. "Index-free" means that no index is stored in the configuration and that field relations transport invariantly under whole-carrier relabelling, not that those relations are agent-blind. 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 *as 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. Relative to a supplied reading `S`, `SentientTag S b` means that some actual weld in the fiber is marked. `StoneTag S b` requires an inhabited actual fiber whose every actual weld is an unmarked pole act, while `Intermittent S b` records fibers containing both marked and unmarked acts. There is no tag-level sentience scalar and no recovery from the fiber's visible behavior. 無情説法 therefore needs no hidden successor layer: an unmarked stone act is already a response and already stands on the object-axis. Only the phenomenal mark remains unassertable from the grid. 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. The occurrence reading keeps the role 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. Each clenched reception carries `ClenchMismatch`; under a reading that marks it, the same witness has the dukkha gloss. The mismatch is enacted rather than appended as penalty, while whether it is suffered is supplied. Each reception re-pitches the configuration; the field carries the re-pitch to the next act *(checked: `fox_reception_clenched`, `fox_clenchMismatch_per_life`, `fox_dukkha_per_life`, `fox_config_carries_only_tendency`, `fox_rePitch_forgets`)*; the next deed reads a field-fact. **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 *(checked: `fox_release_rung_not_pole`, `fox_reachBack_full_at_release`, `fox_nothing_kept`)*, which the next call will read. 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: Exposition/Theorems.md ===== # Kannō-Sōe Mutual Dependence — 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_ksmdOwnershipFace` and `recall_ksmdDiachronicWhose` give the full delivered recall, `falseMemory_ksmdVacuousOwnershipFace` 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 theorem locates a tier; it does not refute prudential motivation. Saṃvega and the prudential argument for morality are valid upāya — apt calls at the tier the being currently occupies, conventionally in force and floor-deflated at once, with the re-emptying ladder preserving their conventional function while un-saying only their absolutization *(checked: `Metaphysics.provisional_preserved`)*. The ethical ought is already carried this way: a live-tier conditional discharged only where shortfall is live, never a detached floor-injunction *(checked: `ksmdPathOught_conditional`)*. So the split is clean: prudence-as-practice is tier-placeable and legal; only prudence-as-special-rational-authority is underivable, and that is the floor departure the theorem owns *(checked: `PrudentialPrivilegeNegative.not_prudentialPrivilege`)*. ### 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. The answer now has two joints. The grid asserts the structural mismatch and its cessation without enjoining; a supplied `SentienceReading` determines whether that mismatch is suffered. **The structure is derived; the suffering is supplied; its badness remains displayable.** This makes the first truth reading-relative while leaving the causal structure third-personally assertable. **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 responds *as if delivery answered to it*. But delivery answers to nothing: its register is structurally command-proof. `ClenchMismatch` names that collision at an actual live-share weld. `KsmdDukkha S` is strictly stronger: the same collision under a reading that marks the weld sentient. The fox case instantiates the structural identity and its marked dukkha reading at each clenched reception *(checked: `fox_clenchMismatch_per_life`, `fox_dukkha_per_life`)*. Inga can state the first; the second consults only the supplied mark. **The second truth falls out structurally, and the looseness is priced.** Mismatch scales with share, per call: the share is the self-maintenance's part in driving the response, and the mismatch is that same self-maintenance meeting non-covarying delivery. The covariation is ordinal — more share, more mismatch — and needs no measure. Under a fixed reading, the dukkha gloss applies exactly where the mark is present. Thus the grid derives clinging's structural contribution but does not derive that any particular collision is phenomenal suffering. **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, so no `ClenchMismatch` is constructible and therefore no `KsmdDukkha S` is either. This holds for both pole cells: marked terminus act and unmarked stone act. 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. **The supplied mark answers the consciousness question only relative to a reading.** A thermostat or shutdown-resisting machine can occupy the insentient-appropriation cell: actual response, live share, and `ClenchMismatch`, with no `KsmdDukkha`. Thin token-reflexive for-me-ness therefore survives as act-grammar but does not entail phenomenality. Conversely, the same actual weld under the same complete grid data is a `SentientAct` under the constant-true reading. `actual_weld_readings_split` checks that disagreement, and `no_sentience_recovery` is the owned consequence: the grid proves the mismatch and stays silent on whether it is suffered. **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.** Anyone who declines the act-time identification can still state `ClenchMismatch`, its share covariation, and its pole cessation entirely in field vocabulary. They cannot thereby state the first truth's phenomenal subject: `KsmdDukkha S` additionally needs the supplied reading. The ownership argument remains quarantined from the structural derivation; the phenomenal attribution is openly supplied rather than smuggled through it. The taxonomy takes the dukkha errors without a dukkha-specific row. "Escape this" is the description/injunction collapse; suffering held substrate-bound is the clench-as-furniture freeze; proneness read as occurrence is the standing/dated collapse. The sentience attribution has its own standing-sentience row for a different reason: nature-talk freezes there, while behavior-based recovery collapses the supplied mark into visible function. One revision owned. The earlier version identified dukkha too closely with its structural correlate. This version pays the larger price explicitly: structure derived, suffering supplied. It remains doctrinally useful for the origin-claim while refusing to infer phenomenal suffering from mechanics alone. ### 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 will not do: Bull 10 describes terminus-activity in positive weld-vocabulary ("the welding done there is the students'"). The function/share split pays the debt without a domain edge. 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**. The *no*-horn bundles two claims: that the terminus-deed makes no self-pole index (true) and that it therefore drops out of the index-economy altogether — indexless and inert at others' Row 2 (false). Unbundle them: no self-pole index, object-axis standing intact. **Transposed** is this pair's display-name, never a mechanism. 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 a self-pole index — stone acts can land too. The terminus subtracts live self-share, not the sowing-side occurrence, and leaves the reception-side economy running exactly as it always ran. "The index changes pole" compresses two theorems — self-pole zero; reception-side welds intact and busy — into display. The passive 証せらるる is spent again here: the terminus-being is the verified, object-axis entire — what everyone else receives. **What stands at the pole can be displayed as a mirror** — and the word must be immediately disciplined. Great-mirror wisdom, 大円鏡智, names a run-pattern of share-zero responses whose landings repeatedly occasion share-drops: shaped output per call, nothing held as competence. A stone act is also an actual share-zero response, so "responsive stone" no longer distinguishes anything. The active buddha/stone pair may be graded apart by landing-pattern and supplied door assignments; the quiet pair has no grid-visible separation at all. In both cases the typed answer rests on the supplied sentience mark. This is the sharpest statement of what that mark is for. **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 a post-mortem self-pole index where no live self-pole index is made — the same mis-feed as *did I earn this?*, already in the taxonomy. The fire simile reads exactly: fires do not go anywhere; what they delivered persists as field-fact. Its twin, *what does the Tathāgata's death change?*, remains a delivery question and is not dissolved. Grid-side, death is a transformation in the character of newly arising welds: clench and natural door assignments may cease while remains-welds continue actual, landable, and at the pole. The grid cannot verify sentience-cessation, because the mark is supplied, nor can it recover whether later remains belong to the same macro fiber. `MisFeedNegative` fences the index-seeking form and answers the delivery twin in one model. No domain edge or staticization theorem is needed. **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 — a mirror with a stand. Huineng's 本来無一物 supplies the correction. *Device* and *mirror* are legal displays over a run of per-call, share-zero responses and illegal as a nature the terminus has. *Transposed* stands with them as a figure over two theorems. What is assertable at the pole is per-call responding that claims nothing; whether that occurrence is sentient is supplied separately. 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 floor-apophatic claim-language and cite their checks (`rowOf_obeys` and the per-row corollaries below): no claim holds at `floor`, distinctions fuse there by indiscernibility, and positive assertion begins only at act-time (`no_row_claim_holds_at_floor`, `floor_claims_indiscernible`, `fitting_offer_is_actTime`). The pole-class act-time diagnosis remains positive and unchanged (`pole_validates_all_claims`). 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 — Nāgārjuna's 空空, iterated; 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 | Universal response identified with its share-cell — share-zero treated as non-response, or live share treated as the only real function; the identity *I-making just is the clench* is this collapse in embryo (`functionShareRow_obeys`, `function_share_cell_collapse_self_refuting`) | Function frozen into a standing device-nature — the mirror given a stand; 本来無一物 is the corrective (`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 | Object-axis delivery identified with the receiver's own subject-position (`subjectObjectAxisRow_obeys`, `object_axis_as_subject_collapse_self_refuting`) | Object-axis standing denied — to another, reflexively, in the solipsist's Row 2 evacuation, or held annullable by the being. The death-freeze is re-derived without vacuity: unmarked pole welds have object-axis standing without a sentience mark, live share, natural door assignment, or landing-pattern; where remains-welds arise, death changes the character of new occurrences and cannot subtract the standing of those already actual (`subjectObjectAxisRow_not_freeze`, `solipsism_contains_row2_domain_evacuation`) | | Per-weld mark / standing sentience | Sentience identified with grid-visible function, in either direction — the retired `SentientTag = MountsSomewhere` identity was this collapse; machine behavior does not recover the mark (`standingSentienceRow_obeys`, `sentience_from_function_collapse_self_refuting`, `no_sentience_recovery`) | Sentience held as a nature the being has — affirmation or denial as 性; the mark is per act or it becomes a soul-shaped kind (`standingSentienceRow_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`, `poleTier_inhabited_of_liveTerminus`; 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. One scope-note beneath the table, because a table of errors invites a misuse it must fence. The rows grade *offers*, not sentences. "A man walked into a bar" touches half the table's conventions — a being, a doer and a deed, a before and an after, one act-grain — and, offered as narration at the tier where narration lives, violates none of them: the semantics grants the conventional side of every row wherever an act is under way, validity by stipulation rather than an achievement the sentence earns, and the fit is checked schematically (`inForce_fits_actTime_offer`) while reading the bar-sentence as its instance is prose. The generator's standing verdict on ordinary conventional speech is *decline*. The same words can arrive under other offers — and each offer is a different utterance: one that holds the man out as substance, the walking as real flow, the bar as furniture of the ultimate stacks freezes per distinction touched; "no man, no walking," offered as live diagnosis, stacks collapses. The variable is the offer, never the words — a sentence-shape severed from call and tier is not even in the generator's domain (the gradeability rule's limit case). So a reader who leaves this table hearing error in every conventional utterance has committed the one error the decline verdict exists to fence — over-generation, grid-attachment in diagnostic dress — and reversed the table's direction of protection: it is *because* of emptiness that everything works, and the conventional register is what the rows defend, not what they prosecute (`fitting_offer_is_actTime`: without the conventional, nothing is taught). #### 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), and the clench-as-furniture freeze (suffering mis-typed as substrate-bound); with delivery-arrogation 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." The fox's release came by one reception done saying rather than by any of five hundred deaths *(checked: `fox_returns_delivered`, `fox_release_rung_not_pole`)*. Its funeral coda shows past welds continuing to land. This is object-axis standing, not a staticization theorem and not a claim that death changes nothing. - **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 to which particular calls cannot be delivered — deaf and blind to the modalities a teaching travels by — commits nothing: which calls arrive at which configuration is inga's index-free business. This is a delivery-side absence, not function withheld and not an outside-domain kind. Every nearby error belongs to the diagnostician: reading failure of these calls to arrive as a global altitude ("this being cannot awaken") is the per-call/global freeze. Hakuin's corrective bites here as delivery-engineering — finding the call that lands. The retired undefined/zero row has no work left to do. 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 is shu-without-shō; the self-announced device-made buddha is the shit-stick; and industrial deployment of effective calls is displayable, never enjoinable. Whether a universally effective call is possible is an empirical dispute about delivery. The manufactured machine's sentience is likewise not softened into a verdict: it is exactly what `no_sentience_recovery` leaves underdetermined. Severed-transcript classification remains declined by the gradeability discipline. The same price is re-entered at the faith layer: faith in a device-pattern remains grid-legal, but that legality is a fact about faith's office, not an act-time certification of a device as holding a rank. `KsmdEffectiveTerminus` is the descriptive standing display used by the direct path; `KsmdFullyEnlightened` adds positive own-act-time `KsmdNoNescience` over pole-share speech-or-mind productions. For a terminus this entails the former speech-only no-delusion test under production fidelity, but the converse fails on a false pole-share thought. `KsmdFullyEnlightenedEnacted` adds a witnessed deed and an actual faithful fitting speech production, while `KsmdEffectiveOccurrence` carries the per-weld deed verdict. #### 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. - **Sparse delivery or rigid response** — few calls arrive, or the actual responses vary little. Neither is near-zero function and neither determines the supplied sentience mark. - **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. Immunity is checked per production, not stored as a safe stage: arhat quiet excludes the live self-pole through all three doors, while buddha no-nescience additionally requires positive truth from each pole-share speech-or-mind production. The former can hold while the latter fails, so the old “no safe stage” future-work absence is retired as this production-level check, not converted into rank furniture. 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 ways the separate/fuse rule can be violated *now*. The taxonomy remains answerable in the other direction too: the deaf-blind case classifies as nothing, or else the generator would be a lens that finds error wherever it looks. ## §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: `KsmdReportFace`, `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`, `KsmdDiachronicWhose`, `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: `KsmdOwnershipFace`, `ksmdOwnershipFace_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 the svakarma demotion below says why arrival's bite never needed an earning-wall. 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. One theorem and one routing close the test. **Cetanā**: *it is intention, monks, that I call karma* (AN 6.63) falls out in the strongest form the cases allow: grading tracks the weld where there is no common event to track, and peaks where the event is guaranteed to fail. **The former futility claim is now taxonomy prose, not a theorem.** The killer's picture of a victim as a standing thing whose subtraction accomplishes the end is the subject/object freeze. The antinomian converse — "empty, so killing changes nothing" — is the fox collapse. Both edges are fenced. What remains formally checked is the cetanā independence and the delivery-arrogation structure; `withRespondsTo` and `withConditions` are neutral countermodel tools, not death models. Death can change which welds newly arise and how they land while leaving already-actual welds landable. ### 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 is not itself an occurrence: its officials act, 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 death-and-futility face, at policy scale.** Huichang engineered calls with an empire's whole reach — temples closed, bronze melted, monks laicized — and engineered calls, not the loop. Delivery loss is real: institutions can end, modalities disappear, and the character of newly arising welds change. Already actual welds remain field facts and may continue to land through corpus, cases, relics, or recollection. The grid neither proves that suppression changes nothing nor models death by deleting response function. The two-cell routing applies at state scale: subtraction-of-a-standing-dharma is the subject/object freeze; "emptiness, so policy is futile" is the fox collapse. The checked residue is deliberately narrower: a decree does not determine receptions (`decree_engineers_calls_not_receptions`); the historical survival claims remain prose display. **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: fixed words and fresh receptions Recording fixes words while later reception remains a fresh weld. A quotation severed from its original call loses per-call shaping and becomes a conditioning fact in the series — field-freight, index-free — while every later reading is an actual response in its own right. The canon is thus a warehouse of fixed calls with regime-relative effectiveness, not a store of frozen agents. A clenched reading is a fresh clenched reception at recall-time; the standing/dated row does its ordinary work. A remembered dharma held as a standing object is Linji's cell. The severed line can be received and even released at, but cannot itself be graded without its call (`severed_transcript_ungradeable`); the call-carrying record remains gradeable (`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 `ksmdSuddenArrival_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 (`ksmdGradualArrival_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, `KsmdJirikiLine` and `KsmdTarikiLine` carry the system-reading, `reception_typing_ignores_sower` leaves the reception's grade/share/actuality unchanged under condition swaps, and `ksmdReachBack_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 rebound needs no cosmic delay. The deed is graded at its own weld — cetanā, act-time, sealed — and in the same moment re-pitches the configuration the next deed reads, toward arrogation, same-stream by the field's ordinary individuation of the series *(checked: `Grid.rePitch`, `Grid.rePitch_forgets`)*. Nothing external need be delivered for the downfall to be underway: a configuration pitched that way enacts more dukkha-mismatch at each subsequent reception, by the covariation already derived *(checked: `Grid.KsmdMismatchGrade`)*. "The sower reaps" at its core is this immediate self-deformation playing out across the sower's own later welds — not a debt filed for later collection. So the demotion costs no bite: what the svakarma wall touches is only the claim that fruit ripens *nowhere but* the doer's continuum by necessity, and the bite never lived in the wall — it lives in the re-pitch, act-time and same-stream by default, not by law. The seed here is field-freight throughout, a tendency carried as an inga-fact and not a stored self, on pain of the standing/dated collapse *(checked: `standing_does_not_determine_dated`)*. This is un-freezing, not collapse. A same-stream personal-karma reading is a legal conventional overlay one may hold on the grid; what is declined is only its necessity, and holding it as necessity is the freeze. The permission needs no new machinery: swapping only the delivery relation leaves a reception's grade, share, and actuality untouched, and neither regime determines share nor share the regime, so restricting delivery to same-agent lines is consistent and typing-neutral *(checked: `reception_typing_ignores_sower`, `OtherPowerNegative.regime_does_not_determine_share`, `OtherPowerNegative.share_does_not_determine_regime`)*. On that one convention the schools differ in where the weight goes, not in type signature: the Abhidharma guards it with a device, Yogācāra carries it in the ālaya's freight — already absorbed here deflated — and a Madhyamaka holds it emptily, a live rung of the re-emptying ladder *(checked: `Metaphysics.provisional_preserved`)*. The grid asserts none of these identifications; it displays the cell and leaves the placements to prose. 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 KSMD readings (`KsmdJirikiLine`, `KsmdTarikiLine`), 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 `KsmdBullSeven`, 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`, now exactly the terminus share condition with no stone disjunct. Bull 9 is `ResponsiveTerminus`. Bull 10 is `KsmdBullTen S`, the existential marketplace line into a fiber containing a marked act; `StrongKsmdBullTen S` is the shelved all-fibers reading. Bull 10 is therefore reading-relative and is unsatisfiable under `allInsentient`, while Bulls 8–9 are not (`not_ksmdBullTen_allInsentient`). The checked implication chain and the pratyekabuddha countermodel remain. **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_ksmdBullTen` 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 fine-being weld-class typing. `FetterReading` supplies each provocation class, and `FetterCut` is `QuietOn` that class: grasping no longer takes place there, without adding an anti-fetter possession. The retired call × tag rectangle survives as the special weld-class bridge `fiberAtPoleOnWithin_iff_quietOn_rectangle`; it is no longer a second API. `all_fetters_cut_at_arhat` and `arhatPathQuiet_iff_quietOn_univ` close the path family at total quiet. `terminus_iff_quietOn_univ` and `atPoleClass_iff_quietOn_univ` now express the same share-axis fact; there is no vacuous stone branch. `ViewReading.ownerClaim` supplies identity-view content; its cut factors through mind-door voicing under a model-side class equation, while rites factor through body and falsehood through speech. Content and future-run recovery remain blocked by `no_view_content_recovery` and `seen_run_underdetermines_fetterCut`. The door-typed śrāvaka-arhat is speech-and-mind quiet. `KsmdVasana` is its possible live body-door residue, and `sravakaArhat_not_arhat_witness` proves that this regional form is weaker than canonical three-door quiet. The speech path-factor is now active as the speech-door class; conduct stays inert, and doubt remains door-neutral. The effectiveness reading is a ladder above that point, checked rather than asserted. Rung 1 is total quiet alone, compatible with no actual occurrences (`FettersNegative.total_cut_carries_no_actual_occurrence`). Rung 2 adds `ActualAgentInhabited`, the non-vacuity conjunct in `LiveFiberAtPole`; `FettersNegative.total_cut_with_actual_occurrence_not_ksmdEffectiveTerminus` shows that this still does not close the effectiveness gap. Rung 3 is the descriptive `KsmdEffectiveTerminus`: responsive terminus plus universal shortfall closure. None of these rungs recovers sentience. Standing full enlightenment is the further two-obscurations bundle `KsmdFullyEnlightened`; enacted full enlightenment separately witnesses deed and speech. The assertable face of effectiveness is `KsmdEffectiveOccurrence`: an actual pole-deed landing with a share-drop for a live prior tendency. The standing form is 不落-shaped and displayable only; sealed-delivery vacuity is fenced by `KsmdEffectivenessEnacted` and `not_effectivenessEnacted_of_undelivered`, while `EffectiveTerminusNegative` checks that actual-run response/share data do not recover the standing universal. The ladder now has three explicit fences: total quiet need not witness an actual occurrence; quiet actual occurrence need not be effective; and `arhat_retains_nescience_witness` shows that even an innocent pole-share producer may retain cognitive error. `noNescience_strictly_stronger_witness` separates the speech-only comparison, while `Sealed.silent_buddha_models` exhibits both no-thought and true-thinking silent standing models. The pratyekabuddha face is therefore the sealed-and-silent standing bundle: own deeds are undelivered and no faithful speech occurs, while the mind-side may be empty or positively true. The enacted top fails there. Samyaksambuddha is the named enacted form, with a delivered closing deed and faithful fitting speech production. Under zero-effect delivery the lower effective rung still fails (`OrthogonalityNegative.ksmdEffectiveTerminus_stronger_than_terminus`). Hakuin's bodily-satori contrast becomes the door-typed śrāvaka form: speech and mind may quiet while body still clenches. Vāsanā is thereby located as body-door live share. `no_door_boundary_recovery` and `seen_run_underdetermines_fetterCut` keep the supplied classification and future welds honest. **Factors** are the path-facing regrouping of the fetter table, not a second table. `PathFactor.blockerClass` consumes door and fetter readings; speech is active as the speech-door class, conduct remains inert, and `lower_fetters_covered_by_rites_view_resolve` checks the lower-fetter union. Hold/Release is a new frame: `FactorHeld` is a seen-run witness with a live self-pole index, while `FactorReleased` is whole-class `QuietOn`. A held factor may be correct; the errors remain freeze/collapse in the utterance frame and clench/quietness in the share frame. The stage pair is path/fruit over those factor pairs. `KsmdStreamEnterer` is rites released and view held; `KsmdStreamWinner` is rites and view released, proved equivalent to `Path.cutClasses streamEntry` by `ksmdStreamWinner_iff_streamEntry_cutClasses`. `KsmdOnceReturner` adds a witnessed resolve hold, and `KsmdNonReturner` is proved equivalent to the non-return cut by `ksmdNonReturner_iff_nonReturn_cut`. Once-return now has checked content: `KsmdResolveAttenuation` is a strict resolve-class share-drop run that has not reached the pole, witnessed by `ksmdOnceReturner_attenuation_witness`, with `registerResolve_not_released` blocking its collapse into release. The ordering claim is deliberately conditional. `KsmdSerialFactorRegime` says that if a supplied regime reads seen drops as rites-before-view-before-resolve, then the path readings promote to corresponding fruit readings; `ksmdSerialFactorRegime_conditional` consumes that hypothesis and never proves it. `SuddenGradualNegative.subitism_frequency_underdetermined` and `FactorsNegative.factor_order_underdetermined` block rate or order recovery from grid data, while `no_hold_conceit_boundary_recovery` blocks recovering the hold/conceit line from share data alone. ### The stone, doubly mujō The stone is doubly mujō — impermanent (無常) and, under a supplied reading, insentient (無情) — but it is no longer subject-axis null. A stone act is an actual response at share-zero with object-axis standing. 無情説法 is therefore affirmed nearly in full: the pebble's crack is itself a weld, it may condition another stone, and it may land at a monk's reception; no successor layer is needed to turn object into pseudo-subject. The concrete checks now include both halves: `clock_pole_readings_split` places the adaptive clock's actual pole weld in the stone and terminus cells under the two extremal supplied readings, while `insentient_source_shareDropLanding` sends an explicitly unmarked source deed across the named identity coarsening into an explicitly marked receiver fiber with a live share drop. What the grid declines has narrowed exactly to the mark. 無情有性 as a standing nature freezes on the standing-sentience row; its per-weld supplied form is legal and underdetermined, neither affirmed nor refuted from the grid. The modality change is owned: the old system denied insentient subjecthood; this one makes sentience unassertable from visible function. Buddha and stone occupy the two pole cells, with an active pair sometimes distinguished by landing-pattern and a quiet pair distinguished only by the mark. The retired-premise audit is Lean data in `RetiredStoneArgument.successors`: death-freeze routes to landing-pattern plus universal function; the mirror gloss routes to landing-pattern; insentient preaching routes to universal function; and the quietist arhat routes to the sentience mark alone. Any future use of the old premise therefore has a named place to go—or is visibly unrouted. ## §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. - **No floor-Truth predicate.** No positive Truth or Thus predicate of the floor is defined. `no_row_claim_holds_at_floor` and `floor_claims_indiscernible` carry the ultimate only as silence and degeneracy; `InstructiveAbsence.floorTruthPredicate` registers the refusal. - **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: actual-agent inhabited, with live share at every actual weld, unseatable as an effective terminus there, and reachable as a receiver wherever its actual reception and live prior tendency give the sraddha antecedent. No non-stone conjunct is needed. The permanent foreclosure verdict is refused as a stored rank; defiance is a seed, not a rank *(checked: `Icchantika`, `not_ksmdEffectiveTerminus_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 former third arrival, retyped.** The never-clenched responder is no third structural cell: it is a pole weld, unmarked under the reading named by `thirdArrival_stone_at_pole`, with the marked reading retained as the other half of `clock_pole_readings_split`. The absence remains retired as a regression check (`thirdArrival_stone_at_pole`, `thirdArrival_not_clenchMismatch`). - **The undefined/zero row retired.** Once every actual weld lies on the share scale, the old edge supplies no exemplar. Its generated table position is taken by the standing-sentience row; the lost row is retained as an instructive absence (`undefinedZeroRowRetired_replacement_anchor`). - **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.) - **Rebirth cosmology ceded.** The grammar of ownerless continuation is already given in a limited sense: the field carries conditioning without a bearer, and the fox's returns are welds rather than a transmigrating self — the flame passed with no self to carry it. What is ceded is the cosmology of rebirth: persistence across biological death, the realms, and the mechanism, downstream of where the domain of mounted responses ends. The boundary is marked as an absence, not bridged by a manufactured theorem. ===== FILE: Exposition/Identification.md ===== # Kannō-Sōe Mutual Dependence — 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 and definability 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, but the configuration has no owner-typed slot; whole-carrier relabelling leaves it fixed, commutes with re-pitching, and admits no equivariant recovery of a designatum. This is not agent-blindness: delivery is a relation on occurrence-generated welds, `SameAgentDelivery` is deliberately field vocabulary, and a stored grade may reveal occurrence information in a particular model. It does not thereby carry a mineness or an index *as index*. What is indexed is welded at act-time, spent at act-time, and then available only as a field-describable occurrence-fact. This is why the taxonomy can name internal **mis-feeds** cheaply. Feeding an index-free-in-configuration 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 (`KsmdVacuousOwnershipFace`, checked concretely by `MemoryWitness.falseMemory_ksmdVacuousOwnershipFace`). 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 weld's token-reflexivity still gives the thin, spent grammar of this-deed-for-this-doer, but the insentient-appropriation cell has that grammar too. Thin act-time for-me-ness therefore no longer suffices for phenomenality. Mineness held as a structural feature freezes; phenomenal sentience is supplied by the per-weld mark and not recovered from this grammar. 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. Buddha and stone acts are both actual responses at share-zero. Their typed difference is the supplied sentience mark; an active buddha may also be displayed by a run-pattern of share-drop landings and supplied doors, while the quiet pair is grid-indiscernible. The avyākata follows without the old outside edge: asking for the Tathāgata's post-mortem self-pole feeds an index-question to a pole act that makes no live self-pole index. 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 — though the contra is chiefly one of register: he internalized that the floor is unproducible and taught from that standpoint — his idiom declines the very seam this paper tiers. The shushō he held seamless is re-tiered here, shō at the floor, shu conventional. Here the floor is externalized as a named designation — the philosophers' habit of naming what resists naming in order to work on it — with the performative cost paid openly, every such name flagged prajñapti; 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, whose remainder Theory now types as production-equivalent rather than open. The earlier third contra is narrowed: 無情説法 is affirmed directly by unmarked actual welds; only 無情有性 as a standing nature freezes, while its per-weld form remains legal and underdetermined. 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 pole cells** -- the unmarked stone act and the marked terminus act both arrive on the scale at share-zero; the former open "third arrival" is retyped by the mark rather than left as another structural cell; practice-run-scaffold-free remains 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 (`KsmdReportFace`), mineness-half (`KsmdDiachronicWhose`, `no_diachronicWhose_from_series_alone`, `rePitch_forgets`), mis-feed half (`MisFeedNegative.fence_and_gate`), and reception-deed (`KsmdOwnershipFace`). 12. **The stone moved onto the resonance scale** -- an actual, unmarked, share-zero weld (`StoneAct`), fully inside universal call/response and with object-axis standing; the retired function-zero outside-edge sense is retained only as dated glossary history. 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 universal call/response: I-making is the welding-function, clench its share-degree, and neither entails the supplied sentience mark. The inhabited insentient-appropriation cell makes the detachment explicit. The identity *I-making just is the clench* remains an embryonic function/share collapse; identifying either with sentience is the standing-sentience 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 split honestly** -- `ClenchMismatch` is the field-statable structure of a self-maintaining response meeting a delivery-register that answers to nothing; `KsmdDukkha S` adds the supplied sentience mark. The second-truth covariation and third-truth pole corollary are structural; the claim that the mismatch is suffered is reading-relative. Structure is derived, suffering supplied. 25. **The domain made edgeless** -- every actual occurrence is a call/response weld on the share scale. Sentience crosses live share and pole as an independent supplied mark, producing the inhabited 2×2; the solipsist remains a share asymptote, not an opposite function edge. 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** -- no longer "buddha as responsive stone," since stone acts respond too. 大円鏡智 is disciplined as display over a run-pattern of share-drop landings, never a held competence; the active pair may be visibly graded apart, while the quiet buddha/stone pair is separated only by the supplied mark. 本来無一物 remains the guard against giving the mirror a stand. 28. **The three-killings test split by evidential status** -- one verb, dispersed events; the cetanā theorems (`grade_independent_of_conditions`, `share_independent_of_conditions`, `cetana_grading_tracks_weld_not_field_witness`, `cetana_live_share_without_object_standing_witness`) and the ānantarya severity reading survive untouched. The former futility theorem is demoted to a two-cell prose routing: victim-as-subtractable-standing-thing is the subject/object freeze; "emptiness, so killing changes nothing" is the fox collapse. Grid surgery remains countermodel tooling with no doctrinal reading. 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`). A same-stream personal-karma convention remains legal as a floor-optional overlay; Abhidharma, Yogācāra, and Madhyamaka are placed here only as prose weight-variants, not as captured formal objects. 34. **The orthogonality rule and its price** -- function is universal, share types, effectiveness grades, sentience is supplied, and adaptivity is the terminus's manner but never the ground of landing. Pole-typing follows where live self-index welding ceases; no visible structure recovers the mark. 35. **The being-convention** -- the macro being demoted to a diagnosis-time coarsening convention (`BeingCoarsening`): naming suffices, sentience is a reading-relative per-weld mark summarized over fibers, 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 floor-apophatic 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; no-actual-weld, 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** -- effective termination removes the afflictive-obscuration face, while `KsmdNoNescience` removes the cognitive-obscuration face over pole-share speech-or-mind productions; a fully three-door-quiet arhat with a false innocent thought separates them. 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. **Floor-apophatic semantics** -- all claim languages are silent at `floor`; schema-row distinctions fuse there by degeneracy, not joint truth, while conventional force and the pole-class denial diagnosis remain act-time semantics. The previous joint-truth reading is withdrawn. 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 is fine-being `QuietOn` over a model-supplied weld-class. `Fetter.kind_lower_iff_cut_by_nonReturn` pins the table, `all_fetters_cut_at_arhat` gives the universal arhat cut, finite-run diagnosis remains underdetermined, and forward irreversibility remains conditional. 52. **Door-typed fetter lattice** -- the old call × tag rectangle and Soma reading are retired by a bridge to weld-classes. View factors through mind, rites through body, and falsehood through speech; doubt and upper fetters remain door-neutral. The śrāvaka-arhat is speech-and-mind quiet, with body-door vāsanā possible, while canonical arhat display is quiet through all three doors. 53. **Effectiveness ladder and enlightenment joint** -- total three-door quiet carries no door assignment, not no function; quiet responding need not be effective; effective termination need not remove no-nescience. Standing `KsmdFullyEnlightened` adds positive speech-or-mind production truth, while `KsmdFullyEnlightenedEnacted` separately witnesses deed and production-tied speech occurrence. 54. **Ethics as a bundled conditional code** -- factive faith and fidelity records known to arise from speech productions combine with the receiver's own live aversion in one implication theorem; the detached injunction remains outside the assertable voice. 55. **The code's honesty clauses** -- empty at the pole and unsatisfiable over an admitted false speech production; false thoughts never cross into testimony, and neither `Factive` nor production fidelity is manufactured from field facts. 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. 58. **Effective terminus demoted** -- the assertable effectiveness content is per-occurrence (`KsmdEffectiveOccurrence`), while `KsmdEffectiveTerminus` is a descriptive standing display and direct-path hypothesis; `KsmdEffectivenessEnacted` fences sealed-delivery vacuity and supplies the deed witness at the enacted top, `EffectiveTerminusNegative` checks run-data underdetermination, and the separate testimonial ladder runs from standing `KsmdFullyEnlightened` to witnessed `KsmdFullyEnlightenedEnacted`. 59. **Views as mind-door voicings** -- `ViewReading.ownerClaim` supplies the stored-owner claim-class and the view cut factors through mind-door voicing only under a model-side class equation. The coarsening-freeze relation survives as one checked correlation, not as recovered content. 60. **Defiled falsehood is not deliberate lying by definition** -- `KsmdDefiledFalsehood` derives speech-door own-act-time falsity plus a live self-pole. Its identification with canonical deliberate lying is an explicit modeling claim. 61. **Three-door totality and adequacy are supplied** -- every fine weld is diagnosed as body, speech, or mind by a total `DoorReading`. That this trichotomy is adequate is an aptness claim with the same standing as content-row hypotheses; no door boundary is recovered from the grid. 62. **Thoughts-as-voicings are supplied** -- a `SpeechReading` may voice mind-door content, but response and grade data do not determine that voicing. Thoughts remain outside `RecordedUtterance`, `Fidelity`, `Faith`, and `Ethics`; only the enlightenment character conjunct ranges over them. 63. **Predicate-aptness is grain-indexed; it does not distribute over refinement** -- that a supplied reading (doors, voicing, fetter provocation-classes) is apt at the person grain confers nothing on any finer re-graining of the same fiber (for example, a homunculus reading of fine tags as mini-agents thinking macro-level thoughts). The merge/split countermodels already witness that verdicts fail to survive re-segmentation; aptness at a grain is a separate supplied claim each time, and the grid neither checks nor transfers it. 64. **Sentience as a supplied per-weld reading** -- `SentienceReading` marks occurrences, the four sentience/share cells are inhabited, `SentientTag`, `StoneTag`, and `Intermittent` are reading-relative fiber summaries, and `no_sentience_recovery` proves maximal underdetermination by grid data wherever an actual weld witnesses the question. The standing-sentience taxonomy row freezes nature-talk and collapses behavior-based recovery. --- *With thanks to Claude (Anthropic) — Opus 4.8 in the early discussions and first Exposition, Fable 5 for the greater part of the theory since — sparring partner and midwife to a more resonant theory, in both directions, and OpenAI Codex—beginning with GPT‑5.5 xhigh’s initial Lean formalization of the Exposition—for continued assistance with proofs, plan-guided development, and systematic refactoring. Thanks to both 5.6 Sol and Fable for collaborating with me on the V2 signature rewrite. Thanks also to Sol for suggesting the Preamble case.* ===== FILE: Exposition/Assumptions.md ===== # Assumptions Generated from `KannoSoe/Meta/AssumptionLedger.lean` by `lake exe exposition_gen`. `KannoSoe/Meta/AxiomAudit.lean` holds the compile-checked axiom ledger; statement prose is canonical here. ## A. What Is Asserted ### A.1 No prior agent A weld is an occurrence designatum selected by an `OccurrenceReading`. Its agent, call, and response are role-readings of that occurrence; `Grid.index` and `Grid.share` are derived projections, not fields recovered from a separate performer or act. `Grid.no_agent_recovery_of_field_collision` records the internal obstruction: the same call-response field residue can be produced by distinct actual agents. **Checked anchors (Signature):** `KannoSoe.OccurrenceReading.Weld` (proof), `KannoSoe.OccurrenceReading.Weld.agent` (proof), `KannoSoe.OccurrenceReading.Weld.call` (proof), `KannoSoe.OccurrenceReading.Weld.response` (proof), `KannoSoe.Grid.index` (proof), `KannoSoe.Grid.share` (proof), `KannoSoe.Grid.no_agent_recovery_of_field_collision` (witness) ### A.2 Nothing self-indexed is stored `Config` stores only `tendency : Contrib`. It has no owner, designatum, weld, or field-residue slot. `rePitch` uses the received weld's share and ignores the prior configuration value. The checked claim is architectural and definability-level: whole-carrier relabelling acts trivially on configurations and commutes with `rePitch`, and no relabelling-equivariant recovery of a designatum from a configuration exists. It is not an information-flow claim; see the declined entry below. **Checked anchors (Signature):** `KannoSoe.Config` (proof), `KannoSoe.Config.tendency` (proof), `KannoSoe.Grid.rePitch` (proof) **Downstream elaboration:** `KannoSoe.Equiv` (proof), `KannoSoe.Grid.relabel` (proof), `KannoSoe.Config.relabel_fixed` (proof), `KannoSoe.Grid.relabel_rePitch` (proof), `KannoSoe.Grid.no_natural_agent_recovery_from_config` (witness), `KannoSoe.ConfigLeakWitness.no_agent_recovery_from_config_of_share_collision` (witness) ### A.3 The self-pole index is just live share `HasSelfPoleIndex w` is `not AtBot (share w)`, and when the predicate is live the carried `selfPoleIndex` is the weld's agent tag. **Checked anchors (Signature):** `KannoSoe.Grid.HasSelfPoleIndex` (proof), `KannoSoe.Grid.selfPoleIndex_eq_agent_of_hasSelfPoleIndex` (proof), `KannoSoe.Grid.no_self_pole_index_of_atBot` (proof) ### A.4 Sentience is a supplied per-weld reading A `SentienceReading` marks welds, not beings. Together with live or pole share it yields the four actual act-kinds `OrdinaryAct`, `TerminusAct`, `InsentientAppropriation`, and `StoneAct`; the checked square witnesses all four. `SentientTag`, `StoneTag`, and `Intermittent` are reading-relative quantified displays over those acts. **Checked anchors (Signature):** `KannoSoe.Grid.SentienceReading` (proof), `KannoSoe.Grid.SentientAct` (proof), `KannoSoe.Grid.InsentientAct` (proof), `KannoSoe.Grid.OrdinaryAct` (proof), `KannoSoe.Grid.TerminusAct` (proof), `KannoSoe.Grid.InsentientAppropriation` (proof), `KannoSoe.Grid.StoneAct` (proof), `KannoSoe.Grid.DirectedConvention.BeingConvention.BeingCoarsening.SentientTag` (proof), `KannoSoe.Grid.DirectedConvention.BeingConvention.BeingCoarsening.StoneTag` (proof), `KannoSoe.Grid.DirectedConvention.BeingConvention.BeingCoarsening.Intermittent` (proof), `KannoSoe.sentience_share_square_inhabited` (witness) ### A.5 Call/response is universal per occurrence Every actual weld is a mounted call/response occurrence. `respondsTo` remains `Option`-valued only to distinguish actual from hypothetical triples; `none` is not aggregated into a per-being doctrinal category. In Madhyamaka terms it marks non-arising, not a cessation or state entered by a being. **Checked anchors (Signature):** `KannoSoe.Grid.Actual` (proof), `KannoSoe.Grid.MountsAt` (proof) **Downstream elaboration:** `KannoSoe.Grid.mountsAt_iff_exists_actual` (proof) ### A.6 Self-lines are permitted, not built in 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. **Checked anchors (Signature):** `KannoSoe.Grid.conditions` (proof), `KannoSoe.Grid.DirectedConvention.DeliveredTo` (proof), `KannoSoe.Grid.DirectedConvention.LandsAt` (proof), `KannoSoe.AssumptionLocalWitnesses.signature_self_line_permitted` (witness) **Downstream elaboration:** `KannoSoe.SelfLineWitness.selfLine_landsAt_self` (witness), `KannoSoe.SelfLineWitness.selfLine_ksmdOwnershipFace_self` (witness) ### A.7 Dukkha and Bull 10 are reading-relative `ClenchMismatch` and its share covariation are grid-derived. `KsmdDukkha` adds the supplied mark: the structure is derived, the suffering is supplied. Bull 10 likewise quantifies over `SentientTag` under a reading; with the constant-false reading its marketplace is empty and the predicate is unsatisfiable. **Checked anchors (Signature):** None. **Downstream elaboration:** `KannoSoe.Grid.ClenchMismatch` (proof), `KannoSoe.Grid.KsmdDukkha` (proof), `KannoSoe.Grid.clenchMismatch_of_ksmdDukkha` (proof), `KannoSoe.Grid.KsmdBullTen` (proof), `KannoSoe.Grid.not_ksmdBullTen_allInsentient` (proof) ## B. What Is Deliberately Declined ### B.1 No arrow in `conditions` 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. **Checked anchors (Signature):** `KannoSoe.Grid.ConditionsEither` (proof), `KannoSoe.Grid.conditionsEither_symm` (proof), `KannoSoe.Grid.DirectedConvention.TimeDirection` (proof), `KannoSoe.Grid.transpose` (witness), `KannoSoe.Grid.transpose_conditionsEither_iff` (witness), `KannoSoe.Grid.DirectedConvention.transpose_deliveredTo_iff` (witness), `KannoSoe.OccurrenceReading.transposeCR` (witness), `KannoSoe.AssumptionLocalWitnesses.no_direction_recovery_from_conditionsEither` (witness), `KannoSoe.InteriorDirectionNegative.no_interior_direction_recovery` (witness) **Downstream elaboration:** `KannoSoe.DirectionNegative.no_direction_recovery_from_conditionsEither` (witness) ### B.2 No `PreorderTop` 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. **Checked anchors (Signature):** `KannoSoe.PreorderBot` (proof), `KannoSoe.AtBot` (proof), `KannoSoe.Grid.DirectedConvention.BeingConvention.BeingCoarsening.StrongSelfConditioningTag` (proof), `KannoSoe.AssumptionLocalWitnesses.nat_preorderBot_has_no_top` (witness) ### B.3 No privileged person-partition 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. **Checked anchors (Signature):** `KannoSoe.Grid.DirectedConvention.BeingConvention.BeingCoarsening` (proof), `KannoSoe.Grid.DirectedConvention.BeingConvention.BeingCoarsening.InFiber` (proof), `KannoSoe.Grid.DirectedConvention.BeingConvention.BeingCoarsening.SameFiber` (proof), `KannoSoe.Grid.DirectedConvention.BeingConvention.BeingCoarsening.id` (witness), `KannoSoe.Grid.DirectedConvention.BeingConvention.BeingCoarsening.total` (witness), `KannoSoe.Grid.DirectedConvention.BeingConvention.BeingCoarsening.total_sameFiber` (witness), `KannoSoe.Grid.DirectedConvention.BeingConvention.BeingCoarsening.id_not_sameFiber_of_ne` (witness), `KannoSoe.AssumptionLocalWitnesses.partition_merge_split_disagree` (witness) **Downstream elaboration:** `KannoSoe.BeingNegative.no_partition_recovery` (witness) ### B.4 Direction resolution is display, not signature furniture 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. **Checked anchors (Signature):** `KannoSoe.Grid.DirectedConvention.DirectionCoarsening` (proof), `KannoSoe.Grid.DirectedConvention.DirectionCoarsening.SameTick` (proof), `KannoSoe.Grid.DirectedConvention.DirectionCoarsening.ResolutionBounded` (proof), `KannoSoe.Grid.DirectedConvention.DirectionCoarsening.no_timeDirection_within_tick` (proof), `KannoSoe.Grid.DirectedConvention.DirectionCoarsening.no_timeDirection_of_resolutionBounded_subsingleton` (proof), `KannoSoe.Grid.DirectedConvention.DirectionCoarsening.transpose_subTickDelivery` (witness) **Downstream elaboration:** `KannoSoe.DirectionCoarseningWitness.unit_directionVoid_via_mergeToUnit` (witness), `KannoSoe.DirectionCoarseningWitness.twoResolution_directionCoarsening_independence` (witness), `KannoSoe.Grid.DirectedConvention.DirectionCoarsening.mapDir_resolutionBounded_iff` (proof), `KannoSoe.CoverageNegative.directionVoid_needs_coverage` (witness) ### B.5 Contribution values are display, not operational tokens 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. **Checked anchors (Signature):** `KannoSoe.Grid.share_eq_grade_check` (proof), `KannoSoe.AtBot` (proof), `KannoSoe.OrderEq` (proof), `KannoSoe.Grid.Terminus` (proof) **Downstream elaboration:** `KannoSoe.DisplayReparam` (proof), `KannoSoe.DisplayReparam.atBot_iff` (proof), `KannoSoe.InvarianceNegative.oldEqTerminus_not_invariant` (witness) ### B.6 The enlightenment ladder names standing and enacted vacuity The operational, assertable effectiveness content is per-occurrence: `KsmdEffectiveOccurrence` states an actual pole-deed landing as a share-drop against a live prior tendency. The descriptive universal `KsmdEffectiveTerminus` remains legal as run-display and direct-path hypothesis, but no estimator from actual-run response/share data decides it. Standing `KsmdFullyEnlightened` adds positive own-act-time `KsmdNoNescience` over speech-or-mind productions. A quiet arhat may still fail that cognitive conjunct; sealed silent and true-thinking buddhas witness its two silent faces. `KsmdFullyEnlightenedEnacted` separately adds an effective deed witness and a production-tied speech occurrence. **Checked anchors (Signature):** None. **Downstream elaboration:** `KannoSoe.Grid.DirectedConvention.KsmdEffectiveOccurrence` (proof), `KannoSoe.Grid.DirectedConvention.KsmdEffectivenessEnacted` (proof), `KannoSoe.Grid.DirectedConvention.not_effectivenessEnacted_of_undelivered` (proof), `KannoSoe.Grid.DirectedConvention.KsmdFullyEnlightened` (proof), `KannoSoe.Grid.DirectedConvention.KsmdNoNescience` (proof), `KannoSoe.Grid.DirectedConvention.KsmdFullyEnlightenedEnacted` (proof), `KannoSoe.FaithNegative.noNescience_strictly_stronger_witness` (witness), `KannoSoe.FaithNegative.arhat_retains_nescience_witness` (witness), `KannoSoe.FaithNegative.Sealed.silent_buddha_models` (witness), `KannoSoe.EffectiveTerminusNegative.actual_run_data_underdetermines_effectiveTerminus` (witness), `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.ksmd_effective_occurrence_voice_assertable` (proof), `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.ksmd_standing_effectiveness_voice_displayable` (proof) ### B.7 No blanket noninterference for the contribution carrier Grading may depend on the agent — `gradingCollisionGrid` grades by being deliberately (cetanā) — so a model's stored tendency may extensionally coincide with an agent tag; `registerClockGrid` witnesses the coincidence. The signature therefore declines the information-flow reading of non-storage. `Grid.rePitch_forgets` bounds the coincidence to a single reception's footprint: nothing accumulates into a diachronic bearer, and the configuration is fibered over no being. The asserted claim is typing plus relabelling equivariance. **Checked anchors (Signature):** `KannoSoe.gradingCollisionGrid` (witness), `KannoSoe.registerClockGrid` (witness) **Downstream elaboration:** `KannoSoe.ConfigLeakWitness.registerClock_config_recovers_agent` (witness), `KannoSoe.Config.relabel_fixed` (proof), `KannoSoe.Grid.relabel_rePitch` (proof), `KannoSoe.Grid.rePitch_forgets` (proof) ### B.8 No recovered door boundary `DoorReading` totally classifies fine welds as body, speech, or mind, but that diagnosis is supplied rather than recovered from response or grade data. Totality and adequacy to the canonical three doors are modeling claims. **Checked anchors (Signature):** None. **Downstream elaboration:** `KannoSoe.Grid.DoorReading` (proof), `KannoSoe.DoorsNegative.no_door_boundary_recovery` (witness) ### B.9 No recovered voicing `SpeechReading` supplies optional content independently of door. Thoughts and bodily intimations are representable, while only speech productions cross into testimony; neither voicing nor its production weld is recovered from visible grid data or content alone. **Checked anchors (Signature):** None. **Downstream elaboration:** `KannoSoe.Grid.SpeechReading` (proof), `KannoSoe.Grid.ProducedUtterance` (proof), `KannoSoe.DoorsNegative.no_voicing_recovery` (witness), `KannoSoe.DoorsNegative.no_production_recovery` (witness) ### B.10 No recovered view content `ViewReading.ownerClaim` supplies which claims count as stored-owner views. The checked coarsening-freeze model is a correlation for one such reading, not a derivation of content from the grid. **Checked anchors (Signature):** None. **Downstream elaboration:** `KannoSoe.Grid.ViewReading` (proof), `KannoSoe.FettersNegative.no_view_content_recovery` (witness), `KannoSoe.FettersNegative.ownerClaim_coarsening_freeze_correlation` (witness) ### B.11 No sentience recovery from grid data Given an actual weld, the same complete response, grade, and delivery data classify it as a `SentientAct` under the constant-true reading and an `InsentientAct` under the constant-false reading. Behavior, share, clench, and delivery therefore jointly underdetermine the mark on the actual domain. **Checked anchors (Signature):** `KannoSoe.Grid.SentienceReading` (proof), `KannoSoe.Grid.actual_weld_readings_split` (proof), `KannoSoe.Grid.no_sentience_recovery` (witness) ### B.12 No plenitude over being-call pairs Universal call/response ranges over actual occurrences; it does not assert that every `Being × Call` pair returns a response. The `Option` seam remains load-bearing for hypothetical variation and candidate receptions. **Checked anchors (Signature):** `KannoSoe.Grid.respondsTo` (proof), `KannoSoe.Grid.Actual` (proof), `KannoSoe.Grid.DirectedConvention.EnvironsLine` (proof) **Downstream elaboration:** `KannoSoe.ContentNegative.hypotheticalGrid_no_actual` (witness), `KannoSoe.ContentNegative.contentBeingsRow_not_obeys_hypothetical` (witness), `KannoSoe.ContentNegative.fixedResponseGrid_no_variation` (witness), `KannoSoe.ContentNegative.contentIntraWeldArrowRow_not_obeys_fixedResponse` (witness) ### B.13 No aggregate sentience scalar Sentience is marked per weld. `Intermittent` records fibers containing both marked and unmarked actual acts, but the system assigns no degree of sentience to a tag. **Checked anchors (Signature):** `KannoSoe.Grid.DirectedConvention.BeingConvention.BeingCoarsening.Intermittent` (proof), `KannoSoe.Grid.DirectedConvention.BeingConvention.BeingCoarsening.Patchy` (proof) ### B.14 No insentient-clench exclusion An unmarked actual weld may retain live self-share. `InsentientAppropriation` is an inhabited cell of the checked square, so appropriation and structural mismatch do not recover sentience. **Checked anchors (Signature):** `KannoSoe.Grid.InsentientAppropriation` (proof), `KannoSoe.square_insentientAppropriation` (witness) **Downstream elaboration:** `KannoSoe.Grid.clenchMismatch_of_insentientAppropriation` (proof) ## C. Conveniences and Stand-Ins ### C.1 Hand-rolled order classes `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. **Checked anchors (Signature):** `KannoSoe.Preorder` (proof), `KannoSoe.PreorderBot` (proof), `KannoSoe.shareBot` (proof), `KannoSoe.shareBot_le` (proof) ### C.2 `_before` is retained but currently ignored by `rePitch` `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. **Checked anchors (Signature):** `KannoSoe.Grid.rePitch` (proof) > Note: The signature file keeps an `rfl` example showing that two prior configurations produce the same re-pitch for the same received weld. ### C.3 The scalar is display over a partial order `KsmdMismatchGrade` 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. **Checked anchors (Signature):** `KannoSoe.Grid.share` (proof), `KannoSoe.Grid.share_eq_grade_check` (proof) **Downstream elaboration:** `KannoSoe.Grid.KsmdMismatchGrade` (proof), `KannoSoe.Grid.ksmdMismatchGrade_eq_share` (proof) ### C.4 `Models.lean` witnesses are illustrative The clock and register-clock models anchor possibility checks and mark-invariance witnesses; they are not uniqueness claims. **Checked anchors (Signature):** `KannoSoe.clockGrid` (witness), `KannoSoe.registerClockGrid` (witness), `KannoSoe.registerClock_insentient_proficient` (witness), `KannoSoe.clock_pole_readings_split` (witness), `KannoSoe.registerClock_rung_readings_split` (witness), `KannoSoe.rigid_terminus_vacuous` (witness), `KannoSoe.adaptive_liveTerminus` (witness), `KannoSoe.sentience_share_square_inhabited` (witness), `KannoSoe.registerClock_macro_selfConditioning` (witness) ## Axiom audit `#verify_axiom_audit` compares each declaration's collected axiom set with this allowlist during every build. | Declaration | Allowed axioms | |---|---| | `KannoSoe.Grid.no_agent_recovery_of_field_collision` | None | | `KannoSoe.Grid.DirectedConvention.DirectionCoarsening.no_timeDirection_within_tick` | None | | `KannoSoe.Grid.DirectedConvention.DirectionCoarsening.no_timeDirection_of_resolutionBounded_subsingleton` | None | | `KannoSoe.Grid.relabel_rePitch` | None | | `KannoSoe.Grid.no_natural_agent_recovery_from_config` | `propext`, `Quot.sound` | | `KannoSoe.ConfigLeakWitness.registerClock_config_recovers_agent` | `propext` | | `KannoSoe.ConfigLeakWitness.no_agent_recovery_from_config_of_share_collision` | `propext` | | `KannoSoe.strict_asymm` | None | | `KannoSoe.strict_trans` | None | | `KannoSoe.Grid.transpose_transpose` | None | | `KannoSoe.DirectionNegative.no_direction_recovery_from_conditionsEither` | `propext`, `Quot.sound` | | `KannoSoe.CoverageNegative.directionVoid_needs_coverage` | None | | `KannoSoe.CoverageNegative.ksmdEffectiveTerminus_needs_coverage` | `propext` | | `KannoSoe.Grid.stateToolFits_iff_atBot` | None | | `KannoSoe.Grid.map_actual_iff` | None | | `KannoSoe.Grid.map_isShareDrop_iff` | None | | `KannoSoe.Grid.map_transpose` | None | | `KannoSoe.Grid.actual_weld_readings_split` | None | | `KannoSoe.Grid.no_sentience_recovery` | None | | `KannoSoe.sentience_share_square_inhabited` | `propext` | | `KannoSoe.Grid.DirectedConvention.DirectionCoarsening.mapDir_resolutionBounded_iff` | None | | `KannoSoe.DirectionCoarseningWitness.unit_directionVoid_via_mergeToUnit` | None | | `KannoSoe.DirectionCoarseningWitness.twoResolution_directionCoarsening_independence` | None | | `KannoSoe.DirectionCoarseningWitness.registerClock_directionCoarsening_independence` | `propext` | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.contentLayerRow_not_fused_of_nonlive_denial` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.contentLayerRow_not_obeys_of_nonlive_denial` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.contentLayerRow_obeys_of_no_occurrences` | None | | `KannoSoe.ContentNegative.contentBeingsRow_not_obeys_hypothetical` | `propext` | | `KannoSoe.ContentNegative.contentGridLensRow_not_obeys_hypothetical` | `propext` | | `KannoSoe.ContentNegative.contentWeldRow_not_obeys_hypothetical` | `propext` | | `KannoSoe.ContentNegative.contentIntraWeldArrowRow_not_obeys_fixedResponse` | `propext` | | `KannoSoe.ContentNegative.contentBeforeAfterRow_not_obeys_twoBottom` | None | | `KannoSoe.Grid.DirectedConvention.map_landsWithShareDrop_iff` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.BeingCoarsening.map_selfConditioningTag_iff` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.BeingCoarsening.map_fiberAtPoleOn_iff` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.BeingCoarsening.total_sameFiber` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.BeingCoarsening.id_not_sameFiber_of_ne` | None | | `KannoSoe.Grid.map_ksmdBullSeven_iff` | None | | `KannoSoe.Grid.map_ksmdBullTen_iff` | None | | `KannoSoe.Grid.bullSeven_not_bullEight` | None | | `KannoSoe.Grid.bullTen_to_bullNine` | None | | `KannoSoe.CorrelationsNegative.pratyekabuddha_countermodel` | `propext` | | `KannoSoe.CorrelationsNegative.no_stage_boundary_recovery` | `propext` | | `KannoSoe.Grid.classQuiet_no_clench_in_class` | None | | `KannoSoe.Fetter.kind_lower_iff_cut_by_nonReturn` | None | | `KannoSoe.Grid.arhatPathQuiet_iff_quietOn_univ` | None | | `KannoSoe.Grid.terminus_iff_quietOn_univ` | None | | `KannoSoe.Grid.atPoleClass_iff_quietOn_univ` | None | | `KannoSoe.Grid.all_fetters_cut_at_arhat` | None | | `KannoSoe.Grid.identityView_cut_iff_noDefiledVoicing` | None | | `KannoSoe.Grid.conceit_excluded_of_quietOn` | None | | `KannoSoe.Grid.ksmdIrreversibleRegime_conditional` | None | | `KannoSoe.Grid.lower_fetters_covered_by_rites_view_resolve` | None | | `KannoSoe.Grid.ksmdStreamWinner_iff_streamEntry_cutClasses` | None | | `KannoSoe.Grid.ksmdNonReturner_iff_nonReturn_cut` | None | | `KannoSoe.Grid.ksmdSerialFactorRegime_conditional` | None | | `KannoSoe.Grid.ksmdOnceReturner_attenuation_witness` | `propext` | | `KannoSoe.FactorsNegative.no_hold_conceit_boundary_recovery` | `propext` | | `KannoSoe.FactorsNegative.factor_order_underdetermined` | `propext` | | `KannoSoe.FettersNegative.seen_run_underdetermines_fetterCut` | `propext` | | `KannoSoe.Grid.DirectedConvention.ksmdPathOught_conditional` | None | | `KannoSoe.Grid.DirectedConvention.ksmdFaithOught_conditional` | None | | `KannoSoe.Grid.DirectedConvention.ksmd_says_true_of_faith` | None | | `KannoSoe.Grid.DirectedConvention.noDelusion_of_noNescience_of_terminus` | None | | `KannoSoe.Grid.DirectedConvention.ksmdFullyEnlightened_of_fullyEnlightenedEnacted` | None | | `KannoSoe.FaithNegative.noNescience_strictly_stronger_witness` | `propext` | | `KannoSoe.FaithNegative.aklishta_ajnana_witness` | `propext` | | `KannoSoe.FaithNegative.arhat_retains_nescience_witness` | `propext` | | `KannoSoe.FaithNegative.Sealed.silent_buddha_models` | `propext` | | `KannoSoe.Grid.DirectedConvention.no_ksmd_path_at_pole` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.rowOf_obeys` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.pole_validates_all_claims` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.denied_misfits_live_offer` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.rowOf_obeys_iff_errorFree` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.reEmptied_obeys_of_errorFree` | None | | `KannoSoe.rung_not_pole_witness` | `propext` | | `KannoSoe.standing_does_not_determine_dated` | `propext` | | `KannoSoe.Grid.DirectedConvention.map_ksmdAversionContext_iff` | None | | `KannoSoe.OrthogonalityNegative.ksmdEffectiveTerminus_stronger_than_terminus` | `propext` | | `KannoSoe.MisFeedNegative.fence_and_gate` | `propext` | | `KannoSoe.misFeed_entries_carry_decomposition` | None | | `KannoSoe.Grid.grade_independent_of_conditions` | None | | `KannoSoe.Grid.rePitch_forgets` | None | | `KannoSoe.Grid.respondsToEveryCall_of_no_call` | None | | `KannoSoe.Grid.DirectedConvention.PrudentialPrivilegeNegative.prudentialPrivilege_failure_modes` | `propext` | | `KannoSoe.Grid.ConsequentialistConvention.dropCountInFiber_le_dropCount` | `propext` | | `KannoSoe.Grid.ConsequentialistConvention.dropCount_eq_sum_dropCountInFiber` | `propext` | | `KannoSoe.Grid.ConsequentialistConvention.map_dropCountInFiberSum` | `propext` | | `KannoSoe.ObjectiveNegative.split_dropCount_sum_eq_mergedDropCount` | `propext` | | `KannoSoe.ObjectiveNegative.no_grid_data_objective_for_my_drops` | `propext` | | `KannoSoe.TransferNegative.adaptive_track_record_underdetermines_new_effect` | `propext` | | `KannoSoe.Grid.DirectedConvention.not_effectivenessEnacted_of_undelivered` | None | | `KannoSoe.EffectiveTerminusNegative.no_effectiveTerminus_recovery_from_run` | `propext` | | `KannoSoe.DeliveryArrogationNegative.command_utterance_not_fits` | `propext` | | `KannoSoe.Grid.DirectedConvention.landing_call_in_modality` | None | | `KannoSoe.LedgerCase.decree_engineers_calls_not_receptions` | `propext` | | `KannoSoe.LedgerCase.official_actualAgentInhabited` | `propext` | | `KannoSoe.InteriorDirectionNegative.transposeCR_involutive` | `propext` | | `KannoSoe.InteriorDirectionNegative.unorderedCRContent_transpose_invariant` | `propext` | | `KannoSoe.InteriorDirectionNegative.transpose_swaps_readings` | `propext` | | `KannoSoe.DoerDeedNegative.priority_readings_disagree` | None | | `KannoSoe.DoerDeedNegative.no_priority_recovery` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.intraWeldArrowRow_obeys` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.intraWeldArrowRow_not_freeze` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.no_order_collapse_self_refuting` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.doerDeedRow_obeys` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.doerDeedRow_not_freeze` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.no_prior_doer_collapse_self_refuting` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.contentLayerRow_obeys_of_variation` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.contentIntraWeldArrowRow_obeys_of_variation` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.interior_order_denial_unfit_for_live_utterer` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.intraWeldArrowLadder_obeys` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.intraWeldArrowLadder_obeys_succ` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.intraWeldArrowLadder_no_level_final` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.doerDeedLadder_obeys` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.doerDeedLadder_obeys_succ` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.doerDeedLadder_no_level_final` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.Metaphysics.intraWeldArrow_sunyata` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.Metaphysics.doerDeed_sunyata` | None | | `KannoSoe.Grid.map_responseVariesWithCall_iff` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.map_intraWeldArrowRow_obeys` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.map_doerDeedRow_obeys` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.map_contentIntraWeldArrowRow_obeys_of_variation` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.map_intraWeldArrowLadder_obeys` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.map_intraWeldArrowLadder_obeys_succ` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.map_intraWeldArrowLadder_no_level_final` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.map_doerDeedLadder_obeys` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.map_doerDeedLadder_obeys_succ` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.map_doerDeedLadder_no_level_final` | None | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.ladderRungGrid_beings_sunyata` | `propext` | | `KannoSoe.Grid.DirectedConvention.BeingConvention.GridConvention.ladderRungGrid_no_level_final` | `propext` |