SHA-256: ef128d5e67a2e80d086fe83ede585149eadb28ba69a1000832b3db7967c02850

import Mathlib

/-!
# Lambda: the equal-standard instrument, successor R1
Authorial program: Lu Semita / EmergenceByDesign. Consolidated 2026-09-13.
This file proves the declared mathematical contracts. Case parameters do not
silently import a PDE, a quantum field theory, or an arithmetic equivalence.
The source and receipt, together, delimit the meaning of `verified`.
-/
namespace LambdaInstrument

-- A. Information, target recovery, and declared changes.
def Recoverable {X Y Z : Type*} (read : X → Y) (target : X → Z) : Prop :=
  ∃ decode : Y → Z, ∀ x, decode (read x) = target x

theorem recovery_iff_fibre_constancy {X Y Z : Type*} [Nonempty Z]
    (read : X → Y) (target : X → Z) :
    Recoverable read target ↔
      ∀ x y, read x = read y → target x = target y := by
  classical
  constructor
  · rintro ⟨d, hd⟩ x y h
    rw [← hd x, ← hd y, h]
  · intro h
    let d : Y → Z := fun y => if hy : ∃ x, read x = y
      then target (Classical.choose hy) else Classical.choice inferInstance
    refine ⟨d, ?_⟩
    intro x
    have hx : ∃ a, read a = read x := ⟨x, rfl⟩
    simp only [d, dite_eq_left hx]
    exact h _ x (Classical.choose_spec hx)

theorem collision_blocks_recovery {X Y Z : Type*}
    (read : X → Y) (target : X → Z) {a b : X}
    (same : read a = read b) (split : target a ≠ target b) :
    ¬ Recoverable read target := by
  rintro ⟨d, hd⟩
  apply split
  rw [← hd a, ← hd b, same]

theorem postprocessing_preserves_collision {X Y Z : Type*}
    (read : X → Y) (post : Y → Z) {a b : X}
    (h : read a = read b) : post (read a) = post (read b) := congrArg post h

theorem enriched_readout_recovers_target {X Y Z : Type*}
    (read : X → Y) (target : X → Z) :
    Recoverable (fun x => (read x, target x)) target := ⟨Prod.snd, fun _ => rfl⟩

theorem one_sided_certificate_contract {X Y : Type*}
    (read : X → Y) (fires : Y → Prop) (target : X → Prop) :
    (∀ x, fires (read x) → target x) ↔
      {x | fires (read x)} ⊆ {x | target x} := Iff.rfl

theorem entailed_condition_preserves_acceptance {X : Type*}
    (accept condition : X → Prop) (h : ∀ x, accept x → condition x) :
    ∀ x, (accept x ∧ condition x) ↔ accept x := by
  intro x
  exact ⟨And.left, fun ha => ⟨ha, h x ha⟩⟩

theorem new_condition_changes_acceptance {X : Type*}
    (accept condition : X → Prop) {x : X}
    (ha : accept x) (hc : ¬ condition x) :
    ¬ (∀ y, (accept y ∧ condition y) ↔ accept y) := by
  intro h
  exact hc ((h x).mpr ha).2

theorem equal_declared_inputs_equal_outputs {X Y Z : Type*}
    (read : X → Y) (judge : X → Z) (h : Recoverable read judge)
    {a b : X} (same : read a = read b) : judge a = judge b := by
  obtain ⟨d, hd⟩ := h
  rw [← hd a, ← hd b, same]

theorem different_outputs_require_distinction {X Y Z : Type*}
    (read : X → Y) (judge : X → Z) (h : Recoverable read judge)
    {a b : X} (split : judge a ≠ judge b) : read a ≠ read b := by
  intro same
  exact split (equal_declared_inputs_equal_outputs read judge h same)

-- B. Burden reversal: missing refutation versus a proof of existence.
theorem no_refutation_is_not_a_general_proof :
    ¬ (∀ (certified : Prop → Prop) (P : Prop),
      (∀ Q, certified Q → Q) → ¬ certified (¬ P) → P) := by
  intro h
  exact h (fun _ => False) False (fun _ hf => hf.elim) (fun hf => hf)

theorem completeness_licenses_reversal
    (certified : Prop → Prop) (P : Prop)
    (completeAtNegation : (¬ P) → certified (¬ P))
    (noRefutation : ¬ certified (¬ P)) : P := by
  classical
  by_contra h
  exact noRefutation (completeAtNegation h)

theorem existential_claim_needs_no_closed_form {X : Type*} (P : X → Prop)
    (construction : ∃ x, P x) : ¬ (∀ x, ¬ P x) := by
  rintro h
  obtain ⟨x, hx⟩ := construction
  exact h x hx

theorem residual_equation_has_witness {X F : Type*} (residual : X → F) (x : X) :
    ∃ f, f = residual x := ⟨residual x, rfl⟩

theorem residual_admissibility_is_the_obligation {X F : Type*}
    (residual : X → F) (admitted : F → Prop) (x : X) :
    (∃ f, f = residual x ∧ admitted f) ↔ admitted (residual x) := by
  constructor
  · rintro ⟨f, rfl, hf⟩
    exact hf
  · intro h
    exact ⟨residual x, rfl, h⟩

-- C. Finite observation and an all-stage target.
def AllStages (P : ℕ → Prop) : Prop := ∀ n, P n
def Window (N : ℕ) (P : ℕ → Prop) : Prop := ∀ n, n < N → P n

theorem finite_window_has_opposite_extensions (N : ℕ) :
    ∃ good bad : ℕ → Prop,
      Window N good ∧ Window N bad ∧ AllStages good ∧ ¬ AllStages bad := by
  refine ⟨fun _ => True, fun n => n < N, ?_, ?_, ?_, ?_⟩
  · intro n hn; trivial
  · intro n hn; exact hn
  · intro n; trivial
  · intro h; exact Nat.lt_irrefl N (h N)

theorem no_fixed_window_decides_unrestricted_tail (N : ℕ) :
    ¬ (∀ P : ℕ → Prop, Window N P → AllStages P) := by
  intro h
  exact Nat.lt_irrefl N (h (fun n => n < N) (fun _ hn => hn) N)

theorem universal_proof_closes_all_windows (P : ℕ → Prop)
    (h : AllStages P) : ∀ N, Window N P := fun _ n _ => h n

theorem all_windows_iff_all_stages (P : ℕ → Prop) :
    (∀ N, Window N P) ↔ AllStages P := by
  constructor
  · intro h n; exact h (n + 1) n (Nat.lt_succ_self n)
  · exact universal_proof_closes_all_windows P

theorem actual_failure_refutes_tail (P : ℕ → Prop) {n : ℕ}
    (failure : ¬ P n) : ¬ AllStages P := fun h => failure (h n)

theorem tail_negation_has_failure (P : ℕ → Prop) :
    ¬ AllStages P ↔ ∃ n, ¬ P n := by
  classical
  simp [AllStages]

-- D. Navier-Stokes: the official force-quantifier relationship, abstract carrier.
def NSGlobal {D F : Type*} (admD : D → Prop) (global : D → F → Prop)
    (zeroForce : F) : Prop := ∀ d, admD d → global d zeroForce
def NSForcedFailure {D F : Type*} (admD : D → Prop) (admF : F → Prop)
    (global : D → F → Prop) : Prop :=
  ∃ d f, admD d ∧ admF f ∧ ¬ global d f

theorem unforced_failure_is_admitted_forced_failure {D F : Type*}
    (admD : D → Prop) (admF : F → Prop) (global : D → F → Prop)
    (zeroForce : F) (zeroAdmitted : admF zeroForce)
    (failure : ¬ NSGlobal admD global zeroForce) :
    NSForcedFailure admD admF global := by
  classical
  unfold NSGlobal at failure
  push Not at failure
  obtain ⟨d, hd, hn⟩ := failure
  exact ⟨d, zeroForce, hd, zeroAdmitted, hn⟩

theorem forced_failure_can_coexist_with_unforced_global :
    ∃ global : Unit → Bool → Prop,
      NSGlobal (fun _ => True) global false ∧
      NSForcedFailure (fun _ => True) (fun _ => True) global := by
  refine ⟨fun _ f => f = false, ?_, ?_⟩
  · intro d hd; rfl
  · exact ⟨(), true, trivial, trivial, Bool.noConfusion⟩

def NSRegular {D : Type*} (regularWindow : D → ℕ → Prop) (d : D) : Prop :=
  ∀ n, regularWindow d n
def NSBlowup {D Time : Type*} (before : D → Time → Prop)
    (size : D → Time → ℝ) (d : D) : Prop :=
  ∀ M : ℝ, ∃ t, before d t ∧ M < size d t

theorem ns_regularity_requires_each_window {D : Type*}
    (window : D → ℕ → Prop) (d : D) :
    NSRegular window d ↔ ∀ N, Window N (window d) :=
  (all_windows_iff_all_stages (window d)).symm

theorem ns_uniform_bound_excludes_encoded_blowup {D Time : Type*}
    (before : D → Time → Prop) (size : D → Time → ℝ) (d : D)
    (bound : ∃ K, ∀ t, before d t → size d t ≤ K) :
    ¬ NSBlowup before size d := by
  rintro h
  obtain ⟨K, hK⟩ := bound
  obtain ⟨t, ht, hb⟩ := h K
  exact (not_lt_of_ge (hK t ht)) hb

theorem invariant_exact_classifier {X : Type*} (move : X → X)
    (H B : X → Prop) (equiv : ∀ x, H x ↔ B x)
    (inv : ∀ x, B (move x) ↔ B x) : ∀ x, H (move x) ↔ H x := by
  intro x
  exact (equiv (move x)).trans ((inv x).trans (equiv x).symm)

theorem sufficient_condition_need_not_be_invariant :
    ∃ H B : Bool → Prop,
      (∀ x, H x → B x) ∧ (∀ x, B (!x) ↔ B x) ∧
      ¬ (H (!false) ↔ H false) := by
  refine ⟨fun b => b = false, fun _ => True, ?_, ?_, ?_⟩
  · intro x hx; trivial
  · intro x; rfl
  · simp

-- E. Riemann: direct zero predicate and an explicitly bridged tail coding.
def RHForm {Zero : Type*} (nontrivial onLine : Zero → Prop) : Prop :=
  ∀ z, nontrivial z → onLine z

theorem rh_counterexample_duality {Zero : Type*} (nontrivial onLine : Zero → Prop) :
    ¬ RHForm nontrivial onLine ↔ ∃ z, nontrivial z ∧ ¬ onLine z := by
  classical
  simp [RHForm]

theorem rh_tail_transport {Zero : Type*} (nontrivial onLine : Zero → Prop)
    (test : ℕ → Prop) (bridge : RHForm nontrivial onLine ↔ AllStages test)
    (closure : ∀ n, test n) : RHForm nontrivial onLine := bridge.mpr closure

-- F. Yang-Mills: one common positive bound and the continuum theory obligation.
def UniformGap {State : Type*} (excited : State → Prop) (energy : State → ℝ) : Prop :=
  ∃ δ : ℝ, 0 < δ ∧ ∀ s, excited s → δ ≤ energy s
def YMForm {Group Theory State : Type*} (admissibleGroup : Group → Prop)
    (validTheory : Group → Theory → Prop)
    (excited : Theory → State → Prop) (energy : Theory → State → ℝ) : Prop :=
  ∀ g, admissibleGroup g → ∃ t, validTheory g t ∧ UniformGap (excited t) (energy t)

theorem uniform_gap_implies_pointwise_positive {State : Type*}
    (excited : State → Prop) (energy : State → ℝ)
    (h : UniformGap excited energy) : ∀ s, excited s → 0 < energy s := by
  obtain ⟨δ, hδ, hs⟩ := h
  intro s he
  exact lt_of_lt_of_le hδ (hs s he)

theorem pointwise_positive_need_not_have_uniform_gap :
    (∀ x : {r : ℝ // 0 < r}, 0 < x.val) ∧
    ¬ UniformGap (fun _ : {r : ℝ // 0 < r} => True) (fun x => x.val) := by
  refine ⟨fun x => x.property, ?_⟩
  rintro ⟨δ, hδ, hs⟩
  have h := hs ⟨δ / 2, by linarith⟩ trivial
  dsimp at h
  linarith

theorem common_gap_survives_order_limit {State : Type*}
    (excited : State → Prop) (energy : State → ℝ) (approx : ℕ → State → ℝ)
    (δ : ℝ) (positive : 0 < δ)
    (bounds : ∀ n s, excited s → δ ≤ approx n s)
    (passToLimit : ∀ s, (∀ n, δ ≤ approx n s) → δ ≤ energy s) :
    UniformGap excited energy := by
  refine ⟨δ, positive, ?_⟩
  intro s hs
  exact passToLimit s (fun n => bounds n s hs)

-- G. Hodge: exact cycle-class image, finite witness, global quantifier.
def HodgeForm {Instance Cycle : Type*} (admitted : Instance → Prop)
    (represents : Cycle → Instance → Prop) : Prop :=
  ∀ i, admitted i → ∃ c, represents c i

theorem hodge_actual_cycle_closes_instance {Instance Cycle : Type*}
    (represents : Cycle → Instance → Prop) (i : Instance) (c : Cycle)
    (certificate : represents c i) : ∃ w, represents w i := ⟨c, certificate⟩

theorem hodge_nonmembership_requires_all_cycles {Instance Cycle : Type*}
    (represents : Cycle → Instance → Prop) (i : Instance) :
    (¬ ∃ c, represents c i) ↔ ∀ c, ¬ represents c i := by simp

theorem hodge_separating_invariant_closes_nonmembership {Instance Cycle : Type*}
    (represents : Cycle → Instance → Prop) (invariant : Instance → Prop)
    (sound : ∀ c i, represents c i → invariant i) {i : Instance}
    (separates : ¬ invariant i) : ¬ ∃ c, represents c i := by
  rintro ⟨c, hc⟩
  exact separates (sound c i hc)

theorem hodge_finite_empty_search_not_universal (S : Finset ℕ) :
    ∃ witness : ℕ → Prop, (∀ n ∈ S, ¬ witness n) ∧ ∃ n, witness n := by
  let m := S.sup id + 1
  have hm : m ∉ S := by
    intro h
    have hh := Finset.le_sup (f := id) h
    dsimp [m] at *
    omega
  refine ⟨fun n => n = m, ?_, m, rfl⟩
  intro n hn heq
  exact hm (heq ▸ hn)

-- H. P versus NP: candidates include a machine and a polynomial clock.
def PolyCandidateForm {Candidate Input : Type*} (correct : Candidate → Input → Prop) : Prop :=
  ∃ c, ∀ x, correct c x

theorem pnp_quantifier_duality {Candidate Input : Type*}
    (correct : Candidate → Input → Prop) :
    ¬ PolyCandidateForm correct ↔ ∀ c, ∃ x, ¬ correct c x := by
  classical
  simp [PolyCandidateForm]

theorem pnp_candidate_with_all_input_proof_closes {Candidate Input : Type*}
    (correct : Candidate → Input → Prop) (c : Candidate)
    (allInputs : ∀ x, correct c x) : PolyCandidateForm correct := ⟨c, allInputs⟩

theorem bounded_tests_do_not_prove_candidate (N : ℕ) :
    ∃ correct : Unit → ℕ → Prop,
      (∀ n, n < N → correct () n) ∧ ¬ PolyCandidateForm correct := by
  refine ⟨fun _ n => n < N, fun _ h => h, ?_⟩
  rintro ⟨c, h⟩
  exact Nat.lt_irrefl N (h N)

-- I. BSD: rank comparison, analytic order, and product identification.
def BSDRankForm {Curve : Type*} (algRank anRank : Curve → ℕ) : Prop :=
  ∀ E, algRank E = anRank E
def ExactOrder (coefficient : ℕ → ℝ) (r : ℕ) : Prop :=
  (∀ n, n < r → coefficient n = 0) ∧ coefficient r ≠ 0

theorem bsd_matching_bounds_close_rank (rank lower upper : ℕ)
    (hl : lower ≤ rank) (hu : rank ≤ upper) (meet : lower = upper) :
    rank = lower := by omega

theorem bsd_matching_certificates_close_instance (alg an lower upper : ℕ)
    (hl : lower ≤ alg) (hu : alg ≤ upper) (meet : lower = upper)
    (analytic : an = lower) : alg = an := by omega

theorem exact_order_unique (a : ℕ → ℝ) {r s : ℕ}
    (hr : ExactOrder a r) (hs : ExactOrder a s) : r = s := by
  by_contra h
  rcases lt_or_gt_of_ne h with hlt | hgt
  · exact hr.2 (hs.1 r hlt)
  · exact hs.2 (hr.1 s hgt)

theorem nonzero_term_alone_not_exact_order :
    ∃ a : ℕ → ℝ, a 1 ≠ 0 ∧ ¬ ExactOrder a 1 := by
  refine ⟨fun _ => 1, one_ne_zero, ?_⟩
  intro h
  exact one_ne_zero (h.1 0 (by omega))

theorem product_readout_loses_factor :
    ¬ Recoverable (fun p : ℝ × ℝ => p.1 * p.2) Prod.fst := by
  apply collision_blocks_recovery _ _ (a := (1, 6)) (b := (2, 3))
  · norm_num
  · norm_num

theorem anchored_product_recovers_factor (a b c : ℝ) (ha : a ≠ 0)
    (h : a * b = a * c) : b = c := (mul_left_cancel₀ ha) h

-- J. Pi and e: exact representation classes and a substantive positive control.
theorem pi_outside_rational_image : ¬ ∃ q : ℚ, (q : ℝ) = Real.pi := by
  rintro ⟨q, hq⟩
  exact irrational_pi ⟨q, hq⟩

theorem pi_no_finite_base_fraction (a : ℤ) (b n : ℕ) :
    Real.pi ≠ (a : ℝ) / (b : ℝ) ^ n := by
  have h := irrational_pi.ne_rational a (b ^ n)
  simpa only [Int.cast_pow, Int.cast_natCast] using h

theorem irrational_can_have_arbitrarily_close_rationals (x : ℝ) (ε : ℝ)
    (hε : 0 < ε) : ∃ q : ℚ, 0 < (q : ℝ) - x ∧ (q : ℝ) - x < ε := by
  obtain ⟨q, hq₁, hq₂⟩ := exists_rat_btwn (show x < x + ε by linarith)
  exact ⟨q, by linarith, by linarith⟩

theorem transcendental_excludes_algebraic_representation (x : ℝ)
    (hx : Transcendental ℚ x) :
    ¬ ∃ y : ℝ, IsAlgebraic ℚ y ∧ y = x := by
  rintro ⟨y, hy, rfl⟩
  exact hx hy

theorem enlarged_real_polynomials_have_exact_root (x : ℝ) :
    ∃ p : Polynomial ℝ, p ≠ 0 ∧ p.eval x = 0 := by
  refine ⟨Polynomial.X - Polynomial.C x, ?_, ?_⟩
  · intro h
    have hc := congrArg (fun p : Polynomial ℝ => p.coeff 1) h
    simp at hc
  · simp

theorem e_exceeds_every_finite_factorial_sum (n : ℕ) :
    (∑ i ∈ Finset.range n, (1 : ℝ) / i.factorial) < Real.exp 1 := by
  have h := Real.sum_le_exp_of_nonneg (show (0 : ℝ) ≤ 1 by norm_num) (n + 1)
  simp only [Finset.sum_range_succ, one_pow] at h
  have hp : (0 : ℝ) < 1 / (n.factorial : ℝ) := by positivity
  linarith

theorem e_algebraic_class_closure_contract (h : Transcendental ℚ (Real.exp 1)) :
    ∀ p : Polynomial ℚ, p ≠ 0 → Polynomial.aeval (Real.exp 1) p ≠ 0 := by
  intro p hp he
  exact hp ((transcendental_iff.mp h) p he)

-- K. Reader instrument. Status completeness is a declared datatype contract.
inductive Status where
  | accepted | rejected | open | scopeChange
  deriving DecidableEq, Repr

structure Assessment (Claim Scope Evidence : Type*) where
  claim : Claim
  scope : Scope
  evidence : Evidence
  rule : Scope → Evidence → Status
  verdict : Status
  receipt : rule scope evidence = verdict

theorem consideration_has_an_applied_rule {C S E : Type*}
    (a : Assessment C S E) :
    ∃ rule : S → E → Status, rule a.scope a.evidence = a.verdict := ⟨a.rule, a.receipt⟩

theorem challenge_is_an_instance {C S E : Type*}
    (a : Assessment C S E) (rejects : a.verdict = Status.rejected) :
    a.rule a.scope a.evidence = Status.rejected := a.receipt.trans rejects

theorem shared_rule_scope_evidence_force_shared_status {C S E : Type*}
    (a b : Assessment C S E) (hr : a.rule = b.rule)
    (hs : a.scope = b.scope) (he : a.evidence = b.evidence) :
    a.verdict = b.verdict := by rw [← a.receipt, ← b.receipt, hr, hs, he]

theorem same_evidence_can_support_different_declared_rules :
    ∃ a b : Assessment Unit Unit Unit,
      a.claim = b.claim ∧ a.scope = b.scope ∧ a.evidence = b.evidence ∧
      a.verdict ≠ b.verdict := by
  refine ⟨⟨(), (), (), fun _ _ => .accepted, .accepted, rfl⟩,
    ⟨(), (), (), fun _ _ => .rejected, .rejected, rfl⟩, rfl, rfl, rfl, ?_⟩
  intro h; cases h

theorem receipt_does_not_certify_rule_soundness :
    ∃ a : Assessment Prop Unit Unit,
      a.claim = False ∧ a.verdict = Status.accepted :=
  ⟨⟨False, (), (), fun _ _ => .accepted, .accepted, rfl⟩, rfl, rfl⟩

theorem a_sound_rejection_can_defeat_a_claim (P : Prop)
    (soundRejection : ¬ P) : ¬ P := soundRejection

structure Record where
  text : String
  status : Status
  scope : String
  reason : String
  actor : String
  parent : Option ℕ
  deriving Repr

def append (history : List Record) (r : Record) : List Record := history ++ [r]

theorem any_finite_comment_can_be_registered (s : String) :
    ∃ r : Record, r.text = s := ⟨⟨s, .open, "unassigned", "awaiting classification", "unassigned", none⟩, rfl⟩

theorem append_preserves_earlier_records (history : List Record) (r old : Record)
    (h : old ∈ history) : old ∈ append history r := by simp [append, h]

theorem finite_registry_has_no_fixed_capacity (history : List Record) (r : Record) :
    (append history r).length = history.length + 1 := by simp [append]

theorem declared_statuses_exhaustive (s : Status) :
    s = .accepted ∨ s = .rejected ∨ s = .open ∨ s = .scopeChange := by cases s <;> simp

inductive StopMode (Actor : Type*) where
  | effective (testRan : Bool) (checked : testRan = true)
  | declared (actor : Actor)

theorem stop_mode_contract {Actor : Type*} (s : StopMode Actor) :
    (∃ b h, s = StopMode.effective b h) ∨
      (∃ actor, s = StopMode.declared actor) := by
  cases s with
  | effective b h => exact Or.inl ⟨b, h, rfl⟩
  | declared actor => exact Or.inr ⟨actor, rfl⟩

end LambdaInstrument

-- Exact theorem statements and transitive axiom dependencies.
#check LambdaInstrument.recovery_iff_fibre_constancy
#print axioms LambdaInstrument.recovery_iff_fibre_constancy
#check LambdaInstrument.collision_blocks_recovery
#print axioms LambdaInstrument.collision_blocks_recovery
#check LambdaInstrument.postprocessing_preserves_collision
#print axioms LambdaInstrument.postprocessing_preserves_collision
#check LambdaInstrument.enriched_readout_recovers_target
#print axioms LambdaInstrument.enriched_readout_recovers_target
#check LambdaInstrument.one_sided_certificate_contract
#print axioms LambdaInstrument.one_sided_certificate_contract
#check LambdaInstrument.entailed_condition_preserves_acceptance
#print axioms LambdaInstrument.entailed_condition_preserves_acceptance
#check LambdaInstrument.new_condition_changes_acceptance
#print axioms LambdaInstrument.new_condition_changes_acceptance
#check LambdaInstrument.equal_declared_inputs_equal_outputs
#print axioms LambdaInstrument.equal_declared_inputs_equal_outputs
#check LambdaInstrument.different_outputs_require_distinction
#print axioms LambdaInstrument.different_outputs_require_distinction
#check LambdaInstrument.no_refutation_is_not_a_general_proof
#print axioms LambdaInstrument.no_refutation_is_not_a_general_proof
#check LambdaInstrument.completeness_licenses_reversal
#print axioms LambdaInstrument.completeness_licenses_reversal
#check LambdaInstrument.existential_claim_needs_no_closed_form
#print axioms LambdaInstrument.existential_claim_needs_no_closed_form
#check LambdaInstrument.residual_equation_has_witness
#print axioms LambdaInstrument.residual_equation_has_witness
#check LambdaInstrument.residual_admissibility_is_the_obligation
#print axioms LambdaInstrument.residual_admissibility_is_the_obligation
#check LambdaInstrument.finite_window_has_opposite_extensions
#print axioms LambdaInstrument.finite_window_has_opposite_extensions
#check LambdaInstrument.no_fixed_window_decides_unrestricted_tail
#print axioms LambdaInstrument.no_fixed_window_decides_unrestricted_tail
#check LambdaInstrument.universal_proof_closes_all_windows
#print axioms LambdaInstrument.universal_proof_closes_all_windows
#check LambdaInstrument.all_windows_iff_all_stages
#print axioms LambdaInstrument.all_windows_iff_all_stages
#check LambdaInstrument.actual_failure_refutes_tail
#print axioms LambdaInstrument.actual_failure_refutes_tail
#check LambdaInstrument.tail_negation_has_failure
#print axioms LambdaInstrument.tail_negation_has_failure
#check LambdaInstrument.unforced_failure_is_admitted_forced_failure
#print axioms LambdaInstrument.unforced_failure_is_admitted_forced_failure
#check LambdaInstrument.forced_failure_can_coexist_with_unforced_global
#print axioms LambdaInstrument.forced_failure_can_coexist_with_unforced_global
#check LambdaInstrument.ns_regularity_requires_each_window
#print axioms LambdaInstrument.ns_regularity_requires_each_window
#check LambdaInstrument.ns_uniform_bound_excludes_encoded_blowup
#print axioms LambdaInstrument.ns_uniform_bound_excludes_encoded_blowup
#check LambdaInstrument.invariant_exact_classifier
#print axioms LambdaInstrument.invariant_exact_classifier
#check LambdaInstrument.sufficient_condition_need_not_be_invariant
#print axioms LambdaInstrument.sufficient_condition_need_not_be_invariant
#check LambdaInstrument.rh_counterexample_duality
#print axioms LambdaInstrument.rh_counterexample_duality
#check LambdaInstrument.rh_tail_transport
#print axioms LambdaInstrument.rh_tail_transport
#check LambdaInstrument.uniform_gap_implies_pointwise_positive
#print axioms LambdaInstrument.uniform_gap_implies_pointwise_positive
#check LambdaInstrument.pointwise_positive_need_not_have_uniform_gap
#print axioms LambdaInstrument.pointwise_positive_need_not_have_uniform_gap
#check LambdaInstrument.common_gap_survives_order_limit
#print axioms LambdaInstrument.common_gap_survives_order_limit
#check LambdaInstrument.hodge_actual_cycle_closes_instance
#print axioms LambdaInstrument.hodge_actual_cycle_closes_instance
#check LambdaInstrument.hodge_nonmembership_requires_all_cycles
#print axioms LambdaInstrument.hodge_nonmembership_requires_all_cycles
#check LambdaInstrument.hodge_separating_invariant_closes_nonmembership
#print axioms LambdaInstrument.hodge_separating_invariant_closes_nonmembership
#check LambdaInstrument.hodge_finite_empty_search_not_universal
#print axioms LambdaInstrument.hodge_finite_empty_search_not_universal
#check LambdaInstrument.pnp_quantifier_duality
#print axioms LambdaInstrument.pnp_quantifier_duality
#check LambdaInstrument.pnp_candidate_with_all_input_proof_closes
#print axioms LambdaInstrument.pnp_candidate_with_all_input_proof_closes
#check LambdaInstrument.bounded_tests_do_not_prove_candidate
#print axioms LambdaInstrument.bounded_tests_do_not_prove_candidate
#check LambdaInstrument.bsd_matching_bounds_close_rank
#print axioms LambdaInstrument.bsd_matching_bounds_close_rank
#check LambdaInstrument.bsd_matching_certificates_close_instance
#print axioms LambdaInstrument.bsd_matching_certificates_close_instance
#check LambdaInstrument.exact_order_unique
#print axioms LambdaInstrument.exact_order_unique
#check LambdaInstrument.nonzero_term_alone_not_exact_order
#print axioms LambdaInstrument.nonzero_term_alone_not_exact_order
#check LambdaInstrument.product_readout_loses_factor
#print axioms LambdaInstrument.product_readout_loses_factor
#check LambdaInstrument.anchored_product_recovers_factor
#print axioms LambdaInstrument.anchored_product_recovers_factor
#check LambdaInstrument.pi_outside_rational_image
#print axioms LambdaInstrument.pi_outside_rational_image
#check LambdaInstrument.pi_no_finite_base_fraction
#print axioms LambdaInstrument.pi_no_finite_base_fraction
#check LambdaInstrument.irrational_can_have_arbitrarily_close_rationals
#print axioms LambdaInstrument.irrational_can_have_arbitrarily_close_rationals
#check LambdaInstrument.transcendental_excludes_algebraic_representation
#print axioms LambdaInstrument.transcendental_excludes_algebraic_representation
#check LambdaInstrument.enlarged_real_polynomials_have_exact_root
#print axioms LambdaInstrument.enlarged_real_polynomials_have_exact_root
#check LambdaInstrument.e_exceeds_every_finite_factorial_sum
#print axioms LambdaInstrument.e_exceeds_every_finite_factorial_sum
#check LambdaInstrument.e_algebraic_class_closure_contract
#print axioms LambdaInstrument.e_algebraic_class_closure_contract
#check LambdaInstrument.consideration_has_an_applied_rule
#print axioms LambdaInstrument.consideration_has_an_applied_rule
#check LambdaInstrument.challenge_is_an_instance
#print axioms LambdaInstrument.challenge_is_an_instance
#check LambdaInstrument.shared_rule_scope_evidence_force_shared_status
#print axioms LambdaInstrument.shared_rule_scope_evidence_force_shared_status
#check LambdaInstrument.same_evidence_can_support_different_declared_rules
#print axioms LambdaInstrument.same_evidence_can_support_different_declared_rules
#check LambdaInstrument.receipt_does_not_certify_rule_soundness
#print axioms LambdaInstrument.receipt_does_not_certify_rule_soundness
#check LambdaInstrument.a_sound_rejection_can_defeat_a_claim
#print axioms LambdaInstrument.a_sound_rejection_can_defeat_a_claim
#check LambdaInstrument.any_finite_comment_can_be_registered
#print axioms LambdaInstrument.any_finite_comment_can_be_registered
#check LambdaInstrument.append_preserves_earlier_records
#print axioms LambdaInstrument.append_preserves_earlier_records
#check LambdaInstrument.finite_registry_has_no_fixed_capacity
#print axioms LambdaInstrument.finite_registry_has_no_fixed_capacity
#check LambdaInstrument.declared_statuses_exhaustive
#print axioms LambdaInstrument.declared_statuses_exhaustive
#check LambdaInstrument.stop_mode_contract
#print axioms LambdaInstrument.stop_mode_contract
#eval Lean.versionString
#eval "LAMBDA_INSTRUMENT_R1"


/-!
Part II: exact arithmetic, spectral projection, and indexed residue.
The ledger in the paper gives the scope of each declaration.
-/
namespace EnumerativeEnergy

theorem prime_iff_no_intermediate_divisor (n : ℕ) (hn : 2 ≤ n) :
    Nat.Prime n ↔ ¬ ∃ d : ℕ, d ∣ n ∧ 2 ≤ d ∧ d < n := by
  constructor
  · intro hp
    rintro ⟨d, hd, htwo, hlt⟩
    have hne : d ≠ 1 := by omega
    have heq := (hp.dvd_iff_eq hne).mp hd
    omega
  · intro h
    by_contra hnp
    exact h (Nat.exists_dvd_of_not_prime2 hn hnp)

theorem prime_step_gcd_one (p k : ℕ) (hp : Nat.Prime p)
    (hk : 0 < k) (hkp : k < p) : Nat.gcd p k = 1 := by
  exact (Nat.coprime_of_lt_prime (Nat.ne_of_gt hk) hkp hp).gcd_eq_one

theorem shared_divisibility (n m d : ℕ) :
    d ∣ Nat.gcd n m ↔ d ∣ n ∧ d ∣ m := by
  exact Nat.dvd_gcd_iff

theorem simultaneous_return (n m t : ℕ) :
    Nat.lcm n m ∣ t ↔ n ∣ t ∧ m ∣ t := by
  exact Nat.lcm_dvd_iff

def orbit {A : Type*} (f : A → A) : ℕ → A → A
  | 0, x => x
  | n + 1, x => f (orbit f n x)

theorem relabeling_preserves_orbit {A B : Type*}
    (e : A ≃ B) (f : A → A) (n : ℕ) (x : A) :
    orbit (fun y => e (f (e.symm y))) n (e x) = e (orbit f n x) := by
  induction n with
  | zero => rfl
  | succ n ih =>
    simp only [orbit, ih, Equiv.symm_apply_apply]

theorem relabeling_preserves_return {A B : Type*}
    (e : A ≃ B) (f : A → A) (n : ℕ) (x : A) :
    orbit (fun y => e (f (e.symm y))) n (e x) = e x ↔ orbit f n x = x := by
  rw [relabeling_preserves_orbit]
  exact e.injective.eq_iff

noncomputable def spectralRead (z : ℂ) : ℂ := 2 - z - z⁻¹

theorem inversion_preserves_spectral_read (z : ℂ) :
    spectralRead z⁻¹ = spectralRead z := by
  simp only [spectralRead, inv_inv]
  ring

theorem spectral_collision_has_two_branches (z w : ℂ)
    (hz : z ≠ 0) (hw : w ≠ 0) (h : spectralRead z = spectralRead w) :
    z = w ∨ z * w = 1 := by
  have hid : (spectralRead z - spectralRead w) * (z * w) =
      -(z - w) * (z * w - 1) := by
    dsimp [spectralRead]
    field_simp
    ring
  rw [h, sub_self, zero_mul] at hid
  have hp : (z - w) * (z * w - 1) = 0 := by
    linear_combination hid
  rcases mul_eq_zero.mp hp with heq | hinv
  · exact Or.inl (sub_eq_zero.mp heq)
  · exact Or.inr (sub_eq_zero.mp hinv)

theorem spectral_read_cannot_recover_phase (z : ℂ) (hz : z ≠ 0)
    (hd : z ≠ z⁻¹) :
    ¬ ∃ f : ℂ → ℂ, ∀ w : ℂ, w ≠ 0 → f (spectralRead w) = w := by
  rintro ⟨f, hf⟩
  have h1 := hf z hz
  have h2 := hf z⁻¹ (inv_ne_zero hz)
  rw [inversion_preserves_spectral_read] at h2
  exact hd (h1.symm.trans h2)

theorem ordered_count_from_union_data {A : Type*} [DecidableEq A]
    (s t : Finset A) (g f : ℕ)
    (hs : s.card = g) (ht : t.card = g) (hi : (s ∩ t).card = f) :
    (s ∪ t).card = 2 * g - f := by
  have h := Finset.card_union_add_card_inter s t
  omega

theorem common_energy_shift_preserves_gaps (a b offset : ℝ) :
    (a + offset) - (b + offset) = a - b := by ring

theorem calibration_rescaling_preserves_phase (scale energy time : ℝ)
    (hs : scale ≠ 0) :
    (scale * energy) * (time / scale) = energy * time := by
  field_simp

noncomputable def indexedResidue {A : Type*} (S : Set A) (cost : A → ENNReal) : ENNReal :=
  sInf (cost '' S)

theorem residue_monotone {A : Type*} (S T : Set A)
    (cost : A → ENNReal) (h : S ⊆ T) :
    indexedResidue T cost ≤ indexedResidue S cost := by
  unfold indexedResidue
  apply sInf_le_sInf
  rintro y ⟨x, hx, rfl⟩
  exact ⟨x, h hx, rfl⟩

theorem conservative_representation_preserves_theorems {P T : Type*}
    (R0 R1 : Set P) (conclusion : P → T) (expand : P → P)
    (hin : R0 ⊆ R1)
    (hex : ∀ p ∈ R1, expand p ∈ R0 ∧ conclusion (expand p) = conclusion p)
    (target : T) :
    (∃ p ∈ R0, conclusion p = target) ↔ (∃ p ∈ R1, conclusion p = target) := by
  constructor
  · rintro ⟨p, hp, hc⟩
    exact ⟨p, hin hp, hc⟩
  · rintro ⟨p, hp, hc⟩
    obtain ⟨he, ht⟩ := hex p hp
    exact ⟨expand p, he, ht.trans hc⟩

theorem pointwise_positivity_not_uniform :
    (∀ x : ℝ, 0 < x → 0 < x) ∧
    ¬ ∃ epsilon : ℝ, 0 < epsilon ∧ ∀ x : ℝ, 0 < x → epsilon ≤ x := by
  constructor
  · intro x hx
    exact hx
  · rintro ⟨epsilon, he, hbound⟩
    have hhalf : 0 < epsilon / 2 := by linarith
    have hh := hbound (epsilon / 2) hhalf
    linarith

end EnumerativeEnergy

namespace LambdaPhysical

def boostTime (g b T x : ℝ) : ℝ := g * (T - b * x)
def boostSpace (g b T x : ℝ) : ℝ := g * (x - b * T)
def interval (T x : ℝ) : ℝ := x ^ 2 - T ^ 2

theorem boosted_time_needs_space (g b : ℝ) (hg : g ≠ 0) (hb : b ≠ 0) :
    ¬ ∃ f : ℝ → ℝ, ∀ T x, f T = boostTime g b T x := by
  rintro ⟨f, hf⟩
  have h0 := hf 0 0
  have h1 := hf 0 1
  simp only [boostTime, mul_zero, sub_zero] at h0
  simp only [boostTime, mul_one, zero_sub] at h1
  have hgb : g * b = 0 := by nlinarith
  exact (mul_ne_zero hg hb) hgb

theorem boosted_space_needs_time (g b : ℝ) (hg : g ≠ 0) (hb : b ≠ 0) :
    ¬ ∃ f : ℝ → ℝ, ∀ T x, f x = boostSpace g b T x := by
  rintro ⟨f, hf⟩
  have h0 := hf 0 0
  have h1 := hf 1 0
  simp only [boostSpace, mul_zero, sub_zero] at h0
  simp only [boostSpace, mul_one, zero_sub] at h1
  have hgb : g * b = 0 := by nlinarith
  exact (mul_ne_zero hg hb) hgb

theorem lorentz_interval_preserved (g b T x : ℝ)
    (hn : g ^ 2 * (1 - b ^ 2) = 1) :
    interval (boostTime g b T x) (boostSpace g b T x) = interval T x := by
  unfold interval boostTime boostSpace
  calc
    (g * (x - b * T)) ^ 2 - (g * (T - b * x)) ^ 2 =
        (g ^ 2 * (1 - b ^ 2)) * (x ^ 2 - T ^ 2) := by ring
    _ = x ^ 2 - T ^ 2 := by rw [hn]; ring

theorem lorentz_null_preserved (g b T x : ℝ)
    (hn : g ^ 2 * (1 - b ^ 2) = 1) :
    (interval (boostTime g b T x) (boostSpace g b T x) = 0) ↔
    interval T x = 0 := by
  rw [lorentz_interval_preserved g b T x hn]

theorem timelike_not_time_only :
    ¬ ∃ P : ℝ → Prop, ∀ T x, P T ↔ interval T x < 0 := by
  rintro ⟨P, h⟩
  have hp : P 1 := (h 1 0).mpr (by norm_num [interval])
  have hn := (h 1 2).mp hp
  norm_num [interval] at hn

theorem timelike_not_space_only :
    ¬ ∃ P : ℝ → Prop, ∀ T x, P x ↔ interval T x < 0 := by
  rintro ⟨P, h⟩
  have hp : P 1 := (h 2 1).mpr (by norm_num [interval])
  have hn := (h 0 1).mp hp
  norm_num [interval] at hn

theorem fixed_c_couples_unit_rescaling (c L U : ℝ)
    (hc : c ≠ 0) (hL : L ≠ 0) (h : c * U / L = c) : L = U := by
  have he : c * U = c * L := (div_eq_iff hL).mp h
  exact (mul_left_cancel₀ hc he).symm

theorem calibrated_ratios_determine_values {I : Type*}
    (r E F : I → ℝ) (anchor : ℝ)
    (hE : ∀ i, E i = r i * anchor)
    (hF : ∀ i, F i = r i * anchor) : E = F := by
  funext i
  exact (hE i).trans (hF i).symm


end LambdaPhysical

#check EnumerativeEnergy.prime_iff_no_intermediate_divisor
#check EnumerativeEnergy.prime_step_gcd_one
#check EnumerativeEnergy.shared_divisibility
#check EnumerativeEnergy.simultaneous_return
#check EnumerativeEnergy.relabeling_preserves_orbit
#check EnumerativeEnergy.relabeling_preserves_return
#check EnumerativeEnergy.inversion_preserves_spectral_read
#check EnumerativeEnergy.spectral_collision_has_two_branches
#check EnumerativeEnergy.spectral_read_cannot_recover_phase
#check EnumerativeEnergy.ordered_count_from_union_data
#check EnumerativeEnergy.common_energy_shift_preserves_gaps
#check EnumerativeEnergy.calibration_rescaling_preserves_phase
#check EnumerativeEnergy.residue_monotone
#check EnumerativeEnergy.conservative_representation_preserves_theorems
#check EnumerativeEnergy.pointwise_positivity_not_uniform
#check LambdaPhysical.boosted_time_needs_space
#check LambdaPhysical.boosted_space_needs_time
#check LambdaPhysical.lorentz_interval_preserved
#check LambdaPhysical.lorentz_null_preserved
#check LambdaPhysical.timelike_not_time_only
#check LambdaPhysical.timelike_not_space_only
#check LambdaPhysical.fixed_c_couples_unit_rescaling
#check LambdaPhysical.calibrated_ratios_determine_values
#print axioms EnumerativeEnergy.prime_iff_no_intermediate_divisor
#print axioms EnumerativeEnergy.prime_step_gcd_one
#print axioms EnumerativeEnergy.shared_divisibility
#print axioms EnumerativeEnergy.simultaneous_return
#print axioms EnumerativeEnergy.relabeling_preserves_orbit
#print axioms EnumerativeEnergy.relabeling_preserves_return
#print axioms EnumerativeEnergy.inversion_preserves_spectral_read
#print axioms EnumerativeEnergy.spectral_collision_has_two_branches
#print axioms EnumerativeEnergy.spectral_read_cannot_recover_phase
#print axioms EnumerativeEnergy.ordered_count_from_union_data
#print axioms EnumerativeEnergy.common_energy_shift_preserves_gaps
#print axioms EnumerativeEnergy.calibration_rescaling_preserves_phase
#print axioms EnumerativeEnergy.residue_monotone
#print axioms EnumerativeEnergy.conservative_representation_preserves_theorems
#print axioms EnumerativeEnergy.pointwise_positivity_not_uniform
#print axioms LambdaPhysical.boosted_time_needs_space
#print axioms LambdaPhysical.boosted_space_needs_time
#print axioms LambdaPhysical.lorentz_interval_preserved
#print axioms LambdaPhysical.lorentz_null_preserved
#print axioms LambdaPhysical.timelike_not_time_only
#print axioms LambdaPhysical.timelike_not_space_only
#print axioms LambdaPhysical.fixed_c_couples_unit_rescaling
#print axioms LambdaPhysical.calibrated_ratios_determine_values
#eval Lean.versionString
#eval "LAMBDA_PART_II_AUDIT_COMPLETE"


/-!
# Lambda, Reference, and the Spatiotemporal Descriptive Frame
Formal kernel for the companion paper.

Scope:
This file checks only the propositions encoded below.  The terms `self`, `other`,
`space`, `time`, `will`, `absolute`, and `meaning` receive only the formal roles
explicitly assigned here.  Physical, phenomenological, linguistic, or ontological
interpretations require separate bridge arguments in the paper.
-/

namespace LambdaSpatiotemporal

/-! ## 1. Reference polarity -/

inductive RefRole where
  | source
  | target
  deriving DecidableEq, Repr

structure RoleTagged (X : Type) where
  carrier : X
  role : RefRole
  deriving DecidableEq, Repr

def asSource {X : Type} (x : X) : RoleTagged X := ⟨x, .source⟩
def asTarget {X : Type} (x : X) : RoleTagged X := ⟨x, .target⟩

theorem source_target_roles_distinct : RefRole.source ≠ RefRole.target := by
  intro h
  cases h

theorem reference_polarity {X : Type} (x y : X) :
    asSource x ≠ asTarget y := by
  intro h
  have hr : RefRole.source = RefRole.target := congrArg RoleTagged.role h
  exact source_target_roles_distinct hr

/-- Even when the carrier is the same, referring and referred-to roles remain distinct. -/
theorem reflexive_reference_preserves_role_distinction {X : Type} (x : X) :
    asSource x ≠ asTarget x :=
  reference_polarity x x

/-- Repeating the tagging operation at any indexed station preserves role polarity. -/
theorem iterated_reference_polarity {X : Type} (x : X) (n : Nat) :
    (n, asSource x) ≠ (n, asTarget x) := by
  intro h
  have ht : asSource x = asTarget x := congrArg Prod.snd h
  exact reflexive_reference_preserves_role_distinction x ht

/-! ## 2. Binary partition and self/other bridge -/

def SelfSide {X : Type} (criterion : X → Bool) (x : X) : Prop := criterion x = true
def OtherSide {X : Type} (criterion : X → Bool) (x : X) : Prop := criterion x = false

def NontrivialCriterion {X : Type} (criterion : X → Bool) : Prop :=
  (∃ x, SelfSide criterion x) ∧ (∃ y, OtherSide criterion y)

theorem nontrivial_criterion_exhibits_poles {X : Type} (criterion : X → Bool)
    (h : NontrivialCriterion criterion) :
    ∃ x y, SelfSide criterion x ∧ OtherSide criterion y := by
  rcases h with ⟨⟨x, hx⟩, ⟨y, hy⟩⟩
  exact ⟨x, y, hx, hy⟩

theorem nontrivial_criterion_exhibits_distinct_states {X : Type} (criterion : X → Bool)
    (h : NontrivialCriterion criterion) :
    ∃ x y : X, x ≠ y := by
  rcases h with ⟨⟨x, hx⟩, ⟨y, hy⟩⟩
  refine ⟨x, y, ?_⟩
  intro hxy
  subst y
  have : true = false := hx.symm.trans hy
  cases this

/-! ## 3. Exclusion is indexed to a criterion -/

def ExcludedBy {X : Type} (criterion : X → Prop) (x : X) : Prop := ¬ criterion x

theorem exclusion_is_criterion_relative {X : Type} (criterion : X → Prop) (x : X) :
    ExcludedBy criterion x ↔ ¬ criterion x :=
  Iff.rfl

/-! ## 4. Lambda projection / fibre obstruction -/

theorem postprocessing_cannot_split_fibre
    {X Y Z : Type} (projection : X → Y) (g : Y → Z) {x₁ x₂ : X}
    (h : projection x₁ = projection x₂) :
    g (projection x₁) = g (projection x₂) :=
  congrArg g h

def FactorsThrough {X Y Z : Type} (projection : X → Y) (target : X → Z) : Prop :=
  ∃ g : Y → Z, ∀ x, g (projection x) = target x

theorem target_difference_blocks_factorization
    {X Y Z : Type} (projection : X → Y) (target : X → Z)
    {x₁ x₂ : X} (hproj : projection x₁ = projection x₂)
    (htarget : target x₁ ≠ target x₂) :
    ¬ FactorsThrough projection target := by
  intro hfac
  rcases hfac with ⟨g, hg⟩
  apply htarget
  calc
    target x₁ = g (projection x₁) := (hg x₁).symm
    _ = g (projection x₂) := congrArg g hproj
    _ = target x₂ := hg x₂

/-! ## 5. Compression may be exact for a target while remaining non-injective -/

def InjectiveMap {X Y : Type} (f : X → Y) : Prop :=
  ∀ ⦃x y⦄, f x = f y → x = y

theorem target_exact_compression_can_lose_other_distinctions :
    ∃ (compress : Bool × Bool → Bool) (target : Bool × Bool → Bool),
      FactorsThrough compress target ∧ ¬ InjectiveMap compress := by
  let compress : Bool × Bool → Bool := fun p => p.1
  let target : Bool × Bool → Bool := fun p => p.1
  refine ⟨compress, target, ?_, ?_⟩
  · refine ⟨(fun b => b), ?_⟩
    intro x
    rfl
  · intro hinj
    have hpair : (false, false) = (false, true) := hinj rfl
    have hsnd : false = true := congrArg Prod.snd hpair
    cases hsnd

/-! ## 6. Residual selection / will kernel -/

def UniqueOutcome {J S : Type} (Admissible : J → Prop) (outcome : J → S) : Prop :=
  ∃ s : S, ∀ j, Admissible j → outcome j = s

theorem residual_selection
    {J S : Type} (Admissible : J → Prop) (outcome : J → S)
    {j₁ j₂ : J} (h₁ : Admissible j₁) (h₂ : Admissible j₂)
    (hdiff : outcome j₁ ≠ outcome j₂) :
    ¬ UniqueOutcome Admissible outcome := by
  intro huniq
  rcases huniq with ⟨s, hs⟩
  apply hdiff
  calc
    outcome j₁ = s := hs j₁ h₁
    _ = outcome j₂ := (hs j₂ h₂).symm

/-- Formal role used by the paper's term `will`: an admissible selected procedure
    in a registry whose admissible procedures do not determine one unique outcome. -/
def ResidualWill {J S : Type} (Admissible : J → Prop) (outcome : J → S) (chosen : J) : Prop :=
  Admissible chosen ∧ ¬ UniqueOutcome Admissible outcome

theorem residual_will_from_competing_admissible_procedures
    {J S : Type} (Admissible : J → Prop) (outcome : J → S)
    {chosen j₂ : J} (hchosen : Admissible chosen) (h₂ : Admissible j₂)
    (hdiff : outcome chosen ≠ outcome j₂) :
    ResidualWill Admissible outcome chosen := by
  exact ⟨hchosen, residual_selection Admissible outcome hchosen h₂ hdiff⟩

/-- A selected procedure can index a criterion without the criterion being uniquely forced by
    the predecessor registry.  The substantive premise is that two admissible procedures induce
    different criteria. -/
def SelectedCriterion {J X : Type} (criterionOf : J → X → Bool) (chosen : J) : X → Bool :=
  criterionOf chosen

theorem competing_admissible_criteria_not_uniquely_forced
    {J X : Type} (Admissible : J → Prop) (criterionOf : J → X → Bool)
    {j₁ j₂ : J} (h₁ : Admissible j₁) (h₂ : Admissible j₂)
    (hdiff : criterionOf j₁ ≠ criterionOf j₂) :
    ¬ UniqueOutcome Admissible criterionOf :=
  residual_selection Admissible criterionOf h₁ h₂ hdiff

/-! ## 7. Absolute-priority schema and no-first-position kernel -/

def AbsolutePriority {C : Type} (Priority UsesComplement : C → Prop) (c : C) : Prop :=
  Priority c ∧ ¬ UsesComplement c

theorem complement_requirement_blocks_absolute_priority
    {C : Type} (Priority UsesComplement : C → Prop)
    (hbridge : ∀ c, Priority c → UsesComplement c) :
    ¬ ∃ c, AbsolutePriority Priority UsesComplement c := by
  intro h
  rcases h with ⟨c, hp, hnot⟩
  exact hnot (hbridge c hp)

structure SpatiotemporalBridge (Claim : Type) where
  SpaceFirst : Claim → Prop
  TimeFirst : Claim → Prop
  UsesTemporalResource : Claim → Prop
  UsesSpatialResource : Claim → Prop
  spaceFirstUsesTemporal : ∀ c, SpaceFirst c → UsesTemporalResource c
  timeFirstUsesSpatial : ∀ c, TimeFirst c → UsesSpatialResource c

def AbsoluteSpaceFirst {Claim : Type} (B : SpatiotemporalBridge Claim) (c : Claim) : Prop :=
  AbsolutePriority B.SpaceFirst B.UsesTemporalResource c

def AbsoluteTimeFirst {Claim : Type} (B : SpatiotemporalBridge Claim) (c : Claim) : Prop :=
  AbsolutePriority B.TimeFirst B.UsesSpatialResource c

theorem no_first_position {Claim : Type} (B : SpatiotemporalBridge Claim) :
    (¬ ∃ c, AbsoluteSpaceFirst B c) ∧ (¬ ∃ c, AbsoluteTimeFirst B c) := by
  constructor
  · exact complement_requirement_blocks_absolute_priority
      B.SpaceFirst B.UsesTemporalResource B.spaceFirstUsesTemporal
  · exact complement_requirement_blocks_absolute_priority
      B.TimeFirst B.UsesSpatialResource B.timeFirstUsesSpatial

/-! ## 8. Frame-local warrant does not self-promote to universal warrant -/

inductive TwoFrame where
  | local
  | other
  deriving DecidableEq, Repr

def SampleWarrant : TwoFrame → Prop
  | .local => True
  | .other => False

def UniversalWarrant {F : Type} (Warrant : F → Prop) : Prop := ∀ f, Warrant f

theorem local_warrant_not_universal_in_general :
    SampleWarrant .local ∧ ¬ UniversalWarrant SampleWarrant := by
  constructor
  · exact True.intro
  · intro hall
    exact hall .other

/-- A predicate named or intended as `absolute` has no elimination rule by logic alone. -/
theorem absolute_label_does_not_self_license :
    ¬ (∀ (Absolute : Prop → Prop) (p : Prop), Absolute p → p) := by
  intro h
  have hfalse : False := h (fun _ => True) False True.intro
  exact hfalse

/-! ## 9. Public-label compression can suppress operative meaning -/

inductive Usage where
  | original
  | extended
  deriving DecidableEq, Repr

inductive TinyState where
  | bare
  | marked
  deriving DecidableEq, Repr

def tinyMeaning : Usage → TinyState → Bool
  | .original, .bare => true
  | .original, .marked => false
  | .extended, _ => true

def publicLabel (_ : Usage) : String := "singularity"

theorem same_public_label : publicLabel .original = publicLabel .extended := rfl

theorem same_label_can_hide_different_meanings :
    publicLabel .original = publicLabel .extended ∧
    tinyMeaning .original .marked ≠ tinyMeaning .extended .marked := by
  constructor
  · rfl
  · decide

/-! ## 10. Translation bridges: preservation and noncommutation -/

def PreservesPredicate {A B : Type} (f : A → B) (P : A → Prop) (Q : B → Prop) : Prop :=
  ∀ a, P a ↔ Q (f a)

theorem predicate_preservation_composes
    {A B C : Type} (f : A → B) (g : B → C)
    (P : A → Prop) (Q : B → Prop) (R : C → Prop)
    (hAB : PreservesPredicate f P Q)
    (hBC : PreservesPredicate g Q R) :
    PreservesPredicate (fun a => g (f a)) P R := by
  intro a
  exact Iff.trans (hAB a) (hBC (f a))

theorem translations_need_not_commute :
    ∃ (AB BC AC : Bool → Bool) (x : Bool), AC x ≠ BC (AB x) := by
  refine ⟨(fun b => b), (fun b => b), Bool.not, false, ?_⟩
  decide

/-! ## 11. Finite resource budget forces a tradeoff when full demand exceeds it -/

theorem finite_budget_forces_tradeoff
    (costA costB allocA allocB budget : Nat)
    (hDemand : budget < costA + costB)
    (hBudget : allocA + allocB ≤ budget)
    (hA : costA ≤ allocA)
    (hB : costB ≤ allocB) : False := by
  have hsum : costA + costB ≤ allocA + allocB := Nat.add_le_add hA hB
  have hfit : costA + costB ≤ budget := Nat.le_trans hsum hBudget
  exact (Nat.not_le_of_lt hDemand) hfit

/-! ## 12. Frozen inscription does not by logic alone freeze interpretation -/

theorem same_input_can_receive_different_interpretations :
    ∃ (I₀ I₁ : Bool → Bool) (r : Bool), I₀ r ≠ I₁ r := by
  refine ⟨(fun b => b), Bool.not, false, ?_⟩
  decide

/-! ## 13. Audit checks -/

#check source_target_roles_distinct
#check reference_polarity
#check reflexive_reference_preserves_role_distinction
#check iterated_reference_polarity
#check nontrivial_criterion_exhibits_poles
#check nontrivial_criterion_exhibits_distinct_states
#check exclusion_is_criterion_relative
#check postprocessing_cannot_split_fibre
#check target_difference_blocks_factorization
#check target_exact_compression_can_lose_other_distinctions
#check residual_selection
#check residual_will_from_competing_admissible_procedures
#check SelectedCriterion
#check competing_admissible_criteria_not_uniquely_forced
#check complement_requirement_blocks_absolute_priority
#check no_first_position
#check local_warrant_not_universal_in_general
#check absolute_label_does_not_self_license
#check same_public_label
#check same_label_can_hide_different_meanings
#check predicate_preservation_composes
#check translations_need_not_commute
#check finite_budget_forces_tradeoff
#check same_input_can_receive_different_interpretations

#print axioms source_target_roles_distinct
#print axioms reference_polarity
#print axioms reflexive_reference_preserves_role_distinction
#print axioms iterated_reference_polarity
#print axioms nontrivial_criterion_exhibits_poles
#print axioms nontrivial_criterion_exhibits_distinct_states
#print axioms exclusion_is_criterion_relative
#print axioms postprocessing_cannot_split_fibre
#print axioms target_difference_blocks_factorization
#print axioms target_exact_compression_can_lose_other_distinctions
#print axioms residual_selection
#print axioms residual_will_from_competing_admissible_procedures
#print axioms competing_admissible_criteria_not_uniquely_forced
#print axioms complement_requirement_blocks_absolute_priority
#print axioms no_first_position
#print axioms local_warrant_not_universal_in_general
#print axioms absolute_label_does_not_self_license
#print axioms same_public_label
#print axioms same_label_can_hide_different_meanings
#print axioms predicate_preservation_composes
#print axioms translations_need_not_commute
#print axioms finite_budget_forces_tradeoff
#print axioms same_input_can_receive_different_interpretations

#eval Lean.versionString
#eval "LAMBDA_SPATIOTEMPORAL_TRANSLATION_AUDIT_COMPLETE"

end LambdaSpatiotemporal


/-!
# Deflation of Pharmakon-Based Delusion
A formal example of undisclosed meaning change under one public label.
The finite model illustrates logical structure, not a physical model.
-/
namespace SemanticDeflation

/-- The new use cannot retain every constraint of the old use. -/
theorem deflation
    {X : Type} (A B P : X → Prop)
    (hA : ∀ x, A x → ¬ P x)
    (hB : ∃ x, B x ∧ P x) :
    ¬ (∀ x, B x → A x) := by
  intro hBA
  rcases hB with ⟨x, hBx, hPx⟩
  exact hA x (hBA x hBx) hPx

/-- Identify a witness at which the original definition no longer applies. -/
theorem constraint_loss
    {X : Type} (A B P : X → Prop)
    (hA : ∀ x, A x → ¬ P x)
    (hB : ∃ x, B x ∧ P x) :
    ∃ x, B x ∧ P x ∧ ¬ A x := by
  rcases hB with ⟨x, hBx, hPx⟩
  exact ⟨x, hBx, hPx, fun hAx => hA x hAx hPx⟩

/-- No single predicate can be equivalent to both uses. -/
theorem no_shared_definition
    {X : Type} (A B P : X → Prop)
    (hA : ∀ x, A x → ¬ P x)
    (hB : ∃ x, B x ∧ P x) :
    ¬ ∃ S : X → Prop,
      (∀ x, S x ↔ A x) ∧ (∀ x, S x ↔ B x) := by
  intro h
  rcases h with ⟨S, hSA, hSB⟩
  exact deflation A B P hA hB
    (fun x hBx => (hSA x).mp ((hSB x).mpr hBx))

/-- Forcing both arms onto one unchanged meaning yields False. -/
theorem same_meaning_conflict
    {X : Type} (S P : X → Prop)
    (hNo : ∀ x, S x → ¬ P x)
    (hYes : ∃ x, S x ∧ P x) : False := by
  rcases hYes with ⟨x, hSx, hPx⟩
  exact hNo x hSx hPx

inductive State where
  | bare
  | marked

def HasTrait : State → Prop
  | .bare => False
  | .marked => True

def Original (x : State) : Prop := ¬ HasTrait x
def Extended (_x : State) : Prop := True

inductive Usage where
  | original
  | extended

def meaning : Usage → State → Prop
  | .original => Original
  | .extended => Extended

/-- This public label suppresses which predicate supplies its meaning. -/
def publicLabel (_u : Usage) : String := "singularity"

theorem original_inhabited : ∃ x, Original x := by
  exact ⟨State.bare, fun h => h⟩

theorem original_excludes_trait :
    ∀ x, Original x → ¬ HasTrait x := by
  intro x h
  exact h

theorem extended_admits_trait :
    ∃ x, Extended x ∧ HasTrait x := by
  exact ⟨State.marked, True.intro, True.intro⟩

theorem original_is_extended :
    ∀ x, Original x → Extended x := by
  intro x _
  exact True.intro

/-- Both scoped arms hold, with a nonempty old use and the same public name. -/
theorem two_checked_branches_one_label :
    (∃ x, meaning Usage.original x) ∧
    (∀ x, meaning Usage.original x → ¬ HasTrait x) ∧
    (∃ x, meaning Usage.extended x ∧ HasTrait x) ∧
    publicLabel Usage.original = publicLabel Usage.extended := by
  exact ⟨original_inhabited, original_excludes_trait,
    extended_admits_trait, rfl⟩

/-- Equal printed names do not justify identifying the two definitions. -/
theorem shared_label_does_not_preserve_meaning :
    publicLabel Usage.original = publicLabel Usage.extended ∧
    ¬ (∀ x, meaning Usage.original x ↔ meaning Usage.extended x) := by
  constructor
  · rfl
  · intro h
    exact deflation Original Extended HasTrait
      original_excludes_trait extended_admits_trait
      (fun x hx => (h x).mpr hx)

end SemanticDeflation

-- Explicit verification observations
#check SemanticDeflation.deflation
#print axioms SemanticDeflation.deflation

#check SemanticDeflation.constraint_loss
#print axioms SemanticDeflation.constraint_loss

#check SemanticDeflation.no_shared_definition
#print axioms SemanticDeflation.no_shared_definition

#check SemanticDeflation.same_meaning_conflict
#print axioms SemanticDeflation.same_meaning_conflict

#check SemanticDeflation.original_inhabited
#print axioms SemanticDeflation.original_inhabited

#check SemanticDeflation.original_excludes_trait
#print axioms SemanticDeflation.original_excludes_trait

#check SemanticDeflation.extended_admits_trait
#print axioms SemanticDeflation.extended_admits_trait

#check SemanticDeflation.original_is_extended
#print axioms SemanticDeflation.original_is_extended

#check SemanticDeflation.two_checked_branches_one_label
#print axioms SemanticDeflation.two_checked_branches_one_label

#check SemanticDeflation.shared_label_does_not_preserve_meaning
#print axioms SemanticDeflation.shared_label_does_not_preserve_meaning

#eval Lean.versionString
#eval "SEMANTIC_DEFLATION_AUDIT_COMPLETE"


/-
================================================================================
  THE UNWITNESSABLE VERDICT  —  LEAN DEMONSTRATOR
  A self-contained enactment of the paper's central distinction.

  Lu Semita · EmergenceByDesign

  WHAT THIS FILE IS.
    This file does not "prove the paper." It cannot, and that impossibility
    IS the paper's thesis. What it does is make a proof assistant PERFORM the
    thesis: a passing kernel check certifies that a derivation is valid (the
    paper's C*), and NEVER that the formal statement captures the informal
    claim a human reader means (the paper's C). Run this file through Lean and
    the green check is itself the demonstration — the oracle pronouncing its
    own limit.

  HOW TO VERIFY.
    Paste the whole file into the official Lean 4 playground at
    https://live.lean-lang.org/ and wait for it to load. No install, no
    mathlib. Every `theorem` below should check. The `#print axioms` lines
    report, in public, exactly which adoptions each result rests on.

  HOW TO READ THE STATUS OF EACH LINE.
    [CHK]  a finitely checkable claim. Emitted as `theorem`. Lean proves it.
    [ADPT] a declared adoption. Emitted as `def`. Lean ACCEPTS it and
           certifies NOTHING by doing so — a definition has no truth value.
    The paper's tail-level thesis ("truth is unwitnessable from any state that
    could draw the distinction") is emitted as NEITHER. It appears nowhere as
    a `theorem`, because no station proves it, and nowhere as an `axiom`,
    because we refuse to assume what we are discussing. Its ABSENCE is the
    point: a file that "proved the thesis" would commit the paper's error
    inside the theorem prover.

  THE ONE ADOPTION THIS WHOLE ARTIFACT RESTS ON.
    That the Lean statements below faithfully render the informal sentences in
    their comments. No green build can close this gap — it is precisely the
    specification-adequacy residue the file is about. It is declared here, in
    the open, and it is the correct target of any refutation.
================================================================================
-/

namespace UnwitnessableVerdict

/- ============================================================================
   PART A — THE CHECKABLE KERNEL  [CHK]
   Claims the paper marks as finitely checkable. Lean proves them outright.
   ============================================================================ -/

/-- Lemma 3.2 (Verification asymmetry), the witnessed half.
    A single counterexample refutes a universal claim: refutation has a finite
    station witness. (The other half — that no finite set of instances CROWNS
    a universal — is the untyped tail, and by design it is NOT provable here.) -/
theorem refutation_is_witnessed
    {α : Type} (P : α → Prop) (a : α) (h : ¬ P a) :
    ¬ (∀ x, P x) :=
  fun hall => h (hall a)


/- ============================================================================
   PART B — THE SPECIFICATION GAP  (the centerpiece)
   Lean certifies that a derivation is valid. It does NOT certify that the
   formal statement means what the English sentence means. We exhibit theorems
   that PASS the kernel while carrying no information about their stated target.
   ============================================================================ -/

/-- The specification gap in its purest form.
    If a hypothesis H is satisfied by nothing, then `∀ x, H x → G x` holds for
    EVERY conclusion G — the kernel certifies it without G ever being examined.
    A formalization whose hypothesis is mis-scoped (true of nothing in the
    intended domain) passes VACUOUSLY and says nothing about the intended G.
    This is C* (the derivation checks) with C (the claim about the real
    objects) left entirely untouched. -/
theorem vacuous_pass
    {α : Type} (H G : α → Prop) (empty : ∀ x, ¬ H x) :
    ∀ x, H x → G x :=
  fun x hx => absurd hx (empty x)

/-  A concrete, vivid instance. "No natural number is negative" is the
    mis-scoped hypothesis. Watch: BOTH of the following pass the kernel, though
    their conclusions flatly contradict each other. The conclusion after the
    arrow is never tested — that IS the gap. A green check on either one tells
    a reader nothing about whether the intended claim holds.                  -/

/-- Passes. Says every "negative natural" equals itself. -/
theorem misscoped_says_equal :
    ∀ n : Nat, n < 0 → n = n :=
  fun n h => absurd h (Nat.not_lt_zero n)

/-- Also passes. Says every "negative natural" does NOT equal itself.
    Two contradictory "theorems," both kernel-certified, because in each the
    conclusion is vacuously reached. The build is green; the meaning is empty. -/
theorem misscoped_says_not_equal :
    ∀ n : Nat, n < 0 → n ≠ n :=
  fun n h => absurd h (Nat.not_lt_zero n)


/- ============================================================================
   PART C — BULLETPROOFING, THE DECIDABLE HEART  [CHK]
   Lemma 3.4: the outcome of a finite check is settled mechanically. That, and
   only that, is what C* asserts.
   ============================================================================ -/

/-- A finite check yields a determinate Boolean outcome. -/
def checkPasses (b : Bool) : Bool := b

/-- The outcome is settled: it is one value or the other, decided by the check
    itself, with no appeal to anything outside it. This is the exact and
    attainable sense in which C* is bulletproof. -/
theorem check_outcome_settled (b : Bool) :
    checkPasses b = true ∨ checkPasses b = false := by
  cases b
  · exact Or.inr rfl
  · exact Or.inl rfl


/- ============================================================================
   PART D — THE DISCHARGE CRITERION  [ADPT]
   Definition 7.2 is an ADOPTION, not a theorem. Emitting it as a `def` makes
   that visible: Lean accepts the definition and certifies NOTHING by doing so.
   The file does not launder a definition into a proof.
   ============================================================================ -/

/-- A premise is discharged when it does NOT occur free in the conclusion's
    warrant. This is a definition we ADOPT; accepting it proves nothing. -/
def Discharged (premiseOccursFreeInConclusion : Bool) : Prop :=
  premiseOccursFreeInConclusion = false


/- ============================================================================
   PART E — EXPOSING THE SUBSCRIPT
   `#print axioms` is the Discharge Test, automated. It reports, in public, the
   adoptions each result leans on. The checkable kernel below leans on none.
   (If anyone ever patches a proof with `sorry`, these same lines flag
   `sorryAx` — the incompleteness is exposed even though the build stays green.)
   ============================================================================ -/

#print axioms refutation_is_witnessed
#print axioms vacuous_pass
#print axioms misscoped_says_equal
#print axioms misscoped_says_not_equal
#print axioms check_outcome_settled


/- ============================================================================
   PART F — THE REFLEXIVE CAPSTONE  (comment only; deliberately not a theorem)

   Con(Lean) is unprovable in Lean. If Lean's logic is consistent, Lean cannot
   prove its own consistency — this is Gödel's second theorem pointed at the
   prover, i.e. the paper's Theorem 4.3 applied to the checker itself. The
   trust concentrated in Lean's small kernel is RISK REDUCTION on an
   unwitnessable-from-inside property, never a certificate of it. The kernel's
   soundness is adopted, not proved.

   Therefore "Lean is infallible" is false in the exact grammar the paper
   diagnoses: it applies a station observable's confidence ("this proof
   checks") to a tail predicate ("this system is sound"). Lean is a frame. It
   has maximal [CHK] power and no more. It cannot witness its own tail either —
   which is why a passing check of THIS file, and the absence within it of any
   proof of the thesis, is the most trusted available witness that witnessing
   has limits.
   ============================================================================ -/

end UnwitnessableVerdict

#check UnwitnessableVerdict.refutation_is_witnessed
#check UnwitnessableVerdict.vacuous_pass
#check UnwitnessableVerdict.misscoped_says_equal
#check UnwitnessableVerdict.misscoped_says_not_equal
#check UnwitnessableVerdict.check_outcome_settled

#eval Lean.versionString
#eval "UNWITNESSABLE_VERDICT_AUDIT_COMPLETE"

#eval Lean.versionString
#eval "LAMBDA_R4_COMPANION_END"

SHA-256: 56946d09136d0b0aeffd31daace360a74ab5acc3e11575620d60a123b5562afc

import Mathlib

/- Lambda R3: carried conditions, access, intervention, and persistence.
   Conditional mathematical contracts; no biological or permanence axiom. -/
namespace LambdaCarriedState

inductive Origin where
  | inherited | acquired | declared | unknown
  deriving DecidableEq, Repr

structure Carried (C R : Type*) where
  condition : C
  record : R
  origin : Origin

-- Updating the descriptive record has an explicitly limited action.
def remark {C R : Type*} (f : R → R) (s : Carried C R) : Carried C R :=
  { s with record := f s.record }

theorem remark_preserves_condition {C R : Type*} (f : R → R) (s : Carried C R) :
    (remark f s).condition = s.condition := rfl

theorem remark_preserves_origin {C R : Type*} (f : R → R) (s : Carried C R) :
    (remark f s).origin = s.origin := rfl

theorem repeated_remarking_preserves_condition {C R : Type*}
    (fs : List (R → R)) (s : Carried C R) :
    (fs.foldl (fun st f => remark f st) s).condition = s.condition := by
  induction fs generalizing s with
  | nil => rfl
  | cons f fs ih => exact ih (remark f s)

theorem recording_inherited_state_does_not_rewrite_origin {C R : Type*}
    (s : Carried C R) (h : s.origin = .inherited) (f : R → R) :
    (remark f s).origin = .inherited := h

def Recovers {X Y Z : Type*} (observe : X → Y) (target : X → Z) : Prop :=
  ∃ decode : Y → Z, ∀ x, decode (observe x) = target x

theorem equal_observation_blocks_target {X Y Z : Type*}
    (observe : X → Y) (target : X → Z) {a b : X}
    (same : observe a = observe b) (different : target a ≠ target b) :
    ¬ Recovers observe target := by
  rintro ⟨decode, exactness⟩
  apply different
  calc target a = decode (observe a) := (exactness a).symm
       _ = decode (observe b) := congrArg decode same
       _ = target b := exactness b

theorem identical_descriptions_can_hide_distinct_conditions :
    ¬ Recovers (fun s : Carried Bool Unit => s.record) (fun s => s.condition) := by
  apply equal_observation_blocks_target _ _
    (a := ⟨false, (), .unknown⟩) (b := ⟨true, (), .unknown⟩)
  · rfl
  · decide

theorem content_does_not_determine_origin :
    ¬ Recovers (fun s : Carried Unit Unit => s.record) (fun s => s.origin) := by
  apply equal_observation_blocks_target _ _
    (a := ⟨(), (), .inherited⟩) (b := ⟨(), (), .declared⟩)
  · rfl
  · decide

theorem enlarged_observation_can_recover_condition {C R : Type*} :
    Recovers (fun s : Carried C R => (s.record, s.condition)) (fun s => s.condition) := by
  exact ⟨Prod.snd, fun _ => rfl⟩

def CanChange {X A : Type*} (act : A → X → X) (x : X) : Prop :=
  ∃ a, act a x ≠ x

theorem exact_access_does_not_supply_intervention :
    Recovers (id : Bool → Bool) id ∧
      ∀ x : Bool, ¬ CanChange (fun (_ : Unit) (s : Bool) => s) x := by
  constructor
  · exact ⟨id, fun _ => rfl⟩
  · intro x h
    rcases h with ⟨a, ha⟩
    exact ha rfl

theorem intervention_does_not_supply_exact_access :
    (∀ x : Bool, CanChange (fun (_ : Unit) (s : Bool) => !s) x) ∧
      ¬ Recovers (fun _ : Bool => ()) id := by
  constructor
  · intro x
    exact ⟨(), by cases x <;> decide⟩
  · apply equal_observation_blocks_target _ _ (a := false) (b := true)
    · rfl
    · decide

-- Available interventions may have a multi-step path.
def applyActions {X A : Type*} (act : A → X → X) (x : X) (as : List A) : X :=
  as.foldl (fun s a => act a s) x

theorem invariant_survives_available_interventions {X A : Type*}
    (act : A → X → X) (p : X → Prop)
    (preserved : ∀ a x, p x → p (act a x)) (x : X) (initial : p x) (as : List A) :
    p (applyActions act x as) := by
  induction as generalizing x with
  | nil => exact initial
  | cons a as ih => exact ih (act a x) (preserved a x initial)

theorem invariant_obstructs_revision_path {X A : Type*}
    (act : A → X → X) (p : X → Prop)
    (preserved : ∀ a x, p x → p (act a x)) (x y : X)
    (initial : p x) (excluded : ¬ p y) :
    ¬ ∃ as, applyActions act x as = y := by
  rintro ⟨as, h⟩
  apply excluded
  rw [← h]
  exact invariant_survives_available_interventions act p preserved x initial as

-- Time is an index. Observation and decoder may change between carriers.
def ExactAt {X S Z : Type*} (encode : Nat → X → S)
    (decode : Nat → S → Z) (target : X → Z) (t : Nat) : Prop :=
  ∀ x, decode t (encode t x) = target x

def Through {X S Z : Type*} (encode : Nat → X → S)
    (decode : Nat → S → Z) (target : X → Z) (N : Nat) : Prop :=
  ∀ t, t ≤ N → ExactAt encode decode target t

theorem recovery_horizon_can_be_shortened {X S Z : Type*}
    (encode : Nat → X → S) (decode : Nat → S → Z) (target : X → Z)
    {M N : Nat} (h : Through encode decode target N) (bound : M ≤ N) :
    Through encode decode target M := by
  intro t ht
  exact h t (Nat.le_trans ht bound)

theorem target_preserving_transfer_gives_successor_recovery {X S T Z : Type*}
    (old : X → S) (next : X → T) (transfer : S → T)
    (oldDecode : S → Z) (nextDecode : T → Z) (q : X → Z)
    (route : ∀ x, next x = transfer (old x))
    (faithful : ∀ x, nextDecode (transfer (old x)) = oldDecode (old x))
    (exactness : ∀ x, oldDecode (old x) = q x) :
    ∀ x, nextDecode (next x) = q x := by
  intro x
  rw [route x, faithful x, exactness x]

theorem maintenance_contract_extends_recovery {X S Z : Type*}
    (encode : Nat → X → S) (decode : Nat → S → Z) (target : X → Z)
    (initial : ExactAt encode decode target 0)
    (step : ∀ t, ExactAt encode decode target t → ExactAt encode decode target (t+1)) :
    ∀ t, ExactAt encode decode target t := by
  intro t
  induction t with
  | zero => exact initial
  | succ t ih => exact step t ih

theorem maintained_hypotheses_give_conditional_continuity
    (sound maintained : Nat → Prop) (initial : sound 0)
    (step : ∀ t, sound t → maintained t → sound (t+1)) :
    (∀ t, maintained t) → ∀ t, sound t := by
  intro all t
  induction t with
  | zero => exact initial
  | succ t ih => exact step t ih (all t)

-- A finite successful prefix is compatible with later loss.
def expiresAfter (N t : Nat) (x : Bool) : Bool :=
  if t ≤ N then x else false

theorem finite_successful_prefix (N : Nat) :
    Through (expiresAfter N) (fun _ => id) id N := by
  intro t ht x
  simp [expiresAfter, ht]

theorem prefix_agreement_can_hide_later_divergence (N : Nat) :
    (∀ t, t ≤ N → ∀ x : Bool, expiresAfter N t x = x) ∧
      expiresAfter N (N+1) true ≠ true := by
  constructor
  · intro t ht x
    simp [expiresAfter, ht]
  · simp [expiresAfter]

theorem loss_after_horizon_has_no_replacement_decoder (N : Nat) :
    ¬ Recovers (expiresAfter N (N+1)) id := by
  apply equal_observation_blocks_target _ _ (a := false) (b := true)
  · simp [expiresAfter]
  · decide

theorem no_finite_prefix_certificate_of_permanence (N : Nat) :
    ¬ (∀ encode : Nat → Bool → Bool,
      Through encode (fun _ => id) id N →
      ∀ t, ExactAt encode (fun _ => id) id t) := by
  intro certificate
  have h := certificate (expiresAfter N) (finite_successful_prefix N) (N+1) true
  simp [expiresAfter] at h

theorem permanent_ideal_model_is_also_consistent_with_prefix :
    ∃ encode : Nat → Bool → Bool, ∀ t, ExactAt encode (fun _ => id) id t := by
  exact ⟨fun _ => id, fun _ _ => rfl⟩

theorem collision_survives_later_transfer {X S T Z : Type*}
    (encode : X → S) (transfer : S → T) (target : X → Z) {a b : X}
    (same : encode a = encode b) (different : target a ≠ target b) :
    ¬ Recovers (transfer ∘ encode) target := by
  exact equal_observation_blocks_target _ _ (congrArg transfer same) different

-- Unit-cost commitments: feasibility can force omission without selecting priority.
theorem budget_forces_an_omitted_commitment {I : Type*} [DecidableEq I]
    (required retained : Finset I) (B : Nat)
    (feasible : retained.card ≤ B) (overBudget : B < required.card) :
    ∃ i ∈ required, i ∉ retained := by
  by_contra h
  have subset : required ⊆ retained := by
    intro i hi
    by_contra missing
    exact h ⟨i, hi, missing⟩
  have size := Finset.card_le_card subset
  omega

theorem equal_budget_does_not_select_priority :
    ∃ a b : Finset Bool, a.card ≤ 1 ∧ b.card ≤ 1 ∧ a ≠ b := by
  exact ⟨{false}, {true}, by decide, by decide, by decide⟩

theorem exact_target_requires_sufficient_carrier_states {X S : Type*}
    [Fintype X] [Fintype S] (encode : X → S) (decode : S → X)
    (exactness : ∀ x, decode (encode x) = x) :
    Fintype.card X ≤ Fintype.card S := by
  apply Fintype.card_le_of_injective encode
  intro a b h
  calc a = decode (encode a) := (exactness a).symm
       _ = decode (encode b) := congrArg decode h
       _ = b := exactness b

theorem finite_carrier_can_preserve_selected_target {R : Type*} :
    Recovers (fun h : Bool × R => h.1) (fun h => h.1) := by
  exact ⟨id, fun _ => rfl⟩

end LambdaCarriedState

#eval Lean.versionString
set_option pp.universes false
#check @LambdaCarriedState.remark_preserves_condition
#print axioms LambdaCarriedState.remark_preserves_condition
#check @LambdaCarriedState.remark_preserves_origin
#print axioms LambdaCarriedState.remark_preserves_origin
#check @LambdaCarriedState.repeated_remarking_preserves_condition
#print axioms LambdaCarriedState.repeated_remarking_preserves_condition
#check @LambdaCarriedState.recording_inherited_state_does_not_rewrite_origin
#print axioms LambdaCarriedState.recording_inherited_state_does_not_rewrite_origin
#check @LambdaCarriedState.equal_observation_blocks_target
#print axioms LambdaCarriedState.equal_observation_blocks_target
#check @LambdaCarriedState.identical_descriptions_can_hide_distinct_conditions
#print axioms LambdaCarriedState.identical_descriptions_can_hide_distinct_conditions
#check @LambdaCarriedState.content_does_not_determine_origin
#print axioms LambdaCarriedState.content_does_not_determine_origin
#check @LambdaCarriedState.enlarged_observation_can_recover_condition
#print axioms LambdaCarriedState.enlarged_observation_can_recover_condition
#check @LambdaCarriedState.exact_access_does_not_supply_intervention
#print axioms LambdaCarriedState.exact_access_does_not_supply_intervention
#check @LambdaCarriedState.intervention_does_not_supply_exact_access
#print axioms LambdaCarriedState.intervention_does_not_supply_exact_access
#check @LambdaCarriedState.invariant_survives_available_interventions
#print axioms LambdaCarriedState.invariant_survives_available_interventions
#check @LambdaCarriedState.invariant_obstructs_revision_path
#print axioms LambdaCarriedState.invariant_obstructs_revision_path
#check @LambdaCarriedState.recovery_horizon_can_be_shortened
#print axioms LambdaCarriedState.recovery_horizon_can_be_shortened
#check @LambdaCarriedState.target_preserving_transfer_gives_successor_recovery
#print axioms LambdaCarriedState.target_preserving_transfer_gives_successor_recovery
#check @LambdaCarriedState.maintenance_contract_extends_recovery
#print axioms LambdaCarriedState.maintenance_contract_extends_recovery
#check @LambdaCarriedState.maintained_hypotheses_give_conditional_continuity
#print axioms LambdaCarriedState.maintained_hypotheses_give_conditional_continuity
#check @LambdaCarriedState.finite_successful_prefix
#print axioms LambdaCarriedState.finite_successful_prefix
#check @LambdaCarriedState.prefix_agreement_can_hide_later_divergence
#print axioms LambdaCarriedState.prefix_agreement_can_hide_later_divergence
#check @LambdaCarriedState.loss_after_horizon_has_no_replacement_decoder
#print axioms LambdaCarriedState.loss_after_horizon_has_no_replacement_decoder
#check @LambdaCarriedState.no_finite_prefix_certificate_of_permanence
#print axioms LambdaCarriedState.no_finite_prefix_certificate_of_permanence
#check @LambdaCarriedState.permanent_ideal_model_is_also_consistent_with_prefix
#print axioms LambdaCarriedState.permanent_ideal_model_is_also_consistent_with_prefix
#check @LambdaCarriedState.collision_survives_later_transfer
#print axioms LambdaCarriedState.collision_survives_later_transfer
#check @LambdaCarriedState.budget_forces_an_omitted_commitment
#print axioms LambdaCarriedState.budget_forces_an_omitted_commitment
#check @LambdaCarriedState.equal_budget_does_not_select_priority
#print axioms LambdaCarriedState.equal_budget_does_not_select_priority
#check @LambdaCarriedState.exact_target_requires_sufficient_carrier_states
#print axioms LambdaCarriedState.exact_target_requires_sufficient_carrier_states
#check @LambdaCarriedState.finite_carrier_can_preserve_selected_target
#print axioms LambdaCarriedState.finite_carrier_can_preserve_selected_target

#eval "LAMBDA_R3_END_OF_CHECK"

#eval Lean.versionString
#eval "LAMBDA_R4_CARRIEDSTATE_END"

SHA-256: 94b31d916921f678d5cc4e60a6a5a2904eef6dbfe47adf6200fd12c50280716c

import Mathlib

/-!
# Lambda: conveyance, carried commitments, and the shared accumulator
Lu Semita / EmergenceByDesign. Successor R2, 2026-09-13.

Theorems concern the explicit types and protocols below. No theorem identifies
all meaningful reference, consciousness, or physical memory with these types.
No termination theorem follows merely from the presence of role positions.
-/
namespace LambdaConstitutive

-- A. Roles and conveyance. Distinct positions need not have distinct carriers.
inductive Role where
  | source | target
  deriving DecidableEq

theorem role_positions_differ : Role.source ≠ Role.target := by decide

theorem one_carrier_can_fill_both_roles {X : Type*} (x : X) :
    ∃ placement : Role → X, placement .source = placement .target :=
  ⟨fun _ => x, rfl⟩

def Preserves {X Y : Type*} (f : X → Y) (p : X → Prop) (q : Y → Prop) : Prop :=
  ∀ x, p x ↔ q (f x)

theorem translation_composes {X Y Z : Type*} (f : X → Y) (g : Y → Z)
    (p : X → Prop) (q : Y → Prop) (r : Z → Prop)
    (first : Preserves f p q) (second : Preserves g q r) :
    Preserves (g ∘ f) p r := fun x => (first x).trans (second (f x))

theorem preserved_predicate_survives_roundtrip {X Y : Type*}
    (f : X → Y) (g : Y → X) (p : X → Prop) (q : Y → Prop)
    (forward : Preserves f p q) (backward : Preserves g q p) :
    ∀ x, p x ↔ p (g (f x)) := translation_composes f g p q p forward backward

theorem changed_middle_predicate_breaks_composition :
    ∃ (f g : Bool → Bool) (p q₁ q₂ r : Bool → Prop),
      Preserves f p q₁ ∧ Preserves g q₂ r ∧ ¬ Preserves (g ∘ f) p r := by
  refine ⟨id, fun _ => false, (· = true), (· = true),
    (fun _ => True), (fun _ => True), ?_, ?_, ?_⟩
  · intro x; rfl
  · intro x; rfl
  · intro h
    have impossible : false = true := (h false).mpr trivial
    cases impossible

theorem conveyance_collision_blocks_target {X Y Z : Type*}
    (message : X → Y) (target : X → Z) {a b : X}
    (same : message a = message b) (split : target a ≠ target b) :
    ¬ ∃ interpret : Y → Z, ∀ x, interpret (message x) = target x := by
  rintro ⟨interpret, h⟩
  exact split ((h a).symm.trans ((congrArg interpret same).trans (h b)))

theorem metadescription_cannot_split_equal_messages {X Y Z : Type*}
    (message : X → Y) (redescribe : Y → Z) {a b : X}
    (same : message a = message b) : redescribe (message a) = redescribe (message b) :=
  congrArg redescribe same

-- B. Iteration: continuation-space, retained data, and termination differ.
theorem erased_depth_has_no_decoder :
    ¬ ∃ decode : Unit → ℕ, ∀ n : ℕ, decode () = n := by
  rintro ⟨decode, h⟩
  have h0 := h 0
  have h1 := h 1
  omega

theorem threaded_depth_has_decoder :
    ∃ decode : Unit × ℕ → ℕ, ∀ n, decode ((), n) = n :=
  ⟨Prod.snd, fun _ => rfl⟩

theorem retained_argument_can_recover_depth :
    ∃ decode : ℕ → ℕ, ∀ n, decode n = n := ⟨id, fun _ => rfl⟩

def countdown : ℕ → List ℕ
  | 0 => []
  | n + 1 => n :: countdown n

theorem terminating_countdown_has_input_sized_trace (n : ℕ) :
    (countdown n).length = n := by
  induction n with
  | zero => rfl
  | succ n ih => simp [countdown, ih]

theorem no_uniform_trace_bound_for_terminating_countdown :
    ¬ ∃ B : ℕ, ∀ n, (countdown n).length ≤ B := by
  rintro ⟨B, h⟩
  have bad := h (B + 1)
  rw [terminating_countdown_has_input_sized_trace] at bad
  omega

theorem finite_state_can_continue_without_halting :
    ∃ (step : Unit → Unit) (halt : Unit → Prop),
      ∀ n : ℕ, ¬ halt ((step^[n]) ()) := by
  exact ⟨id, fun _ => False, fun _ h => h⟩

-- C. Exact finite-state accounting, measured in distinguishable states.
theorem exact_recovery_requires_enough_states {X S : Type*}
    [Fintype X] [Fintype S] (encode : X → S) (decode : S → X)
    (exactness : ∀ x, decode (encode x) = x) :
    Fintype.card X ≤ Fintype.card S := by
  apply Fintype.card_le_of_injective encode
  intro x y same
  rw [← exactness x, ← exactness y, same]

theorem exact_subset_memory_requires_all_subsets (k : ℕ) {S : Type*}
    [Fintype S] (encode : (Fin k → Bool) → S) (decode : S → Fin k → Bool)
    (exactness : ∀ x, decode (encode x) = x) :
    2 ^ k ≤ Fintype.card S := by
  have h := exact_recovery_requires_enough_states encode decode exactness
  simpa using h

theorem exact_depth_through_N_requires_N_plus_one_states (N : ℕ) {S : Type*}
    [Fintype S] (encode : Fin (N + 1) → S) (decode : S → Fin (N + 1))
    (exactness : ∀ n, decode (encode n) = n) :
    N + 1 ≤ Fintype.card S := by
  simpa using exact_recovery_requires_enough_states encode decode exactness

theorem no_fixed_finite_state_recovers_unbounded_depth {S : Type*}
    [Fintype S] (encode : ℕ → S) :
    ¬ ∃ decode : S → ℕ, ∀ n, decode (encode n) = n := by
  rintro ⟨decode, h⟩
  let N := Fintype.card S
  have injective : Function.Injective (fun n : Fin (N + 1) => encode n.val) := by
    intro x y same
    apply Fin.ext
    exact (h x.val).symm.trans ((congrArg decode same).trans (h y.val))
  have bad := Fintype.card_le_of_injective _ injective
  simp only [Fintype.card_fin] at bad
  change N + 1 ≤ N at bad
  omega

-- D. An online accumulator must commute with the declared history extension.
def run {E S : Type*} (update : S → E → S) (initial : S) (events : List E) : S :=
  events.foldl update initial

def AppendCompatible {E S : Type*} (encode : List E → S) : Prop :=
  ∀ h k e, encode h = encode k → encode (h ++ [e]) = encode (k ++ [e])

theorem online_update_implies_append_compatibility {E S : Type*}
    (encode : List E → S) (update : S → E → S)
    (commutes : ∀ h e, update (encode h) e = encode (h ++ [e])) :
    AppendCompatible encode := by
  intro h k e same
  rw [← commutes h e, ← commutes k e, same]

theorem append_compatibility_supplies_online_update {E S : Type*}
    [Nonempty S] (encode : List E → S) (compatible : AppendCompatible encode) :
    ∃ update : S → E → S, ∀ h e, update (encode h) e = encode (h ++ [e]) := by
  classical
  let update : S → E → S := fun s e =>
    if witness : ∃ h, encode h = s then
      encode (Classical.choose witness ++ [e])
    else Classical.choice inferInstance
  refine ⟨update, ?_⟩
  intro h e
  have witness : ∃ k, encode k = encode h := ⟨h, rfl⟩
  simp only [update, dite_eq_left witness]
  exact compatible _ h e (Classical.choose_spec witness)

theorem run_preserves_history_encoding {E S : Type*}
    (encode : List E → S) (update : S → E → S)
    (commutes : ∀ h e, update (encode h) e = encode (h ++ [e]))
    (h : List E) : run update (encode []) h = encode h := by
  induction h using List.reverseRecOn with
  | nil => rfl
  | append_singleton h e ih =>
    change (h ++ [e]).foldl update (encode []) = _
    rw [List.foldl_append]
    change update (run update (encode []) h) e = _
    rw [ih, commutes]

theorem online_target_recovery {E S Z : Type*}
    (encode : List E → S) (update : S → E → S) (decode : S → Z)
    (target : List E → Z)
    (commutes : ∀ h e, update (encode h) e = encode (h ++ [e]))
    (exactness : ∀ h, decode (encode h) = target h) :
    ∀ h, decode (run update (encode []) h) = target h := by
  intro h
  rw [run_preserves_history_encoding encode update commutes, exactness]

def hasTwo (h : List Unit) : Bool := decide (2 ≤ h.length)

theorem snapshot_target_can_fail_online_update :
    (∃ decode : Bool → Bool, ∀ h, decode (hasTwo h) = hasTwo h) ∧
      ¬ AppendCompatible hasTwo := by
  constructor
  · exact ⟨id, fun _ => rfl⟩
  · intro compatible
    have bad := compatible [] [()] () (by decide)
    have unequal : hasTwo ([] ++ [()]) ≠ hasTwo ([()] ++ [()]) := by decide
    exact unequal bad

-- E. Recognition and continuation need different queries.
structure Cache where
  result : ℕ
  returned : Bool
  deriving DecidableEq

theorem cached_result_does_not_recover_return :
    ¬ ∃ d : ℕ → Bool, ∀ c : Cache, d c.result = c.returned := by
  rintro ⟨d, h⟩
  have h0 := h ⟨7, false⟩
  have h1 := h ⟨7, true⟩
  exact Bool.noConfusion (h0.symm.trans h1)

theorem return_mark_does_not_recover_cached_result :
    ¬ ∃ d : Bool → ℕ, ∀ c : Cache, d c.returned = c.result := by
  rintro ⟨d, h⟩
  have h0 := h ⟨0, true⟩
  have h1 := h ⟨1, true⟩
  change d true = 0 at h0
  change d true = 1 at h1
  omega

theorem joint_record_recovers_both_cache_queries :
    ∃ d : Cache → ℕ × Bool, ∀ c, d c = (c.result, c.returned) :=
  ⟨fun c => (c.result, c.returned), fun _ => rfl⟩

-- F. Scope, provenance, and warrants are separately carried coordinates.
inductive Origin where
  | declared | derived | unknown
  deriving DecidableEq

structure Entry where
  holder : String
  scope : String
  basis : String
  claim : String
  origin : Origin
  deriving DecidableEq

def Reuse (old new : Entry) : Prop :=
  new.holder = old.holder ∧ new.scope = old.scope ∧ new.basis = old.basis ∧
    new.claim = old.claim ∧ new.origin = old.origin

theorem unchanged_reuse_preserves_entry {old new : Entry} (h : Reuse old new) :
    new = old := by
  cases old with
  | mk oh os ob oc oo =>
    cases new with
    | mk nh ns nb nc no =>
      rcases h with ⟨hh, hs, hb, hc, ho⟩
      simp_all

theorem unknown_origin_stays_unknown_under_reuse {old new : Entry}
    (h : Reuse old new) (unknown : old.origin = .unknown) : new.origin = .unknown :=
  h.2.2.2.2.trans unknown

theorem changed_scope_is_not_unchanged_reuse {old new : Entry}
    (changed : new.scope ≠ old.scope) : ¬ Reuse old new := fun h => changed h.2.1

theorem result_label_cannot_recover_origin :
    ¬ ∃ decode : String → Origin, ∀ e : Entry, decode e.claim = e.origin := by
  rintro ⟨decode, h⟩
  have hd := h ⟨"holder", "scope", "basis", "P", .declared⟩
  have hf := h ⟨"holder", "scope", "basis", "P", .derived⟩
  exact Origin.noConfusion (hd.symm.trans hf)

structure Warrant (Scope Claim : Type*) (holds : Scope → Claim → Prop) where
  scope : Scope
  claim : Claim
  receipt : holds scope claim

theorem warranted_reuse_needs_scope_preservation {Scope Claim : Type*}
    {holds : Scope → Claim → Prop} (w : Warrant Scope Claim holds)
    (nextScope : Scope) (same : nextScope = w.scope) : holds nextScope w.claim := by
  rw [same]
  exact w.receipt

theorem warranted_translation_needs_a_bridge {S T C D : Type*}
    {holds : S → C → Prop} {nextHolds : T → D → Prop}
    (scopeMap : S → T) (claimMap : C → D)
    (bridge : ∀ s c, holds s c → nextHolds (scopeMap s) (claimMap c))
    (w : Warrant S C holds) : nextHolds (scopeMap w.scope) (claimMap w.claim) :=
  bridge w.scope w.claim w.receipt

theorem declared_basis_allows_derived_conclusion (P Q : Prop)
    (adopted : P) (derivation : P → Q) : Q := derivation adopted

theorem derived_tag_alone_does_not_prove_claim :
    ¬ ∀ (P : Prop) (tag : Origin), tag = .derived → P := by
  intro h
  exact h False .derived rfl

-- G. Refinements and protocol changes retain predecessors.
def appendRecord {R : Type*} (history : List R) (record : R) : List R :=
  history ++ [record]

theorem append_record_preserves_prefix {R : Type*} (history : List R) (record : R) :
    (appendRecord history record).take history.length = history := by
  simp [appendRecord]

structure ProtocolEntry (R : Type*) where
  holder : String
  protocol : String
  payload : R

theorem recording_protocol_has_a_holder {R : Type*} (e : ProtocolEntry R) :
    ∃ holder : String, holder = e.holder := ⟨e.holder, rfl⟩

theorem different_origin_rankings_need_no_absolute_comparator :
    ∃ (first second : Bool → ℕ), first false < first true ∧ second true < second false :=
  ⟨(fun b => if b then 1 else 0), (fun b => if b then 0 else 1), by decide, by decide⟩

end LambdaConstitutive

-- Complete statement and transitive dependency receipts.
#check LambdaConstitutive.role_positions_differ
#print axioms LambdaConstitutive.role_positions_differ
#check LambdaConstitutive.one_carrier_can_fill_both_roles
#print axioms LambdaConstitutive.one_carrier_can_fill_both_roles
#check LambdaConstitutive.translation_composes
#print axioms LambdaConstitutive.translation_composes
#check LambdaConstitutive.preserved_predicate_survives_roundtrip
#print axioms LambdaConstitutive.preserved_predicate_survives_roundtrip
#check LambdaConstitutive.changed_middle_predicate_breaks_composition
#print axioms LambdaConstitutive.changed_middle_predicate_breaks_composition
#check LambdaConstitutive.conveyance_collision_blocks_target
#print axioms LambdaConstitutive.conveyance_collision_blocks_target
#check LambdaConstitutive.metadescription_cannot_split_equal_messages
#print axioms LambdaConstitutive.metadescription_cannot_split_equal_messages
#check LambdaConstitutive.erased_depth_has_no_decoder
#print axioms LambdaConstitutive.erased_depth_has_no_decoder
#check LambdaConstitutive.threaded_depth_has_decoder
#print axioms LambdaConstitutive.threaded_depth_has_decoder
#check LambdaConstitutive.retained_argument_can_recover_depth
#print axioms LambdaConstitutive.retained_argument_can_recover_depth
#check LambdaConstitutive.terminating_countdown_has_input_sized_trace
#print axioms LambdaConstitutive.terminating_countdown_has_input_sized_trace
#check LambdaConstitutive.no_uniform_trace_bound_for_terminating_countdown
#print axioms LambdaConstitutive.no_uniform_trace_bound_for_terminating_countdown
#check LambdaConstitutive.finite_state_can_continue_without_halting
#print axioms LambdaConstitutive.finite_state_can_continue_without_halting
#check LambdaConstitutive.exact_recovery_requires_enough_states
#print axioms LambdaConstitutive.exact_recovery_requires_enough_states
#check LambdaConstitutive.exact_subset_memory_requires_all_subsets
#print axioms LambdaConstitutive.exact_subset_memory_requires_all_subsets
#check LambdaConstitutive.exact_depth_through_N_requires_N_plus_one_states
#print axioms LambdaConstitutive.exact_depth_through_N_requires_N_plus_one_states
#check LambdaConstitutive.no_fixed_finite_state_recovers_unbounded_depth
#print axioms LambdaConstitutive.no_fixed_finite_state_recovers_unbounded_depth
#check LambdaConstitutive.online_update_implies_append_compatibility
#print axioms LambdaConstitutive.online_update_implies_append_compatibility
#check LambdaConstitutive.append_compatibility_supplies_online_update
#print axioms LambdaConstitutive.append_compatibility_supplies_online_update
#check LambdaConstitutive.run_preserves_history_encoding
#print axioms LambdaConstitutive.run_preserves_history_encoding
#check LambdaConstitutive.online_target_recovery
#print axioms LambdaConstitutive.online_target_recovery
#check LambdaConstitutive.snapshot_target_can_fail_online_update
#print axioms LambdaConstitutive.snapshot_target_can_fail_online_update
#check LambdaConstitutive.cached_result_does_not_recover_return
#print axioms LambdaConstitutive.cached_result_does_not_recover_return
#check LambdaConstitutive.return_mark_does_not_recover_cached_result
#print axioms LambdaConstitutive.return_mark_does_not_recover_cached_result
#check LambdaConstitutive.joint_record_recovers_both_cache_queries
#print axioms LambdaConstitutive.joint_record_recovers_both_cache_queries
#check LambdaConstitutive.unchanged_reuse_preserves_entry
#print axioms LambdaConstitutive.unchanged_reuse_preserves_entry
#check LambdaConstitutive.unknown_origin_stays_unknown_under_reuse
#print axioms LambdaConstitutive.unknown_origin_stays_unknown_under_reuse
#check LambdaConstitutive.changed_scope_is_not_unchanged_reuse
#print axioms LambdaConstitutive.changed_scope_is_not_unchanged_reuse
#check LambdaConstitutive.result_label_cannot_recover_origin
#print axioms LambdaConstitutive.result_label_cannot_recover_origin
#check LambdaConstitutive.warranted_reuse_needs_scope_preservation
#print axioms LambdaConstitutive.warranted_reuse_needs_scope_preservation
#check LambdaConstitutive.warranted_translation_needs_a_bridge
#print axioms LambdaConstitutive.warranted_translation_needs_a_bridge
#check LambdaConstitutive.declared_basis_allows_derived_conclusion
#print axioms LambdaConstitutive.declared_basis_allows_derived_conclusion
#check LambdaConstitutive.derived_tag_alone_does_not_prove_claim
#print axioms LambdaConstitutive.derived_tag_alone_does_not_prove_claim
#check LambdaConstitutive.append_record_preserves_prefix
#print axioms LambdaConstitutive.append_record_preserves_prefix
#check LambdaConstitutive.recording_protocol_has_a_holder
#print axioms LambdaConstitutive.recording_protocol_has_a_holder
#check LambdaConstitutive.different_origin_rankings_need_no_absolute_comparator
#print axioms LambdaConstitutive.different_origin_rankings_need_no_absolute_comparator
#eval Lean.versionString
#eval "LAMBDA_CONSTITUTIVE_R2_COMPLETE"

#eval Lean.versionString
#eval "LAMBDA_R4_CONSTITUTIVE_END"

SHA-256: b8c6421fce2df48e774e993b2e85a5bf0646539f48064dbe38d3ab1462fe862b

import Mathlib

/-!
# Institutional signals: declared models, not findings about an institution

These results expose assumptions needed to move between public recognition,
eligibility, mathematical truth, and a causal claim about acceptance.
No predicate below certifies Clay eligibility or describes actual human behavior.
-/
namespace LambdaInstitutionalSignals

def thresholdAccepts (evidence signal threshold : Nat) : Prop :=
  threshold ≤ evidence + signal

/-- Under the displayed threshold premises, adding the signal changes the decision. -/
theorem signal_crosses_declared_threshold (evidence signal threshold : Nat)
    (below : evidence < threshold) (enough : threshold ≤ evidence + signal) :
    ¬ thresholdAccepts evidence 0 threshold ∧
      thresholdAccepts evidence signal threshold := by
  unfold thresholdAccepts
  constructor
  · omega
  · exact enough

def observedAcceptance (response : Bool → Bool) : Bool := response true

def SignalDependent (response : Bool → Bool) : Prop :=
  response true ≠ response false

/-- The same observed acceptance is compatible with dependence and independence. -/
theorem observed_acceptance_does_not_identify_dependence :
    ∃ f g : Bool → Bool,
      observedAcceptance f = observedAcceptance g ∧
      SignalDependent f ∧ ¬ SignalDependent g := by
  refine ⟨id, (fun _ => true), rfl, ?_, ?_⟩
  · change (true : Bool) ≠ false
    decide
  · simp [SignalDependent]

/-- No decoder of that observation alone recovers signal-dependence for every response. -/
theorem no_dependence_decoder_from_observed_acceptance :
    ¬ ∃ decode : Bool → Bool, ∀ response : Bool → Bool,
      decode (observedAcceptance response) =
        decide (response true ≠ response false) := by
  rintro ⟨decode, h⟩
  have yes : decode true = true := by
    simpa [observedAcceptance] using h id
  have no := h (fun _ => true)
  simp [observedAcceptance, yes] at no

structure AssessmentCoordinates where
  claimTruth : Bool
  eligible : Bool
  publicRecognition : Bool

/-- Without a bridge, recognition does not recover either of the other coordinates. -/
theorem recognition_does_not_determine_truth_or_eligibility :
    ∃ a b : AssessmentCoordinates,
      a.publicRecognition = b.publicRecognition ∧
      a.claimTruth ≠ b.claimTruth ∧ a.eligible ≠ b.eligible := by
  exact ⟨⟨false, false, true⟩, ⟨true, true, true⟩, rfl, by decide, by decide⟩

end LambdaInstitutionalSignals

#check @LambdaInstitutionalSignals.signal_crosses_declared_threshold
#print axioms LambdaInstitutionalSignals.signal_crosses_declared_threshold
#check @LambdaInstitutionalSignals.observed_acceptance_does_not_identify_dependence
#print axioms LambdaInstitutionalSignals.observed_acceptance_does_not_identify_dependence
#check @LambdaInstitutionalSignals.no_dependence_decoder_from_observed_acceptance
#print axioms LambdaInstitutionalSignals.no_dependence_decoder_from_observed_acceptance
#check @LambdaInstitutionalSignals.recognition_does_not_determine_truth_or_eligibility
#print axioms LambdaInstitutionalSignals.recognition_does_not_determine_truth_or_eligibility
#eval Lean.versionString
#eval "LAMBDA_R4_INSTITUTIONALSIGNALS_END"

SHA-256: 58679cfd9ca92e15e0868fa21c1eeca3cee32bd11cb8689558cd6c6327ecd69d

import Mathlib

/-!
# Lambda: the equal-standard instrument, successor R1
Authorial program: Lu Semita / EmergenceByDesign. Consolidated 2026-09-13.
This file proves the declared mathematical contracts. Case parameters do not
silently import a PDE, a quantum field theory, or an arithmetic equivalence.
The source and receipt, together, delimit the meaning of `verified`.
-/
namespace LambdaInstrument

-- A. Information, target recovery, and declared changes.
def Recoverable {X Y Z : Type*} (read : X → Y) (target : X → Z) : Prop :=
  ∃ decode : Y → Z, ∀ x, decode (read x) = target x

theorem recovery_iff_fibre_constancy {X Y Z : Type*} [Nonempty Z]
    (read : X → Y) (target : X → Z) :
    Recoverable read target ↔
      ∀ x y, read x = read y → target x = target y := by
  classical
  constructor
  · rintro ⟨d, hd⟩ x y h
    rw [← hd x, ← hd y, h]
  · intro h
    let d : Y → Z := fun y => if hy : ∃ x, read x = y
      then target (Classical.choose hy) else Classical.choice inferInstance
    refine ⟨d, ?_⟩
    intro x
    have hx : ∃ a, read a = read x := ⟨x, rfl⟩
    simp only [d, dite_eq_left hx]
    exact h _ x (Classical.choose_spec hx)

theorem collision_blocks_recovery {X Y Z : Type*}
    (read : X → Y) (target : X → Z) {a b : X}
    (same : read a = read b) (split : target a ≠ target b) :
    ¬ Recoverable read target := by
  rintro ⟨d, hd⟩
  apply split
  rw [← hd a, ← hd b, same]

theorem postprocessing_preserves_collision {X Y Z : Type*}
    (read : X → Y) (post : Y → Z) {a b : X}
    (h : read a = read b) : post (read a) = post (read b) := congrArg post h

theorem enriched_readout_recovers_target {X Y Z : Type*}
    (read : X → Y) (target : X → Z) :
    Recoverable (fun x => (read x, target x)) target := ⟨Prod.snd, fun _ => rfl⟩

theorem one_sided_certificate_contract {X Y : Type*}
    (read : X → Y) (fires : Y → Prop) (target : X → Prop) :
    (∀ x, fires (read x) → target x) ↔
      {x | fires (read x)} ⊆ {x | target x} := Iff.rfl

theorem entailed_condition_preserves_acceptance {X : Type*}
    (accept condition : X → Prop) (h : ∀ x, accept x → condition x) :
    ∀ x, (accept x ∧ condition x) ↔ accept x := by
  intro x
  exact ⟨And.left, fun ha => ⟨ha, h x ha⟩⟩

theorem new_condition_changes_acceptance {X : Type*}
    (accept condition : X → Prop) {x : X}
    (ha : accept x) (hc : ¬ condition x) :
    ¬ (∀ y, (accept y ∧ condition y) ↔ accept y) := by
  intro h
  exact hc ((h x).mpr ha).2

theorem equal_declared_inputs_equal_outputs {X Y Z : Type*}
    (read : X → Y) (judge : X → Z) (h : Recoverable read judge)
    {a b : X} (same : read a = read b) : judge a = judge b := by
  obtain ⟨d, hd⟩ := h
  rw [← hd a, ← hd b, same]

theorem different_outputs_require_distinction {X Y Z : Type*}
    (read : X → Y) (judge : X → Z) (h : Recoverable read judge)
    {a b : X} (split : judge a ≠ judge b) : read a ≠ read b := by
  intro same
  exact split (equal_declared_inputs_equal_outputs read judge h same)

-- B. Burden reversal: missing refutation versus a proof of existence.
theorem no_refutation_is_not_a_general_proof :
    ¬ (∀ (certified : Prop → Prop) (P : Prop),
      (∀ Q, certified Q → Q) → ¬ certified (¬ P) → P) := by
  intro h
  exact h (fun _ => False) False (fun _ hf => hf.elim) (fun hf => hf)

theorem completeness_licenses_reversal
    (certified : Prop → Prop) (P : Prop)
    (completeAtNegation : (¬ P) → certified (¬ P))
    (noRefutation : ¬ certified (¬ P)) : P := by
  classical
  by_contra h
  exact noRefutation (completeAtNegation h)

theorem existential_claim_needs_no_closed_form {X : Type*} (P : X → Prop)
    (construction : ∃ x, P x) : ¬ (∀ x, ¬ P x) := by
  rintro h
  obtain ⟨x, hx⟩ := construction
  exact h x hx

theorem residual_equation_has_witness {X F : Type*} (residual : X → F) (x : X) :
    ∃ f, f = residual x := ⟨residual x, rfl⟩

theorem residual_admissibility_is_the_obligation {X F : Type*}
    (residual : X → F) (admitted : F → Prop) (x : X) :
    (∃ f, f = residual x ∧ admitted f) ↔ admitted (residual x) := by
  constructor
  · rintro ⟨f, rfl, hf⟩
    exact hf
  · intro h
    exact ⟨residual x, rfl, h⟩

-- C. Finite observation and an all-stage target.
def AllStages (P : ℕ → Prop) : Prop := ∀ n, P n
def Window (N : ℕ) (P : ℕ → Prop) : Prop := ∀ n, n < N → P n

theorem finite_window_has_opposite_extensions (N : ℕ) :
    ∃ good bad : ℕ → Prop,
      Window N good ∧ Window N bad ∧ AllStages good ∧ ¬ AllStages bad := by
  refine ⟨fun _ => True, fun n => n < N, ?_, ?_, ?_, ?_⟩
  · intro n hn; trivial
  · intro n hn; exact hn
  · intro n; trivial
  · intro h; exact Nat.lt_irrefl N (h N)

theorem no_fixed_window_decides_unrestricted_tail (N : ℕ) :
    ¬ (∀ P : ℕ → Prop, Window N P → AllStages P) := by
  intro h
  exact Nat.lt_irrefl N (h (fun n => n < N) (fun _ hn => hn) N)

theorem universal_proof_closes_all_windows (P : ℕ → Prop)
    (h : AllStages P) : ∀ N, Window N P := fun _ n _ => h n

theorem all_windows_iff_all_stages (P : ℕ → Prop) :
    (∀ N, Window N P) ↔ AllStages P := by
  constructor
  · intro h n; exact h (n + 1) n (Nat.lt_succ_self n)
  · exact universal_proof_closes_all_windows P

theorem actual_failure_refutes_tail (P : ℕ → Prop) {n : ℕ}
    (failure : ¬ P n) : ¬ AllStages P := fun h => failure (h n)

theorem tail_negation_has_failure (P : ℕ → Prop) :
    ¬ AllStages P ↔ ∃ n, ¬ P n := by
  classical
  simp [AllStages]

-- D. Navier-Stokes: the official force-quantifier relationship, abstract carrier.
def NSGlobal {D F : Type*} (admD : D → Prop) (global : D → F → Prop)
    (zeroForce : F) : Prop := ∀ d, admD d → global d zeroForce
def NSForcedFailure {D F : Type*} (admD : D → Prop) (admF : F → Prop)
    (global : D → F → Prop) : Prop :=
  ∃ d f, admD d ∧ admF f ∧ ¬ global d f

theorem unforced_failure_is_admitted_forced_failure {D F : Type*}
    (admD : D → Prop) (admF : F → Prop) (global : D → F → Prop)
    (zeroForce : F) (zeroAdmitted : admF zeroForce)
    (failure : ¬ NSGlobal admD global zeroForce) :
    NSForcedFailure admD admF global := by
  classical
  unfold NSGlobal at failure
  push Not at failure
  obtain ⟨d, hd, hn⟩ := failure
  exact ⟨d, zeroForce, hd, zeroAdmitted, hn⟩

theorem forced_failure_can_coexist_with_unforced_global :
    ∃ global : Unit → Bool → Prop,
      NSGlobal (fun _ => True) global false ∧
      NSForcedFailure (fun _ => True) (fun _ => True) global := by
  refine ⟨fun _ f => f = false, ?_, ?_⟩
  · intro d hd; rfl
  · exact ⟨(), true, trivial, trivial, Bool.noConfusion⟩

def NSRegular {D : Type*} (regularWindow : D → ℕ → Prop) (d : D) : Prop :=
  ∀ n, regularWindow d n
def NSBlowup {D Time : Type*} (before : D → Time → Prop)
    (size : D → Time → ℝ) (d : D) : Prop :=
  ∀ M : ℝ, ∃ t, before d t ∧ M < size d t

theorem ns_regularity_requires_each_window {D : Type*}
    (window : D → ℕ → Prop) (d : D) :
    NSRegular window d ↔ ∀ N, Window N (window d) :=
  (all_windows_iff_all_stages (window d)).symm

theorem ns_uniform_bound_excludes_encoded_blowup {D Time : Type*}
    (before : D → Time → Prop) (size : D → Time → ℝ) (d : D)
    (bound : ∃ K, ∀ t, before d t → size d t ≤ K) :
    ¬ NSBlowup before size d := by
  rintro h
  obtain ⟨K, hK⟩ := bound
  obtain ⟨t, ht, hb⟩ := h K
  exact (not_lt_of_ge (hK t ht)) hb

theorem invariant_exact_classifier {X : Type*} (move : X → X)
    (H B : X → Prop) (equiv : ∀ x, H x ↔ B x)
    (inv : ∀ x, B (move x) ↔ B x) : ∀ x, H (move x) ↔ H x := by
  intro x
  exact (equiv (move x)).trans ((inv x).trans (equiv x).symm)

theorem sufficient_condition_need_not_be_invariant :
    ∃ H B : Bool → Prop,
      (∀ x, H x → B x) ∧ (∀ x, B (!x) ↔ B x) ∧
      ¬ (H (!false) ↔ H false) := by
  refine ⟨fun b => b = false, fun _ => True, ?_, ?_, ?_⟩
  · intro x hx; trivial
  · intro x; rfl
  · simp

-- E. Riemann: direct zero predicate and an explicitly bridged tail coding.
def RHForm {Zero : Type*} (nontrivial onLine : Zero → Prop) : Prop :=
  ∀ z, nontrivial z → onLine z

theorem rh_counterexample_duality {Zero : Type*} (nontrivial onLine : Zero → Prop) :
    ¬ RHForm nontrivial onLine ↔ ∃ z, nontrivial z ∧ ¬ onLine z := by
  classical
  simp [RHForm]

theorem rh_tail_transport {Zero : Type*} (nontrivial onLine : Zero → Prop)
    (test : ℕ → Prop) (bridge : RHForm nontrivial onLine ↔ AllStages test)
    (closure : ∀ n, test n) : RHForm nontrivial onLine := bridge.mpr closure

-- F. Yang-Mills: one common positive bound and the continuum theory obligation.
def UniformGap {State : Type*} (excited : State → Prop) (energy : State → ℝ) : Prop :=
  ∃ δ : ℝ, 0 < δ ∧ ∀ s, excited s → δ ≤ energy s
def YMForm {Group Theory State : Type*} (admissibleGroup : Group → Prop)
    (validTheory : Group → Theory → Prop)
    (excited : Theory → State → Prop) (energy : Theory → State → ℝ) : Prop :=
  ∀ g, admissibleGroup g → ∃ t, validTheory g t ∧ UniformGap (excited t) (energy t)

theorem uniform_gap_implies_pointwise_positive {State : Type*}
    (excited : State → Prop) (energy : State → ℝ)
    (h : UniformGap excited energy) : ∀ s, excited s → 0 < energy s := by
  obtain ⟨δ, hδ, hs⟩ := h
  intro s he
  exact lt_of_lt_of_le hδ (hs s he)

theorem pointwise_positive_need_not_have_uniform_gap :
    (∀ x : {r : ℝ // 0 < r}, 0 < x.val) ∧
    ¬ UniformGap (fun _ : {r : ℝ // 0 < r} => True) (fun x => x.val) := by
  refine ⟨fun x => x.property, ?_⟩
  rintro ⟨δ, hδ, hs⟩
  have h := hs ⟨δ / 2, by linarith⟩ trivial
  dsimp at h
  linarith

theorem common_gap_survives_order_limit {State : Type*}
    (excited : State → Prop) (energy : State → ℝ) (approx : ℕ → State → ℝ)
    (δ : ℝ) (positive : 0 < δ)
    (bounds : ∀ n s, excited s → δ ≤ approx n s)
    (passToLimit : ∀ s, (∀ n, δ ≤ approx n s) → δ ≤ energy s) :
    UniformGap excited energy := by
  refine ⟨δ, positive, ?_⟩
  intro s hs
  exact passToLimit s (fun n => bounds n s hs)

-- G. Hodge: exact cycle-class image, finite witness, global quantifier.
def HodgeForm {Instance Cycle : Type*} (admitted : Instance → Prop)
    (represents : Cycle → Instance → Prop) : Prop :=
  ∀ i, admitted i → ∃ c, represents c i

theorem hodge_actual_cycle_closes_instance {Instance Cycle : Type*}
    (represents : Cycle → Instance → Prop) (i : Instance) (c : Cycle)
    (certificate : represents c i) : ∃ w, represents w i := ⟨c, certificate⟩

theorem hodge_nonmembership_requires_all_cycles {Instance Cycle : Type*}
    (represents : Cycle → Instance → Prop) (i : Instance) :
    (¬ ∃ c, represents c i) ↔ ∀ c, ¬ represents c i := by simp

theorem hodge_separating_invariant_closes_nonmembership {Instance Cycle : Type*}
    (represents : Cycle → Instance → Prop) (invariant : Instance → Prop)
    (sound : ∀ c i, represents c i → invariant i) {i : Instance}
    (separates : ¬ invariant i) : ¬ ∃ c, represents c i := by
  rintro ⟨c, hc⟩
  exact separates (sound c i hc)

theorem hodge_finite_empty_search_not_universal (S : Finset ℕ) :
    ∃ witness : ℕ → Prop, (∀ n ∈ S, ¬ witness n) ∧ ∃ n, witness n := by
  let m := S.sup id + 1
  have hm : m ∉ S := by
    intro h
    have hh := Finset.le_sup (f := id) h
    dsimp [m] at *
    omega
  refine ⟨fun n => n = m, ?_, m, rfl⟩
  intro n hn heq
  exact hm (heq ▸ hn)

-- H. P versus NP: candidates include a machine and a polynomial clock.
def PolyCandidateForm {Candidate Input : Type*} (correct : Candidate → Input → Prop) : Prop :=
  ∃ c, ∀ x, correct c x

theorem pnp_quantifier_duality {Candidate Input : Type*}
    (correct : Candidate → Input → Prop) :
    ¬ PolyCandidateForm correct ↔ ∀ c, ∃ x, ¬ correct c x := by
  classical
  simp [PolyCandidateForm]

theorem pnp_candidate_with_all_input_proof_closes {Candidate Input : Type*}
    (correct : Candidate → Input → Prop) (c : Candidate)
    (allInputs : ∀ x, correct c x) : PolyCandidateForm correct := ⟨c, allInputs⟩

theorem bounded_tests_do_not_prove_candidate (N : ℕ) :
    ∃ correct : Unit → ℕ → Prop,
      (∀ n, n < N → correct () n) ∧ ¬ PolyCandidateForm correct := by
  refine ⟨fun _ n => n < N, fun _ h => h, ?_⟩
  rintro ⟨c, h⟩
  exact Nat.lt_irrefl N (h N)

-- I. BSD: rank comparison, analytic order, and product identification.
def BSDRankForm {Curve : Type*} (algRank anRank : Curve → ℕ) : Prop :=
  ∀ E, algRank E = anRank E
def ExactOrder (coefficient : ℕ → ℝ) (r : ℕ) : Prop :=
  (∀ n, n < r → coefficient n = 0) ∧ coefficient r ≠ 0

theorem bsd_matching_bounds_close_rank (rank lower upper : ℕ)
    (hl : lower ≤ rank) (hu : rank ≤ upper) (meet : lower = upper) :
    rank = lower := by omega

theorem bsd_matching_certificates_close_instance (alg an lower upper : ℕ)
    (hl : lower ≤ alg) (hu : alg ≤ upper) (meet : lower = upper)
    (analytic : an = lower) : alg = an := by omega

theorem exact_order_unique (a : ℕ → ℝ) {r s : ℕ}
    (hr : ExactOrder a r) (hs : ExactOrder a s) : r = s := by
  by_contra h
  rcases lt_or_gt_of_ne h with hlt | hgt
  · exact hr.2 (hs.1 r hlt)
  · exact hs.2 (hr.1 s hgt)

theorem nonzero_term_alone_not_exact_order :
    ∃ a : ℕ → ℝ, a 1 ≠ 0 ∧ ¬ ExactOrder a 1 := by
  refine ⟨fun _ => 1, one_ne_zero, ?_⟩
  intro h
  exact one_ne_zero (h.1 0 (by omega))

theorem product_readout_loses_factor :
    ¬ Recoverable (fun p : ℝ × ℝ => p.1 * p.2) Prod.fst := by
  apply collision_blocks_recovery _ _ (a := (1, 6)) (b := (2, 3))
  · norm_num
  · norm_num

theorem anchored_product_recovers_factor (a b c : ℝ) (ha : a ≠ 0)
    (h : a * b = a * c) : b = c := (mul_left_cancel₀ ha) h

-- J. Pi and e: exact representation classes and a substantive positive control.
theorem pi_outside_rational_image : ¬ ∃ q : ℚ, (q : ℝ) = Real.pi := by
  rintro ⟨q, hq⟩
  exact irrational_pi ⟨q, hq⟩

theorem pi_no_finite_base_fraction (a : ℤ) (b n : ℕ) :
    Real.pi ≠ (a : ℝ) / (b : ℝ) ^ n := by
  have h := irrational_pi.ne_rational a (b ^ n)
  simpa only [Int.cast_pow, Int.cast_natCast] using h

theorem irrational_can_have_arbitrarily_close_rationals (x : ℝ) (ε : ℝ)
    (hε : 0 < ε) : ∃ q : ℚ, 0 < (q : ℝ) - x ∧ (q : ℝ) - x < ε := by
  obtain ⟨q, hq₁, hq₂⟩ := exists_rat_btwn (show x < x + ε by linarith)
  exact ⟨q, by linarith, by linarith⟩

theorem transcendental_excludes_algebraic_representation (x : ℝ)
    (hx : Transcendental ℚ x) :
    ¬ ∃ y : ℝ, IsAlgebraic ℚ y ∧ y = x := by
  rintro ⟨y, hy, rfl⟩
  exact hx hy

theorem enlarged_real_polynomials_have_exact_root (x : ℝ) :
    ∃ p : Polynomial ℝ, p ≠ 0 ∧ p.eval x = 0 := by
  refine ⟨Polynomial.X - Polynomial.C x, ?_, ?_⟩
  · intro h
    have hc := congrArg (fun p : Polynomial ℝ => p.coeff 1) h
    simp at hc
  · simp

theorem e_exceeds_every_finite_factorial_sum (n : ℕ) :
    (∑ i ∈ Finset.range n, (1 : ℝ) / i.factorial) < Real.exp 1 := by
  have h := Real.sum_le_exp_of_nonneg (show (0 : ℝ) ≤ 1 by norm_num) (n + 1)
  simp only [Finset.sum_range_succ, one_pow] at h
  have hp : (0 : ℝ) < 1 / (n.factorial : ℝ) := by positivity
  linarith

theorem e_algebraic_class_closure_contract (h : Transcendental ℚ (Real.exp 1)) :
    ∀ p : Polynomial ℚ, p ≠ 0 → Polynomial.aeval (Real.exp 1) p ≠ 0 := by
  intro p hp he
  exact hp ((transcendental_iff.mp h) p he)

-- K. Reader instrument. Status completeness is a declared datatype contract.
inductive Status where
  | accepted | rejected | open | scopeChange
  deriving DecidableEq, Repr

structure Assessment (Claim Scope Evidence : Type*) where
  claim : Claim
  scope : Scope
  evidence : Evidence
  rule : Scope → Evidence → Status
  verdict : Status
  receipt : rule scope evidence = verdict

theorem consideration_has_an_applied_rule {C S E : Type*}
    (a : Assessment C S E) :
    ∃ rule : S → E → Status, rule a.scope a.evidence = a.verdict := ⟨a.rule, a.receipt⟩

theorem challenge_is_an_instance {C S E : Type*}
    (a : Assessment C S E) (rejects : a.verdict = Status.rejected) :
    a.rule a.scope a.evidence = Status.rejected := a.receipt.trans rejects

theorem shared_rule_scope_evidence_force_shared_status {C S E : Type*}
    (a b : Assessment C S E) (hr : a.rule = b.rule)
    (hs : a.scope = b.scope) (he : a.evidence = b.evidence) :
    a.verdict = b.verdict := by rw [← a.receipt, ← b.receipt, hr, hs, he]

theorem same_evidence_can_support_different_declared_rules :
    ∃ a b : Assessment Unit Unit Unit,
      a.claim = b.claim ∧ a.scope = b.scope ∧ a.evidence = b.evidence ∧
      a.verdict ≠ b.verdict := by
  refine ⟨⟨(), (), (), fun _ _ => .accepted, .accepted, rfl⟩,
    ⟨(), (), (), fun _ _ => .rejected, .rejected, rfl⟩, rfl, rfl, rfl, ?_⟩
  intro h; cases h

theorem receipt_does_not_certify_rule_soundness :
    ∃ a : Assessment Prop Unit Unit,
      a.claim = False ∧ a.verdict = Status.accepted :=
  ⟨⟨False, (), (), fun _ _ => .accepted, .accepted, rfl⟩, rfl, rfl⟩

theorem a_sound_rejection_can_defeat_a_claim (P : Prop)
    (soundRejection : ¬ P) : ¬ P := soundRejection

structure Record where
  text : String
  status : Status
  scope : String
  reason : String
  actor : String
  parent : Option ℕ
  deriving Repr

def append (history : List Record) (r : Record) : List Record := history ++ [r]

theorem any_finite_comment_can_be_registered (s : String) :
    ∃ r : Record, r.text = s := ⟨⟨s, .open, "unassigned", "awaiting classification", "unassigned", none⟩, rfl⟩

theorem append_preserves_earlier_records (history : List Record) (r old : Record)
    (h : old ∈ history) : old ∈ append history r := by simp [append, h]

theorem finite_registry_has_no_fixed_capacity (history : List Record) (r : Record) :
    (append history r).length = history.length + 1 := by simp [append]

theorem declared_statuses_exhaustive (s : Status) :
    s = .accepted ∨ s = .rejected ∨ s = .open ∨ s = .scopeChange := by cases s <;> simp

inductive StopMode (Actor : Type*) where
  | effective (testRan : Bool) (checked : testRan = true)
  | declared (actor : Actor)

theorem stop_mode_contract {Actor : Type*} (s : StopMode Actor) :
    (∃ b h, s = StopMode.effective b h) ∨
      (∃ actor, s = StopMode.declared actor) := by
  cases s with
  | effective b h => exact Or.inl ⟨b, h, rfl⟩
  | declared actor => exact Or.inr ⟨actor, rfl⟩

end LambdaInstrument

-- Exact theorem statements and transitive axiom dependencies.
#check LambdaInstrument.recovery_iff_fibre_constancy
#print axioms LambdaInstrument.recovery_iff_fibre_constancy
#check LambdaInstrument.collision_blocks_recovery
#print axioms LambdaInstrument.collision_blocks_recovery
#check LambdaInstrument.postprocessing_preserves_collision
#print axioms LambdaInstrument.postprocessing_preserves_collision
#check LambdaInstrument.enriched_readout_recovers_target
#print axioms LambdaInstrument.enriched_readout_recovers_target
#check LambdaInstrument.one_sided_certificate_contract
#print axioms LambdaInstrument.one_sided_certificate_contract
#check LambdaInstrument.entailed_condition_preserves_acceptance
#print axioms LambdaInstrument.entailed_condition_preserves_acceptance
#check LambdaInstrument.new_condition_changes_acceptance
#print axioms LambdaInstrument.new_condition_changes_acceptance
#check LambdaInstrument.equal_declared_inputs_equal_outputs
#print axioms LambdaInstrument.equal_declared_inputs_equal_outputs
#check LambdaInstrument.different_outputs_require_distinction
#print axioms LambdaInstrument.different_outputs_require_distinction
#check LambdaInstrument.no_refutation_is_not_a_general_proof
#print axioms LambdaInstrument.no_refutation_is_not_a_general_proof
#check LambdaInstrument.completeness_licenses_reversal
#print axioms LambdaInstrument.completeness_licenses_reversal
#check LambdaInstrument.existential_claim_needs_no_closed_form
#print axioms LambdaInstrument.existential_claim_needs_no_closed_form
#check LambdaInstrument.residual_equation_has_witness
#print axioms LambdaInstrument.residual_equation_has_witness
#check LambdaInstrument.residual_admissibility_is_the_obligation
#print axioms LambdaInstrument.residual_admissibility_is_the_obligation
#check LambdaInstrument.finite_window_has_opposite_extensions
#print axioms LambdaInstrument.finite_window_has_opposite_extensions
#check LambdaInstrument.no_fixed_window_decides_unrestricted_tail
#print axioms LambdaInstrument.no_fixed_window_decides_unrestricted_tail
#check LambdaInstrument.universal_proof_closes_all_windows
#print axioms LambdaInstrument.universal_proof_closes_all_windows
#check LambdaInstrument.all_windows_iff_all_stages
#print axioms LambdaInstrument.all_windows_iff_all_stages
#check LambdaInstrument.actual_failure_refutes_tail
#print axioms LambdaInstrument.actual_failure_refutes_tail
#check LambdaInstrument.tail_negation_has_failure
#print axioms LambdaInstrument.tail_negation_has_failure
#check LambdaInstrument.unforced_failure_is_admitted_forced_failure
#print axioms LambdaInstrument.unforced_failure_is_admitted_forced_failure
#check LambdaInstrument.forced_failure_can_coexist_with_unforced_global
#print axioms LambdaInstrument.forced_failure_can_coexist_with_unforced_global
#check LambdaInstrument.ns_regularity_requires_each_window
#print axioms LambdaInstrument.ns_regularity_requires_each_window
#check LambdaInstrument.ns_uniform_bound_excludes_encoded_blowup
#print axioms LambdaInstrument.ns_uniform_bound_excludes_encoded_blowup
#check LambdaInstrument.invariant_exact_classifier
#print axioms LambdaInstrument.invariant_exact_classifier
#check LambdaInstrument.sufficient_condition_need_not_be_invariant
#print axioms LambdaInstrument.sufficient_condition_need_not_be_invariant
#check LambdaInstrument.rh_counterexample_duality
#print axioms LambdaInstrument.rh_counterexample_duality
#check LambdaInstrument.rh_tail_transport
#print axioms LambdaInstrument.rh_tail_transport
#check LambdaInstrument.uniform_gap_implies_pointwise_positive
#print axioms LambdaInstrument.uniform_gap_implies_pointwise_positive
#check LambdaInstrument.pointwise_positive_need_not_have_uniform_gap
#print axioms LambdaInstrument.pointwise_positive_need_not_have_uniform_gap
#check LambdaInstrument.common_gap_survives_order_limit
#print axioms LambdaInstrument.common_gap_survives_order_limit
#check LambdaInstrument.hodge_actual_cycle_closes_instance
#print axioms LambdaInstrument.hodge_actual_cycle_closes_instance
#check LambdaInstrument.hodge_nonmembership_requires_all_cycles
#print axioms LambdaInstrument.hodge_nonmembership_requires_all_cycles
#check LambdaInstrument.hodge_separating_invariant_closes_nonmembership
#print axioms LambdaInstrument.hodge_separating_invariant_closes_nonmembership
#check LambdaInstrument.hodge_finite_empty_search_not_universal
#print axioms LambdaInstrument.hodge_finite_empty_search_not_universal
#check LambdaInstrument.pnp_quantifier_duality
#print axioms LambdaInstrument.pnp_quantifier_duality
#check LambdaInstrument.pnp_candidate_with_all_input_proof_closes
#print axioms LambdaInstrument.pnp_candidate_with_all_input_proof_closes
#check LambdaInstrument.bounded_tests_do_not_prove_candidate
#print axioms LambdaInstrument.bounded_tests_do_not_prove_candidate
#check LambdaInstrument.bsd_matching_bounds_close_rank
#print axioms LambdaInstrument.bsd_matching_bounds_close_rank
#check LambdaInstrument.bsd_matching_certificates_close_instance
#print axioms LambdaInstrument.bsd_matching_certificates_close_instance
#check LambdaInstrument.exact_order_unique
#print axioms LambdaInstrument.exact_order_unique
#check LambdaInstrument.nonzero_term_alone_not_exact_order
#print axioms LambdaInstrument.nonzero_term_alone_not_exact_order
#check LambdaInstrument.product_readout_loses_factor
#print axioms LambdaInstrument.product_readout_loses_factor
#check LambdaInstrument.anchored_product_recovers_factor
#print axioms LambdaInstrument.anchored_product_recovers_factor
#check LambdaInstrument.pi_outside_rational_image
#print axioms LambdaInstrument.pi_outside_rational_image
#check LambdaInstrument.pi_no_finite_base_fraction
#print axioms LambdaInstrument.pi_no_finite_base_fraction
#check LambdaInstrument.irrational_can_have_arbitrarily_close_rationals
#print axioms LambdaInstrument.irrational_can_have_arbitrarily_close_rationals
#check LambdaInstrument.transcendental_excludes_algebraic_representation
#print axioms LambdaInstrument.transcendental_excludes_algebraic_representation
#check LambdaInstrument.enlarged_real_polynomials_have_exact_root
#print axioms LambdaInstrument.enlarged_real_polynomials_have_exact_root
#check LambdaInstrument.e_exceeds_every_finite_factorial_sum
#print axioms LambdaInstrument.e_exceeds_every_finite_factorial_sum
#check LambdaInstrument.e_algebraic_class_closure_contract
#print axioms LambdaInstrument.e_algebraic_class_closure_contract
#check LambdaInstrument.consideration_has_an_applied_rule
#print axioms LambdaInstrument.consideration_has_an_applied_rule
#check LambdaInstrument.challenge_is_an_instance
#print axioms LambdaInstrument.challenge_is_an_instance
#check LambdaInstrument.shared_rule_scope_evidence_force_shared_status
#print axioms LambdaInstrument.shared_rule_scope_evidence_force_shared_status
#check LambdaInstrument.same_evidence_can_support_different_declared_rules
#print axioms LambdaInstrument.same_evidence_can_support_different_declared_rules
#check LambdaInstrument.receipt_does_not_certify_rule_soundness
#print axioms LambdaInstrument.receipt_does_not_certify_rule_soundness
#check LambdaInstrument.a_sound_rejection_can_defeat_a_claim
#print axioms LambdaInstrument.a_sound_rejection_can_defeat_a_claim
#check LambdaInstrument.any_finite_comment_can_be_registered
#print axioms LambdaInstrument.any_finite_comment_can_be_registered
#check LambdaInstrument.append_preserves_earlier_records
#print axioms LambdaInstrument.append_preserves_earlier_records
#check LambdaInstrument.finite_registry_has_no_fixed_capacity
#print axioms LambdaInstrument.finite_registry_has_no_fixed_capacity
#check LambdaInstrument.declared_statuses_exhaustive
#print axioms LambdaInstrument.declared_statuses_exhaustive
#check LambdaInstrument.stop_mode_contract
#print axioms LambdaInstrument.stop_mode_contract
#eval Lean.versionString
#eval "LAMBDA_INSTRUMENT_R1"

SHA-256: c01c21aa7457f0f6b07bc3e838e663cefcf49e1f481b6f04e144bc796c12ff79

import Mathlib

/-!
Part II: exact arithmetic, spectral projection, and indexed residue.
The ledger in the paper gives the scope of each declaration.
-/
namespace EnumerativeEnergy

theorem prime_iff_no_intermediate_divisor (n : ℕ) (hn : 2 ≤ n) :
    Nat.Prime n ↔ ¬ ∃ d : ℕ, d ∣ n ∧ 2 ≤ d ∧ d < n := by
  constructor
  · intro hp
    rintro ⟨d, hd, htwo, hlt⟩
    have hne : d ≠ 1 := by omega
    have heq := (hp.dvd_iff_eq hne).mp hd
    omega
  · intro h
    by_contra hnp
    exact h (Nat.exists_dvd_of_not_prime2 hn hnp)

theorem prime_step_gcd_one (p k : ℕ) (hp : Nat.Prime p)
    (hk : 0 < k) (hkp : k < p) : Nat.gcd p k = 1 := by
  exact (Nat.coprime_of_lt_prime (Nat.ne_of_gt hk) hkp hp).gcd_eq_one

theorem shared_divisibility (n m d : ℕ) :
    d ∣ Nat.gcd n m ↔ d ∣ n ∧ d ∣ m := by
  exact Nat.dvd_gcd_iff

theorem simultaneous_return (n m t : ℕ) :
    Nat.lcm n m ∣ t ↔ n ∣ t ∧ m ∣ t := by
  exact Nat.lcm_dvd_iff

def orbit {A : Type*} (f : A → A) : ℕ → A → A
  | 0, x => x
  | n + 1, x => f (orbit f n x)

theorem relabeling_preserves_orbit {A B : Type*}
    (e : A ≃ B) (f : A → A) (n : ℕ) (x : A) :
    orbit (fun y => e (f (e.symm y))) n (e x) = e (orbit f n x) := by
  induction n with
  | zero => rfl
  | succ n ih =>
    simp only [orbit, ih, Equiv.symm_apply_apply]

theorem relabeling_preserves_return {A B : Type*}
    (e : A ≃ B) (f : A → A) (n : ℕ) (x : A) :
    orbit (fun y => e (f (e.symm y))) n (e x) = e x ↔ orbit f n x = x := by
  rw [relabeling_preserves_orbit]
  exact e.injective.eq_iff

noncomputable def spectralRead (z : ℂ) : ℂ := 2 - z - z⁻¹

theorem inversion_preserves_spectral_read (z : ℂ) :
    spectralRead z⁻¹ = spectralRead z := by
  simp only [spectralRead, inv_inv]
  ring

theorem spectral_collision_has_two_branches (z w : ℂ)
    (hz : z ≠ 0) (hw : w ≠ 0) (h : spectralRead z = spectralRead w) :
    z = w ∨ z * w = 1 := by
  have hid : (spectralRead z - spectralRead w) * (z * w) =
      -(z - w) * (z * w - 1) := by
    dsimp [spectralRead]
    field_simp
    ring
  rw [h, sub_self, zero_mul] at hid
  have hp : (z - w) * (z * w - 1) = 0 := by
    linear_combination hid
  rcases mul_eq_zero.mp hp with heq | hinv
  · exact Or.inl (sub_eq_zero.mp heq)
  · exact Or.inr (sub_eq_zero.mp hinv)

theorem spectral_read_cannot_recover_phase (z : ℂ) (hz : z ≠ 0)
    (hd : z ≠ z⁻¹) :
    ¬ ∃ f : ℂ → ℂ, ∀ w : ℂ, w ≠ 0 → f (spectralRead w) = w := by
  rintro ⟨f, hf⟩
  have h1 := hf z hz
  have h2 := hf z⁻¹ (inv_ne_zero hz)
  rw [inversion_preserves_spectral_read] at h2
  exact hd (h1.symm.trans h2)

theorem ordered_count_from_union_data {A : Type*} [DecidableEq A]
    (s t : Finset A) (g f : ℕ)
    (hs : s.card = g) (ht : t.card = g) (hi : (s ∩ t).card = f) :
    (s ∪ t).card = 2 * g - f := by
  have h := Finset.card_union_add_card_inter s t
  omega

theorem common_energy_shift_preserves_gaps (a b offset : ℝ) :
    (a + offset) - (b + offset) = a - b := by ring

theorem calibration_rescaling_preserves_phase (scale energy time : ℝ)
    (hs : scale ≠ 0) :
    (scale * energy) * (time / scale) = energy * time := by
  field_simp

noncomputable def indexedResidue {A : Type*} (S : Set A) (cost : A → ENNReal) : ENNReal :=
  sInf (cost '' S)

theorem residue_monotone {A : Type*} (S T : Set A)
    (cost : A → ENNReal) (h : S ⊆ T) :
    indexedResidue T cost ≤ indexedResidue S cost := by
  unfold indexedResidue
  apply sInf_le_sInf
  rintro y ⟨x, hx, rfl⟩
  exact ⟨x, h hx, rfl⟩

theorem conservative_representation_preserves_theorems {P T : Type*}
    (R0 R1 : Set P) (conclusion : P → T) (expand : P → P)
    (hin : R0 ⊆ R1)
    (hex : ∀ p ∈ R1, expand p ∈ R0 ∧ conclusion (expand p) = conclusion p)
    (target : T) :
    (∃ p ∈ R0, conclusion p = target) ↔ (∃ p ∈ R1, conclusion p = target) := by
  constructor
  · rintro ⟨p, hp, hc⟩
    exact ⟨p, hin hp, hc⟩
  · rintro ⟨p, hp, hc⟩
    obtain ⟨he, ht⟩ := hex p hp
    exact ⟨expand p, he, ht.trans hc⟩

theorem pointwise_positivity_not_uniform :
    (∀ x : ℝ, 0 < x → 0 < x) ∧
    ¬ ∃ epsilon : ℝ, 0 < epsilon ∧ ∀ x : ℝ, 0 < x → epsilon ≤ x := by
  constructor
  · intro x hx
    exact hx
  · rintro ⟨epsilon, he, hbound⟩
    have hhalf : 0 < epsilon / 2 := by linarith
    have hh := hbound (epsilon / 2) hhalf
    linarith

end EnumerativeEnergy

namespace LambdaPhysical

def boostTime (g b T x : ℝ) : ℝ := g * (T - b * x)
def boostSpace (g b T x : ℝ) : ℝ := g * (x - b * T)
def interval (T x : ℝ) : ℝ := x ^ 2 - T ^ 2

theorem boosted_time_needs_space (g b : ℝ) (hg : g ≠ 0) (hb : b ≠ 0) :
    ¬ ∃ f : ℝ → ℝ, ∀ T x, f T = boostTime g b T x := by
  rintro ⟨f, hf⟩
  have h0 := hf 0 0
  have h1 := hf 0 1
  simp only [boostTime, mul_zero, sub_zero] at h0
  simp only [boostTime, mul_one, zero_sub] at h1
  have hgb : g * b = 0 := by nlinarith
  exact (mul_ne_zero hg hb) hgb

theorem boosted_space_needs_time (g b : ℝ) (hg : g ≠ 0) (hb : b ≠ 0) :
    ¬ ∃ f : ℝ → ℝ, ∀ T x, f x = boostSpace g b T x := by
  rintro ⟨f, hf⟩
  have h0 := hf 0 0
  have h1 := hf 1 0
  simp only [boostSpace, mul_zero, sub_zero] at h0
  simp only [boostSpace, mul_one, zero_sub] at h1
  have hgb : g * b = 0 := by nlinarith
  exact (mul_ne_zero hg hb) hgb

theorem lorentz_interval_preserved (g b T x : ℝ)
    (hn : g ^ 2 * (1 - b ^ 2) = 1) :
    interval (boostTime g b T x) (boostSpace g b T x) = interval T x := by
  unfold interval boostTime boostSpace
  calc
    (g * (x - b * T)) ^ 2 - (g * (T - b * x)) ^ 2 =
        (g ^ 2 * (1 - b ^ 2)) * (x ^ 2 - T ^ 2) := by ring
    _ = x ^ 2 - T ^ 2 := by rw [hn]; ring

theorem lorentz_null_preserved (g b T x : ℝ)
    (hn : g ^ 2 * (1 - b ^ 2) = 1) :
    (interval (boostTime g b T x) (boostSpace g b T x) = 0) ↔
    interval T x = 0 := by
  rw [lorentz_interval_preserved g b T x hn]

theorem timelike_not_time_only :
    ¬ ∃ P : ℝ → Prop, ∀ T x, P T ↔ interval T x < 0 := by
  rintro ⟨P, h⟩
  have hp : P 1 := (h 1 0).mpr (by norm_num [interval])
  have hn := (h 1 2).mp hp
  norm_num [interval] at hn

theorem timelike_not_space_only :
    ¬ ∃ P : ℝ → Prop, ∀ T x, P x ↔ interval T x < 0 := by
  rintro ⟨P, h⟩
  have hp : P 1 := (h 2 1).mpr (by norm_num [interval])
  have hn := (h 0 1).mp hp
  norm_num [interval] at hn

theorem fixed_c_couples_unit_rescaling (c L U : ℝ)
    (hc : c ≠ 0) (hL : L ≠ 0) (h : c * U / L = c) : L = U := by
  have he : c * U = c * L := (div_eq_iff hL).mp h
  exact (mul_left_cancel₀ hc he).symm

theorem calibrated_ratios_determine_values {I : Type*}
    (r E F : I → ℝ) (anchor : ℝ)
    (hE : ∀ i, E i = r i * anchor)
    (hF : ∀ i, F i = r i * anchor) : E = F := by
  funext i
  exact (hE i).trans (hF i).symm


end LambdaPhysical

#check EnumerativeEnergy.prime_iff_no_intermediate_divisor
#check EnumerativeEnergy.prime_step_gcd_one
#check EnumerativeEnergy.shared_divisibility
#check EnumerativeEnergy.simultaneous_return
#check EnumerativeEnergy.relabeling_preserves_orbit
#check EnumerativeEnergy.relabeling_preserves_return
#check EnumerativeEnergy.inversion_preserves_spectral_read
#check EnumerativeEnergy.spectral_collision_has_two_branches
#check EnumerativeEnergy.spectral_read_cannot_recover_phase
#check EnumerativeEnergy.ordered_count_from_union_data
#check EnumerativeEnergy.common_energy_shift_preserves_gaps
#check EnumerativeEnergy.calibration_rescaling_preserves_phase
#check EnumerativeEnergy.residue_monotone
#check EnumerativeEnergy.conservative_representation_preserves_theorems
#check EnumerativeEnergy.pointwise_positivity_not_uniform
#check LambdaPhysical.boosted_time_needs_space
#check LambdaPhysical.boosted_space_needs_time
#check LambdaPhysical.lorentz_interval_preserved
#check LambdaPhysical.lorentz_null_preserved
#check LambdaPhysical.timelike_not_time_only
#check LambdaPhysical.timelike_not_space_only
#check LambdaPhysical.fixed_c_couples_unit_rescaling
#check LambdaPhysical.calibrated_ratios_determine_values
#print axioms EnumerativeEnergy.prime_iff_no_intermediate_divisor
#print axioms EnumerativeEnergy.prime_step_gcd_one
#print axioms EnumerativeEnergy.shared_divisibility
#print axioms EnumerativeEnergy.simultaneous_return
#print axioms EnumerativeEnergy.relabeling_preserves_orbit
#print axioms EnumerativeEnergy.relabeling_preserves_return
#print axioms EnumerativeEnergy.inversion_preserves_spectral_read
#print axioms EnumerativeEnergy.spectral_collision_has_two_branches
#print axioms EnumerativeEnergy.spectral_read_cannot_recover_phase
#print axioms EnumerativeEnergy.ordered_count_from_union_data
#print axioms EnumerativeEnergy.common_energy_shift_preserves_gaps
#print axioms EnumerativeEnergy.calibration_rescaling_preserves_phase
#print axioms EnumerativeEnergy.residue_monotone
#print axioms EnumerativeEnergy.conservative_representation_preserves_theorems
#print axioms EnumerativeEnergy.pointwise_positivity_not_uniform
#print axioms LambdaPhysical.boosted_time_needs_space
#print axioms LambdaPhysical.boosted_space_needs_time
#print axioms LambdaPhysical.lorentz_interval_preserved
#print axioms LambdaPhysical.lorentz_null_preserved
#print axioms LambdaPhysical.timelike_not_time_only
#print axioms LambdaPhysical.timelike_not_space_only
#print axioms LambdaPhysical.fixed_c_couples_unit_rescaling
#print axioms LambdaPhysical.calibrated_ratios_determine_values
#eval Lean.versionString
#eval "LAMBDA_PART_II_AUDIT_COMPLETE"

SHA-256: abd66b0e735f12b0b3ade0d993435ae964604e36a8e5f1e938401c930c48ba9d

import Mathlib

/-!
# Lambda Part III — Successor Discipline, the Collision Dichotomy, and Hypothesis Necessity

Formal kernel for the companion paper.

SCOPE. This file checks only the propositions encoded below. The terms `scope`,
`absolute`, `priority`, `resource`, `criterion`, `handshake`, and `successor`
receive only the formal roles explicitly assigned here. Physical, linguistic,
institutional, and ontological readings require separate bridge arguments in the
paper, which are not encoded.

STATUS. Submitted source. The execution receipt is PENDING until a run is
captured. No acceptance is asserted by the presence of this file.
-/

namespace LambdaIII

/-! ## Section 1. The collision dichotomy

Part I K08/K09 and Part II Proposition 2.1 state one direction of this pair.
L03/L04 supply the converse, turning a one-sided obstruction into a dichotomy.
-/

/-- `Q` is recoverable from the readout `P`. -/
def FactorsThrough {X Y Z : Type*} (P : X → Y) (Q : X → Z) : Prop :=
  ∃ g : Y → Z, ∀ x, g (P x) = Q x

/-- L01. A collision in `P` across which `Q` differs blocks every decoder. -/
theorem collision_blocks_factorization {X Y Z : Type*}
    (P : X → Y) (Q : X → Z) {x₁ x₂ : X}
    (hP : P x₁ = P x₂) (hQ : Q x₁ ≠ Q x₂) :
    ¬ FactorsThrough P Q := by
  rintro ⟨g, hg⟩
  exact hQ (by rw [← hg x₁, ← hg x₂, hP])

/-- L02. Recovering the identity target forces injectivity. -/
theorem id_factors_implies_injective {X Y : Type*} (P : X → Y)
    (h : FactorsThrough P (id : X → X)) : Function.Injective P := by
  obtain ⟨g, hg⟩ := h
  intro a b hab
  have ha : g (P a) = a := hg a
  have hb : g (P b) = b := hg b
  rw [← ha, ← hb, hab]

/-- L03. An injective readout recovers every target. -/
theorem injective_factors_all {X Y Z : Type*} [Nonempty X]
    (P : X → Y) (hinj : Function.Injective P) (Q : X → Z) :
    FactorsThrough P Q :=
  ⟨fun y => Q (Function.invFun P y), fun x => by
    exact congrArg Q (Function.leftInverse_invFun hinj x)⟩

/-- L04. THE DICHOTOMY. A readout either loses nothing or has a collision witness. -/
theorem factorization_dichotomy {X Y : Type*} [Nonempty X] (P : X → Y) :
    Function.Injective P ↔ FactorsThrough P (id : X → X) :=
  ⟨fun h => injective_factors_all P h id, id_factors_implies_injective P⟩

/-- L05. Failure of injectivity is always witnessed by a named pair. -/
theorem not_injective_iff_collision {X Y : Type*} (P : X → Y) :
    ¬ Function.Injective P ↔ ∃ x₁ x₂, P x₁ = P x₂ ∧ x₁ ≠ x₂ := by
  constructor
  · intro h
    by_contra hc
    push Not at hc
    exact h (fun a b hab => hc a b hab)
  · rintro ⟨x₁, x₂, heq, hne⟩ h
    exact hne (h heq)

/-! ## Section 2. Scope retention and the asymmetry of revision

The safe direction of revision is not a house rule. It follows from Section 1.
-/

/-- A claim carried together with the scope index under which it was established. -/
structure ScopedClaim (P S : Type*) where
  prop : P
  scope : S

/-- L06. A successor that retains the scope index leaves the predecessor recoverable. -/
theorem scope_retained_is_recoverable {P S : Type*} :
    FactorsThrough (fun c : ScopedClaim P S => (c.prop, c.scope)) (fun c => c.scope) :=
  ⟨fun p => p.2, fun _ => rfl⟩

/-- L07. A successor that forgets the scope index is irrecoverable, by L01. -/
theorem scope_forgotten_is_not_recoverable {P S : Type*}
    (p : P) {s₁ s₂ : S} (hs : s₁ ≠ s₂) :
    ¬ FactorsThrough (fun c : ScopedClaim P S => c.prop) (fun c => c.scope) :=
  collision_blocks_factorization
    (fun c : ScopedClaim P S => c.prop) (fun c => c.scope)
    (x₁ := ⟨p, s₁⟩) (x₂ := ⟨p, s₂⟩) rfl hs

/-! ## Section 3. The successor taxonomy as a checkable object -/

/-- The admitted successor operations of the revision policy. `obstructionProved`
was added on review: L01, L53 and the imported symmetry obstruction all deliver
exactly that outcome, and the Before-the-Bridge charter names it among the
acceptable returns, but the original seven had no category for it. -/
inductive SuccessorKind where
  | error
  | redundantHypothesis
  | scopeCorrection
  | bridgeRevision
  | absorption
  | supersession
  | warrantLapse
  | obstructionProved
  deriving DecidableEq, Repr

/-- Which successor operations retract a previously accepted formal result. -/
def RetractsFormalResult : SuccessorKind → Bool
  | .error => true
  | _ => false

/-- L08. Exactly one successor category reaches back into an accepted result. -/
theorem only_error_retracts (k : SuccessorKind) :
    RetractsFormalResult k = true ↔ k = SuccessorKind.error := by
  cases k <;> simp [RetractsFormalResult]

/-- L09. Warrant lapse does not retract the formal result. -/
theorem warrant_lapse_does_not_retract :
    RetractsFormalResult SuccessorKind.warrantLapse = false := rfl

/-! ## Section 4. Criteria, exclusion, and the classical boundary -/

def SelfSide {X : Type*} (criterion : X → Bool) (x : X) : Prop := criterion x = true
def OtherSide {X : Type*} (criterion : X → Bool) (x : X) : Prop := criterion x = false
def ExcludedBy {X : Type*} (criterion : X → Prop) (x : X) : Prop := ¬ criterion x

/-- L10. The two sides of a Boolean criterion are exhaustive. -/
theorem criterion_sides_exhaustive {X : Type*} (c : X → Bool) (x : X) :
    SelfSide c x ∨ OtherSide c x := by
  simp only [SelfSide, OtherSide]
  cases hc : c x
  · exact Or.inr rfl
  · exact Or.inl rfl

/-- L11. The two sides of a Boolean criterion are exclusive. -/
theorem criterion_sides_exclusive {X : Type*} (c : X → Bool) (x : X) :
    ¬ (SelfSide c x ∧ OtherSide c x) := by
  rintro ⟨h1, h2⟩
  simp only [SelfSide] at h1
  simp only [OtherSide] at h2
  rw [h1] at h2
  exact Bool.noConfusion h2

/-- L12. Double exclusion is double negation, with no axiom cost. -/
theorem double_exclusion_is_double_negation {X : Type*} (P : X → Prop) (x : X) :
    ExcludedBy (ExcludedBy P) x ↔ ¬ ¬ P x := Iff.rfl

/-- L13. Collapsing double exclusion is the classical step. The axiom report on
this declaration, compared with L12, is the intended marker. -/
theorem double_exclusion_collapse {X : Type*} (P : X → Prop) (x : X) :
    ExcludedBy (ExcludedBy P) x ↔ P x := not_not

/-- L14. BINARY INADEQUACY. On a domain with more than two states, every Boolean
criterion has a collision, hence fails to recover the identity target. -/
theorem binary_criterion_has_collision {X : Type*} [Fintype X]
    (c : X → Bool) (hcard : 2 < Fintype.card X) :
    ∃ x₁ x₂ : X, c x₁ = c x₂ ∧ x₁ ≠ x₂ := by
  have hlt : Fintype.card Bool < Fintype.card X := by simpa using hcard
  obtain ⟨x₁, x₂, hne, heq⟩ := Fintype.exists_ne_map_eq_of_card_lt c hlt
  exact ⟨x₁, x₂, heq, hne⟩

/-- L15. The corresponding non-recovery statement. -/
theorem binary_criterion_not_faithful {X : Type*} [Fintype X]
    (c : X → Bool) (hcard : 2 < Fintype.card X) :
    ¬ FactorsThrough c (id : X → X) := by
  obtain ⟨x₁, x₂, heq, hne⟩ := binary_criterion_has_collision c hcard
  exact collision_blocks_factorization c id heq (by simpa using hne)

/-! ## Section 5. Absolute labels -/

/-- L16. A predicate carrying both an introduction and an elimination rule is the
identity predicate, hence contributes no content. Strengthens Part I K17. -/
theorem absolute_with_both_rules_is_identity
    (A : Prop → Prop) (hintro : ∀ p, p → A p) (helim : ∀ p, A p → p) :
    A = id := by
  funext p
  show A p = p
  exact propext ⟨helim p, hintro p⟩

/-! ## Section 6. The n-ary no-first-position result

Part I K15 is the n = 2 case of L18 below.
-/

def AbsolutePriority {C : Type*} (Priority UsesComplement : C → Prop) (c : C) : Prop :=
  Priority c ∧ ¬ UsesComplement c

/-- L17. Generic absolute-priority obstruction, restated for reference. -/
theorem complement_requirement_blocks_absolute_priority
    {C : Type*} (Priority UsesComplement : C → Prop)
    (hbridge : ∀ c, Priority c → UsesComplement c) :
    ¬ ∃ c, AbsolutePriority Priority UsesComplement c := by
  rintro ⟨c, hp, hnot⟩
  exact hnot (hbridge c hp)

/-- A cyclic chain of descriptive resources: a priority claim at station `i`
uses the resource at station `i + 1`. -/
structure ResourceChain (n : ℕ) [NeZero n] (Claim : Type*) where
  Priority : Fin n → Claim → Prop
  Uses : Fin n → Claim → Prop
  chain : ∀ (i : Fin n) (c : Claim), Priority i c → Uses (i + 1) c

def AbsolutePriorityAt {n : ℕ} [NeZero n] {Claim : Type*} (R : ResourceChain n Claim)
    (i : Fin n) (c : Claim) : Prop :=
  AbsolutePriority (R.Priority i) (R.Uses (i + 1)) c

/-- L18. N-ARY NO-FIRST-POSITION. In a cyclic resource chain of any length, no
station holds complement-free absolute priority. -/
theorem no_first_position_cyclic {n : ℕ} [NeZero n] {Claim : Type*}
    (R : ResourceChain n Claim) (i : Fin n) :
    ¬ ∃ c, AbsolutePriorityAt R i c :=
  complement_requirement_blocks_absolute_priority
    (R.Priority i) (R.Uses (i + 1)) (R.chain i)

/-! ## Section 7. Handshake closure

Part I K20 proves composition. L19–L22 prove closure under the propositional
connectives, so a verified handshake on atoms extends to their Boolean closure.
-/

def PreservesPredicate {A B : Type*} (f : A → B) (P : A → Prop) (Q : B → Prop) : Prop :=
  ∀ a, P a ↔ Q (f a)

theorem preserves_and {A B : Type*} (f : A → B) (P₁ P₂ : A → Prop) (Q₁ Q₂ : B → Prop)
    (h₁ : PreservesPredicate f P₁ Q₁) (h₂ : PreservesPredicate f P₂ Q₂) :
    PreservesPredicate f (fun a => P₁ a ∧ P₂ a) (fun b => Q₁ b ∧ Q₂ b) :=
  fun a => and_congr (h₁ a) (h₂ a)

theorem preserves_or {A B : Type*} (f : A → B) (P₁ P₂ : A → Prop) (Q₁ Q₂ : B → Prop)
    (h₁ : PreservesPredicate f P₁ Q₁) (h₂ : PreservesPredicate f P₂ Q₂) :
    PreservesPredicate f (fun a => P₁ a ∨ P₂ a) (fun b => Q₁ b ∨ Q₂ b) :=
  fun a => or_congr (h₁ a) (h₂ a)

theorem preserves_not {A B : Type*} (f : A → B) (P : A → Prop) (Q : B → Prop)
    (h : PreservesPredicate f P Q) :
    PreservesPredicate f (fun a => ¬ P a) (fun b => ¬ Q b) :=
  fun a => not_congr (h a)

theorem preserves_imp {A B : Type*} (f : A → B) (P₁ P₂ : A → Prop) (Q₁ Q₂ : B → Prop)
    (h₁ : PreservesPredicate f P₁ Q₁) (h₂ : PreservesPredicate f P₂ Q₂) :
    PreservesPredicate f (fun a => P₁ a → P₂ a) (fun b => Q₁ b → Q₂ b) :=
  fun a => imp_congr (h₁ a) (h₂ a)

/-- L23. Noncommuting translations still agree on a preserved predicate.
This is the exact formal content of Part I section 18: test the predicate before
declaring a contradiction. -/
theorem preserved_predicate_agrees_despite_noncommutation
    {A B C : Type*} (AB : A → B) (BC : B → C) (AC : A → C)
    (P : A → Prop) (Q : B → Prop) (R : C → Prop)
    (hAB : PreservesPredicate AB P Q) (hBC : PreservesPredicate BC Q R)
    (hAC : PreservesPredicate AC P R) (a : A) :
    R (AC a) ↔ R (BC (AB a)) :=
  (hAC a).symm.trans ((hAB a).trans (hBC (AB a)))

/-! ## Section 8. Finite budget, n tasks -/

/-- L24. Part I K22 generalized from two demands to a finite family. -/
theorem finite_budget_forces_tradeoff_n {ι : Type*} (s : Finset ι)
    (cost alloc : ι → ℕ) (budget : ℕ)
    (hDemand : budget < ∑ i ∈ s, cost i)
    (hBudget : ∑ i ∈ s, alloc i ≤ budget)
    (hFull : ∀ i ∈ s, cost i ≤ alloc i) : False := by
  have hsum : ∑ i ∈ s, cost i ≤ ∑ i ∈ s, alloc i := Finset.sum_le_sum hFull
  omega

/-! ## Section 9. Interpretation is not fixed by finite metadata -/

/-- L25. Part I K23 says non-uniqueness of interpretation is possible. L25 says
no finite body of pointwise metadata removes it. -/
theorem finite_metadata_leaves_freedom (s : Finset ℕ) :
    ∃ I₀ I₁ : ℕ → Bool, (∀ n ∈ s, I₀ n = I₁ n) ∧ I₀ ≠ I₁ := by
  classical
  let m := s.sup id + 1
  have hm : m ∉ s := by
    intro hmem
    have hle : m ≤ s.sup id := Finset.le_sup (f := id) hmem
    dsimp [m] at hle
    omega
  refine ⟨fun n => decide (n ∈ s), fun n => decide (n ∈ s ∨ n = m), ?_, ?_⟩
  · intro n hn; simp [hn]
  · intro hcontra
    have hm' := congrFun hcontra m
    simp [hm] at hm'

/-! ## Section 10. Discrete registries attain their minimum

Part II E15 shows a real-valued cost can be everywhere positive with zero
infimum. L26 supplies the complement for natural-number cost.
-/

/-- L26. A nonempty natural-number cost registry attains its infimum. -/
theorem nat_cost_registry_attains_minimum (S : Set ℕ) (cost : ℕ → ℕ)
    (hne : ∃ x, x ∈ S) :
    ∃ x ∈ S, ∀ y ∈ S, cost x ≤ cost y := by
  classical
  obtain ⟨x₀, hx₀⟩ := hne
  have hex : ∃ n, ∃ x ∈ S, cost x = n := ⟨cost x₀, x₀, hx₀, rfl⟩
  obtain ⟨x, hxS, hxeq⟩ := Nat.find_spec hex
  refine ⟨x, hxS, fun y hy => ?_⟩
  rw [hxeq]
  exact Nat.find_le ⟨y, hy, rfl⟩

/-! ## Section 11. Spectral and calibration results -/

/-- L27. Part II E11 converse: gap data determines the spectrum up to one
additive constant. -/
theorem gaps_determine_up_to_shift {I : Type*} (E F : I → ℝ) (i₀ : I)
    (hgap : ∀ i j, E i - E j = F i - F j) (i : I) :
    F i = E i + (F i₀ - E i₀) := by
  have h := hgap i i₀
  linarith

/-- L28. The affine calibration of a spectrum is unique once two values differ. -/
theorem affine_calibration_unique {I : Type*} (E : I → ℝ) (a a' b b' : ℝ) (i j : I)
    (hij : E i ≠ E j) (h : ∀ k, a * E k + b = a' * E k + b') :
    a = a' ∧ b = b' := by
  have hi := h i
  have hj := h j
  have hfac : (a - a') * (E i - E j) = 0 := by linear_combination hi - hj
  have ha : a = a' := by
    rcases mul_eq_zero.mp hfac with h1 | h2
    · linarith
    · exact absurd (sub_eq_zero.mp h2) hij
  refine ⟨ha, ?_⟩
  rw [ha] at hi
  linarith

/-- L29. The distinct-count parity identity used by Part II Theorem 6.2.
Closes the arithmetic half of the gap that Part II section 14.2 discloses. -/
theorem distinct_count_parity (g : ℕ) :
    (g + Nat.gcd g 2) / 2 = g / 2 + 1 := by
  have hdvd : Nat.gcd g 2 ∣ 2 := Nat.gcd_dvd_right g 2
  rcases (Nat.dvd_prime Nat.prime_two).mp hdvd with h1 | h2
  · have hnd : ¬ (2 : ℕ) ∣ g := by
      intro hd
      have h2g : (2 : ℕ) ∣ Nat.gcd g 2 := Nat.dvd_gcd hd dvd_rfl
      rw [h1] at h2g
      omega
    rw [h1]
    omega
  · have hd : (2 : ℕ) ∣ g := by
      have hgl := Nat.gcd_dvd_left g 2
      rwa [h2] at hgl
    rw [h2]
    omega

/-! ## Section 12. Lorentz orientation and rigidity -/

def boostTime (g b T x : ℝ) : ℝ := g * (T - b * x)
def boostSpace (g b T x : ℝ) : ℝ := g * (x - b * T)
def interval (T x : ℝ) : ℝ := x ^ 2 - T ^ 2

/-- L30. A physical boost preserves time orientation on the timelike set.
Part II states time orientation as additional data; on timelike separations it
is preserved rather than independently assumed. -/
theorem boost_preserves_time_orientation (g b T x : ℝ)
    (hg : 0 < g) (hb1 : -1 < b) (hb2 : b < 1)
    (htl : x ^ 2 < T ^ 2) (hT : 0 < T) :
    0 < boostTime g b T x := by
  have hxu : x < T := by
    by_contra hcon
    push Not at hcon
    nlinarith [mul_nonneg (by linarith : (0:ℝ) ≤ x - T) (by linarith : (0:ℝ) ≤ x + T)]
  have hxl : -T < x := by
    by_contra hcon
    push Not at hcon
    nlinarith [mul_nonneg (by linarith : (0:ℝ) ≤ -T - x) (by linarith : (0:ℝ) ≤ T - x)]
  have hbx : b * x < T := by
    nlinarith [mul_pos (by linarith : (0:ℝ) < 1 - b) (by linarith : (0:ℝ) < T + x),
               mul_pos (by linarith : (0:ℝ) < 1 + b) (by linarith : (0:ℝ) < T - x)]
  have hpos : 0 < T - b * x := by linarith
  exact mul_pos hg hpos

/-- L31. Boost composition: the Lorentz normalization is closed under the
velocity addition law. Stated without division; the existence of the composed
parameter `b` requires `1 + b₁ * b₂ ≠ 0`, which is a hypothesis on the model,
not on this identity. -/
theorem boost_normalization_composes (b₁ b₂ b g₁ g₂ g : ℝ)
    (h₁ : g₁ ^ 2 * (1 - b₁ ^ 2) = 1) (h₂ : g₂ ^ 2 * (1 - b₂ ^ 2) = 1)
    (hb : b * (1 + b₁ * b₂) = b₁ + b₂)
    (hgg : g = g₁ * g₂ * (1 + b₁ * b₂)) :
    g ^ 2 * (1 - b ^ 2) = 1 := by
  subst hgg
  have key : (g₁ * g₂ * (1 + b₁ * b₂)) ^ 2 * (1 - b ^ 2)
      = (g₁ ^ 2 * (1 - b₁ ^ 2)) * (g₂ ^ 2 * (1 - b₂ ^ 2)) := by
    linear_combination (-(g₁ ^ 2 * g₂ ^ 2) * (b * (1 + b₁ * b₂) + (b₁ + b₂))) * hb
  rw [key, h₁, h₂]
  ring

/-- L32. PLANCK RIGIDITY. Fixing the numerical values of c, h and G leaves only
the trivial rescaling of the length, time and mass units. -/
theorem planck_rescaling_rigid (c h G L U M : ℝ)
    (hc : c ≠ 0) (hh : h ≠ 0) (hG : G ≠ 0)
    (hL : 0 < L) (hU : 0 < U) (_hM : 0 < M)
    (ec : c * U = c * L)
    (eh : h * U = h * (L ^ 2 * M))
    (eG : G * U ^ 2 * M = G * L ^ 3) :
    L = 1 ∧ U = 1 ∧ M = 1 := by
  have e1 : U = L := mul_left_cancel₀ hc ec
  subst e1
  have e2 : U = U ^ 2 * M := mul_left_cancel₀ hh eh
  have e3 : U ^ 2 * M = U ^ 3 :=
    mul_left_cancel₀ hG (by linear_combination eG)
  have e4 : U = U ^ 3 := e2.trans e3
  have hU1 : U = 1 := by
    have hfac : U * ((U - 1) * (U + 1)) = 0 := by linear_combination (-1 : ℝ) * e4
    rcases mul_eq_zero.mp hfac with h1 | h1
    · exact absurd h1 (ne_of_gt hU)
    · rcases mul_eq_zero.mp h1 with h' | h'
      · linarith
      · linarith
  subst hU1
  refine ⟨rfl, rfl, ?_⟩
  have : (1 : ℝ) = M := by linear_combination e2
  linarith

/-! ## Section 13. Hypothesis necessity

Each declaration below exhibits a countermodel showing that a hypothesis of a
previously accepted theorem is load-bearing. These are not corrections. They
establish that the predecessor's hypotheses cannot be dropped.
-/

/-- L33. The two SpatiotemporalBridge premises of Part I K15 are necessary. -/
theorem no_first_position_premises_necessary :
    ∃ (Priority UsesComplement : Bool → Prop) (c : Bool),
      AbsolutePriority Priority UsesComplement c :=
  ⟨fun _ => True, fun _ => False, true, trivial, not_false⟩

/-- L34. The normalization hypothesis of Part II P03 is necessary. -/
theorem lorentz_normalization_necessary :
    ∃ g b T x : ℝ,
      interval (boostTime g b T x) (boostSpace g b T x) ≠ interval T x := by
  refine ⟨2, 0, 0, 1, ?_⟩
  norm_num [interval, boostTime, boostSpace]

/-- L35. The demand hypothesis of Part I K22 is necessary. -/
theorem budget_demand_hypothesis_necessary :
    ∃ costA costB allocA allocB budget : ℕ,
      ¬ (budget < costA + costB) ∧ allocA + allocB ≤ budget ∧
        costA ≤ allocA ∧ costB ≤ allocB :=
  ⟨1, 1, 1, 1, 2, by omega, by omega, by omega, by omega⟩

/-- L36. The nontriviality hypothesis of Part I K05 is necessary. -/
theorem nontriviality_hypothesis_necessary :
    ∃ c : Bool → Bool, ¬ ∃ x, SelfSide c x := by
  refine ⟨fun _ => false, ?_⟩
  rintro ⟨x, hx⟩
  simp [SelfSide] at hx

/-- L37. The velocity bound in L30 is necessary: a superluminal parameter
reverses orientation on a timelike separation. -/
theorem velocity_bound_necessary :
    ∃ g b T x : ℝ, 0 < g ∧ 0 < T ∧ x ^ 2 < T ^ 2 ∧ boostTime g b T x < 0 := by
  refine ⟨1, 4, 2, 1, ?_, ?_, ?_, ?_⟩ <;> norm_num [boostTime]

/-! ## Section 14. Findings against the accepted predecessor sources

These are stated as theorems so that the findings are checkable rather than
editorial. Each is a redundant-hypothesis finding: the predecessor theorem
remains true and is merely stated with more hypotheses than it needs.
-/

/-- F01. Part II E09: the hypothesis `hz : z ≠ 0` is derivable from `hd`. -/
theorem E09_nonzero_hypothesis_redundant (z : ℂ) (hd : z ≠ z⁻¹) : z ≠ 0 := by
  rintro rfl
  simp at hd

/-- F03. Part II P07: the hypothesis `hL : L ≠ 0` is derivable from `hc` and `h`. -/
theorem P07_length_hypothesis_redundant (c L U : ℝ) (hc : c ≠ 0)
    (h : c * U / L = c) : L ≠ 0 := by
  rintro rfl
  rw [div_zero] at h
  exact hc h.symm

/-- F04. Part II E15: the first conjunct is provable with no hypothesis and
carries no content. Recorded so that the finding is checkable, not editorial. -/
theorem E15_first_conjunct_is_contentless : ∀ x : ℝ, 0 < x → 0 < x :=
  fun _ h => h


/-! ## Section 15. The assertion reading: discharging K15's premises

Part III section 14 recorded the achievement reading of `SpaceFirst` as making
Part I K15 vacuous in the 1+1 model, and recorded the assertion reading as OPEN.
This section constructs the assertion reading.

WHAT IS PROVED: that the two bridge premises of a spatiotemporal bridge become
THEOREMS about priority claims, and that the claim class is inhabited.

WHAT IS NOT PROVED, AND IS NOT ELIMINATED: the identification of directed order
with a temporal-type resource and of individuation with a spatial-type resource.
That is Part I bridge B03. It is not discharged here. It is relocated: it now
carries the entire physical content of the no-first-position result by itself.
-/

/-- A priority claim: an assertion that one relatum is prior to another.
Distinctness of the relata is part of what it is to be a priority claim. -/
structure PriorityClaim (R : Type*) where
  prior : R
  posterior : R
  distinct : prior ≠ posterior

/-- The claim obtained by exchanging the two relata. -/
def exchangeRelata {R : Type*} (c : PriorityClaim R) : PriorityClaim R :=
  ⟨c.posterior, c.prior, fun h => c.distinct h.symm⟩

/-- Individuation: the claim distinguishes its relata. -/
def UsesIndividuation {R : Type*} (c : PriorityClaim R) : Prop :=
  c.prior ≠ c.posterior

/-- Directed order: the claim is not invariant under exchanging its relata. -/
def UsesDirectedOrder {R : Type*} (c : PriorityClaim R) : Prop :=
  c ≠ exchangeRelata c

/-- L41. Every priority claim uses individuation. Proved, not stipulated. -/
theorem priority_claim_uses_individuation {R : Type*} (c : PriorityClaim R) :
    UsesIndividuation c := c.distinct

/-- L42. Every priority claim uses directed order. Proved, not stipulated. -/
theorem priority_claim_uses_directed_order {R : Type*} (c : PriorityClaim R) :
    UsesDirectedOrder c := by
  intro h
  exact c.distinct (congrArg PriorityClaim.prior h)

/-- Part I's bridge structure, restated here so this document's kernel is
self-contained. -/
structure SpatiotemporalBridgeIII (Claim : Type*) where
  SpaceFirst : Claim → Prop
  TimeFirst : Claim → Prop
  UsesTemporalResource : Claim → Prop
  UsesSpatialResource : Claim → Prop
  spaceFirstUsesTemporal : ∀ c, SpaceFirst c → UsesTemporalResource c
  timeFirstUsesSpatial : ∀ c, TimeFirst c → UsesSpatialResource c

inductive SpaceTime where
  | space
  | time
  deriving DecidableEq, Repr

def IsSpaceFirst (c : PriorityClaim SpaceTime) : Prop := c.prior = SpaceTime.space
def IsTimeFirst (c : PriorityClaim SpaceTime) : Prop := c.prior = SpaceTime.time

def spaceFirstClaim : PriorityClaim SpaceTime :=
  ⟨SpaceTime.space, SpaceTime.time, by decide⟩
def timeFirstClaim : PriorityClaim SpaceTime :=
  ⟨SpaceTime.time, SpaceTime.space, by decide⟩

/-- The assertion-reading bridge. Both premise fields are DISCHARGED BY PROOF
(L41, L42) rather than stipulated. Bridge B03 is assumed in the choice of the
two `Uses` fields and is not proved anywhere in this file. -/
def assertionBridge : SpatiotemporalBridgeIII (PriorityClaim SpaceTime) where
  SpaceFirst := IsSpaceFirst
  TimeFirst := IsTimeFirst
  UsesTemporalResource := UsesDirectedOrder
  UsesSpatialResource := UsesIndividuation
  spaceFirstUsesTemporal := fun c _ => priority_claim_uses_directed_order c
  timeFirstUsesSpatial := fun c _ => priority_claim_uses_individuation c

/-- L43. The assertion-reading claim class is INHABITED on both sides. This is
what the achievement reading fails to provide, and it is why the resulting
no-first-position statement is not vacuous. -/
theorem assertion_bridge_nonvacuous :
    (∃ c, assertionBridge.SpaceFirst c) ∧ (∃ c, assertionBridge.TimeFirst c) :=
  ⟨⟨spaceFirstClaim, rfl⟩, ⟨timeFirstClaim, rfl⟩⟩

/-- L44. No-first-position under the assertion reading, with premises proved
rather than assumed. -/
theorem no_first_position_assertion_reading :
    (¬ ∃ c, AbsolutePriority assertionBridge.SpaceFirst
        assertionBridge.UsesTemporalResource c) ∧
    (¬ ∃ c, AbsolutePriority assertionBridge.TimeFirst
        assertionBridge.UsesSpatialResource c) :=
  ⟨complement_requirement_blocks_absolute_priority _ _
      assertionBridge.spaceFirstUsesTemporal,
   complement_requirement_blocks_absolute_priority _ _
      assertionBridge.timeFirstUsesSpatial⟩

/-- L45. The contrast case, restated from Part II P05: no predicate of the time
coordinate alone gives the causal classification. -/
theorem timelike_not_time_only :
    ¬ ∃ P : ℝ → Prop, ∀ T x, P T ↔ interval T x < 0 := by
  rintro ⟨P, h⟩
  have hp : P 1 := (h 1 0).mpr (by norm_num [interval])
  have hn := (h 1 2).mp hp
  norm_num [interval] at hn

/-- L46. The contrast case, restated from Part II P06. With L45 this is why the
ACHIEVEMENT reading makes K15 vacuous in the 1+1 model: the predicate whose
existence would inhabit `SpaceFirst` does not exist. -/
theorem timelike_not_space_only :
    ¬ ∃ P : ℝ → Prop, ∀ T x, P x ↔ interval T x < 0 := by
  rintro ⟨P, h⟩
  have hp : P 1 := (h 2 1).mpr (by norm_num [interval])
  have hn := (h 0 1).mp hp
  norm_num [interval] at hn

/-! ## Section 16. Further self-application and necessity -/

/-- L47. The taxonomy's own retraction encoding is lossy. `RetractsFormalResult`
collides on six of seven categories, so by L01 the category cannot be recovered
from the footprint. The compression warned about in Part I section 10, performed
by this document on its own policy object. -/
theorem taxonomy_encoding_is_lossy :
    ¬ FactorsThrough RetractsFormalResult (id : SuccessorKind → SuccessorKind) :=
  collision_blocks_factorization RetractsFormalResult id
    (x₁ := SuccessorKind.absorption) (x₂ := SuccessorKind.supersession)
    rfl (by decide)

/-- L48. The third constant in L32 is necessary: fixing the numerical values of
c and h alone leaves a nontrivial rescaling family. Witness (L,U,M) = (2,2,1/2). -/
theorem planck_two_constants_insufficient (c h : ℝ) :
    ∃ L U M : ℝ, 0 < L ∧ 0 < U ∧ 0 < M ∧ ¬ (L = 1 ∧ U = 1 ∧ M = 1) ∧
      c * U = c * L ∧ h * U = h * (L ^ 2 * M) :=
  ⟨2, 2, 1/2, by norm_num, by norm_num, by norm_num, by norm_num, by ring, by norm_num⟩

/-! ## Section 17. Quantifying the spectral loss -/

noncomputable def spectralRead (z : ℂ) : ℂ := 2 - z - z⁻¹

/-- L49. The spectral readout is invariant under inversion. -/
theorem spectral_read_inversion_invariant (z : ℂ) :
    spectralRead z⁻¹ = spectralRead z := by
  simp only [spectralRead, inv_inv]
  ring

/-- L50. Each nonzero fibre of the spectral readout contains at most the pair
{z, z⁻¹}. With L51 this quantifies the loss exactly: at most one bit. -/
theorem spectral_fibre_at_most_pair (z w : ℂ) (hz : z ≠ 0) (hw : w ≠ 0)
    (h : spectralRead z = spectralRead w) : w = z ∨ w = z⁻¹ := by
  have hzi : z * z⁻¹ = 1 := mul_inv_cancel₀ hz
  have hwi : w * w⁻¹ = 1 := mul_inv_cancel₀ hw
  have hid : (spectralRead z - spectralRead w) * (z * w) =
      -(z - w) * (z * w - 1) := by
    simp only [spectralRead]
    linear_combination z * hwi - w * hzi
  rw [h, sub_self, zero_mul] at hid
  have hp : (z - w) * (z * w - 1) = 0 := by linear_combination hid
  rcases mul_eq_zero.mp hp with heq | hinv
  · exact Or.inl (sub_eq_zero.mp heq).symm
  · right
    have hzw : z * w = 1 := sub_eq_zero.mp hinv
    calc w = 1 * w := (one_mul w).symm
      _ = (z⁻¹ * z) * w := by rw [inv_mul_cancel₀ hz]
      _ = z⁻¹ * (z * w) := by ring
      _ = z⁻¹ * 1 := by rw [hzw]
      _ = z⁻¹ := mul_one _

/-- L51. The fibre collapses to a singleton exactly at the square roots of unity.
So the loss is exactly one bit off those points and zero bits on them. -/
theorem spectral_fibre_singleton_iff (z : ℂ) (hz : z ≠ 0) :
    z = z⁻¹ ↔ z ^ 2 = 1 := by
  constructor
  · intro hzz
    field_simp at hzz
    linear_combination hzz
  · intro hsq
    field_simp
    linear_combination hsq


/-! ## Section 18. Cardinality inadequacy in general (O3)

L14 proves the Boolean case. L52 proves the general cardinality statement, of
which the Boolean and `Fin k` cases are instances.

TERMINOLOGICAL NOTE. "Inadequate" here means exactly: fails to recover the
identity target. By I:K10 target adequacy and source exhaustion are different
predicates, so a criterion named inadequate by L52 may be perfectly adequate for
the target it was built for. The word is scoped to the identity target and
carries no further evaluation.
-/

/-- L52. A readout into a strictly smaller finite codomain always collides. -/
theorem cardinality_forces_collision {X Y : Type*} [Fintype X] [Fintype Y]
    (c : X → Y) (hcard : Fintype.card Y < Fintype.card X) :
    ∃ x₁ x₂ : X, c x₁ = c x₂ ∧ x₁ ≠ x₂ := by
  obtain ⟨x₁, x₂, hne, heq⟩ := Fintype.exists_ne_map_eq_of_card_lt c hcard
  exact ⟨x₁, x₂, heq, hne⟩

/-- L53. The corresponding non-recovery statement, in full generality. -/
theorem cardinality_forces_unfaithfulness {X Y : Type*} [Fintype X] [Fintype Y]
    (c : X → Y) (hcard : Fintype.card Y < Fintype.card X) :
    ¬ FactorsThrough c (id : X → X) := by
  obtain ⟨x₁, x₂, heq, hne⟩ := cardinality_forces_collision c hcard
  exact collision_blocks_factorization c id heq (by simpa using hne)

/-- L54. K-ARY INADEQUACY (O3). A `k`-valued criterion on a domain of more than
`k` states has a collision. L14 is the case `k = 2`. -/
theorem kary_criterion_has_collision {X : Type*} [Fintype X] {k : ℕ}
    (c : X → Fin k) (hcard : k < Fintype.card X) :
    ∃ x₁ x₂ : X, c x₁ = c x₂ ∧ x₁ ≠ x₂ := by
  refine cardinality_forces_collision c ?_
  simpa using hcard

/-- L55. K-ary criteria are unfaithful to the identity target. -/
theorem kary_criterion_not_faithful {X : Type*} [Fintype X] {k : ℕ}
    (c : X → Fin k) (hcard : k < Fintype.card X) :
    ¬ FactorsThrough c (id : X → X) := by
  obtain ⟨x₁, x₂, heq, hne⟩ := kary_criterion_has_collision c hcard
  exact collision_blocks_factorization c id heq (by simpa using hne)

/-! ## Section 19. Conservative expansion with strictly lower cost (O7)

Part II section 2.3 states in prose that a proof registry may lower represented
cost through reusable lemmas or compressed descriptions without thereby proving
a previously unprovable statement. II:E13 gives the cost inequality and II:E14
the theorem-set identity, but neither exhibits a case where the cost falls
STRICTLY while the theorem set is unmoved. L57 supplies that
witness.

TERMINOLOGICAL NOTE. "Conservative" is used in its proof-theoretic sense:
the expansion adds no theorems. The `expand` hypothesis below IS that condition,
made explicit as a conclusion-preserving retraction of the larger registry into
the smaller. The name is faithful provided the hypothesis is read as the
definition rather than as a consequence.
-/

noncomputable def indexedResidue {A : Type*} (S : Set A) (cost : A → ENNReal) : ENNReal :=
  sInf (cost '' S)

/-- L56. II:E13 restated: enlarging the admitted set cannot raise the residue. -/
theorem residue_monotone {A : Type*} (S T : Set A)
    (cost : A → ENNReal) (h : S ⊆ T) :
    indexedResidue T cost ≤ indexedResidue S cost := by
  unfold indexedResidue
  apply sInf_le_sInf
  rintro y ⟨x, hx, rfl⟩
  exact ⟨x, h hx, rfl⟩

/-- L57. O7. A conservative expansion can lower the residue STRICTLY while the
the theorem set is unchanged for every target.
Witness: R0 = {1}, R1 = {0,1},
cost = the numeral, expand = the constant 1. -/
theorem conservative_expansion_can_lower_cost_strictly :
    ∃ (R0 R1 : Set ℕ) (cost : ℕ → ENNReal) (conclusion : ℕ → Unit) (expand : ℕ → ℕ),
      R0 ⊆ R1 ∧
      (∀ p ∈ R1, expand p ∈ R0 ∧ conclusion (expand p) = conclusion p) ∧
      (∀ target : Unit,
        (∃ p ∈ R0, conclusion p = target) ↔ (∃ p ∈ R1, conclusion p = target)) ∧
      indexedResidue R1 cost < indexedResidue R0 cost := by
  classical
  refine ⟨{1}, {0, 1}, fun n => (n : ENNReal), fun _ => (), fun _ => 1,
    ?_, ?_, ?_, ?_⟩
  · intro x hx
    simp only [Set.mem_singleton_iff] at hx
    simp [hx]
  · intro p _
    exact ⟨rfl, rfl⟩
  · intro target
    constructor
    · rintro ⟨p, _, _⟩
      exact ⟨1, by simp, Subsingleton.elim _ _⟩
    · rintro ⟨p, _, _⟩
      exact ⟨1, rfl, Subsingleton.elim _ _⟩
  · have h1 : indexedResidue ({1} : Set ℕ) (fun n => (n : ENNReal)) = 1 := by
      unfold indexedResidue
      rw [Set.image_singleton]
      simp
    have h0 : indexedResidue ({0, 1} : Set ℕ) (fun n => (n : ENNReal)) = 0 := by
      unfold indexedResidue
      refine le_antisymm ?_ zero_le
      refine sInf_le ⟨0, by simp, by simp⟩
    rw [h0, h1]
    exact zero_lt_one

/-- L58. The two halves of O7 are independent: the residue can also fall to the
same value, so strictness is a property of the particular expansion and not a
consequence of conservativity. -/
theorem conservative_expansion_need_not_lower_cost :
    ∃ (R0 R1 : Set ℕ) (cost : ℕ → ENNReal),
      R0 ⊆ R1 ∧ indexedResidue R1 cost = indexedResidue R0 cost := by
  refine ⟨{1}, {1}, fun n => (n : ENNReal), subset_rfl, rfl⟩


/-! ## Section 20. Review-driven additions

L59 converts a stated hypothesis into a countermodel. L60 makes checkable the
claim that L44 is trivial if B03 is denied. L61 and L62 restate two results over
a general carrier so that a SINGLE run tests the axiom-profile prediction of the
supplement rather than requiring a baseline run followed by a second one.
-/

/-- L59. The nonemptiness hypothesis of L03 and L04 is necessary. Over an empty
domain every map is vacuously injective, yet factorization can fail outright
because the decoder itself cannot be constructed. -/
theorem dichotomy_nonemptiness_necessary :
    ∃ P : Empty → Unit, Function.Injective P ∧
      ¬ FactorsThrough P (id : Empty → Empty) := by
  refine ⟨fun e => e.elim, ?_, ?_⟩
  · intro a b _
    exact a.elim
  · rintro ⟨g, _⟩
    exact (g ()).elim

/-- L60. What the no-first-position result becomes if bridge B03 is denied.
With `UsesDirectedOrder` and `UsesIndividuation` read as bare logical properties
carrying no spatiotemporal import, L44's content is non-contradiction and
nothing else. The proof is `fun h1 h2 => h2 h1`, which is the point: this
declaration exists to make the triviality inspectable rather than asserted. -/
theorem no_first_position_without_B03_is_trivial {R : Type*} :
    (¬ ∃ c : PriorityClaim R, UsesDirectedOrder c ∧ ¬ UsesDirectedOrder c) ∧
    (¬ ∃ c : PriorityClaim R, UsesIndividuation c ∧ ¬ UsesIndividuation c) := by
  constructor
  · rintro ⟨c, h1, h2⟩
    exact h2 h1
  · rintro ⟨c, h1, h2⟩
    exact h2 h1

/-- L61. L27 over a commutative ring. Compare the axiom report with L27's. -/
theorem gaps_determine_up_to_shift_ring {K : Type*} [CommRing K] {I : Type*}
    (E F : I → K) (i₀ : I) (hgap : ∀ i j, E i - E j = F i - F j) (i : I) :
    F i = E i + (F i₀ - E i₀) := by
  linear_combination -(hgap i i₀)

/-- L62. L28 over an arbitrary field, with no order used. Compare the axiom
report with L28's. -/
theorem affine_calibration_unique_field {K : Type*} [Field K] {I : Type*}
    (E : I → K) (a a' b b' : K) (i j : I) (hij : E i ≠ E j)
    (h : ∀ k, a * E k + b = a' * E k + b') :
    a = a' ∧ b = b' := by
  have hi := h i
  have hj := h j
  have hfac : (a - a') * (E i - E j) = 0 := by linear_combination hi - hj
  have ha : a = a' := by
    rcases mul_eq_zero.mp hfac with h1 | h2
    · exact sub_eq_zero.mp h1
    · exact absurd (sub_eq_zero.mp h2) hij
  refine ⟨ha, ?_⟩
  rw [ha] at hi
  exact add_left_cancel hi


/-! ## Section 21. The pharmakon of critique

A critique that refutes a strengthened version of a claim is a VALID refutation.
Its validity is what conceals the misfire: the operation is correct and the
target is wrong, and soundness alone does not distinguish the two cases. This is
the pharmakon applied to scrutiny itself — the remedy and the poison are the
same operation.
-/

structure Critique (Claim : Type*) where
  target : Claim
  valid : Bool

/-- L63. STRAW MAN. Refuting a strictly stronger claim leaves the original
standing. The refutation is sound; it is sound about something else. -/
theorem straw_man_leaves_claim_standing :
    ∃ c cPlus : Prop, (cPlus → c) ∧ ¬ cPlus ∧ c :=
  ⟨True, False, fun h => h.elim, not_false, trivial⟩

/-- L64. The dual. Establishing a weakened version does not establish the
original. Straw man and motte-and-bailey are one countermodel read twice. -/
theorem motte_bailey_does_not_establish_claim :
    ∃ c cMinus : Prop, (c → cMinus) ∧ cMinus ∧ ¬ c :=
  ⟨False, True, fun h => h.elim, trivial, not_false⟩

/-- L65. The validity of a critique does not recover which claim it was a
critique of. Two critiques, both valid, different targets, same readout. -/
theorem critique_validity_does_not_recover_target
    {Claim : Type*} {c₁ c₂ : Claim} (hne : c₁ ≠ c₂) :
    ¬ FactorsThrough (fun k : Critique Claim => k.valid) (fun k => k.target) :=
  collision_blocks_factorization _ _
    (x₁ := ⟨c₁, true⟩) (x₂ := ⟨c₂, true⟩) rfl hne

/-- L66. THE PHARMAKON, EXACTLY. Critique is target-exact for its own validity
and non-injective on what it was aimed at — I:K10's shape, instantiated on the
act of scrutiny. The critique genuinely establishes something. What it
establishes does not include its own aim. -/
theorem critique_is_pharmakon {Claim : Type*} {c₁ c₂ : Claim} (hne : c₁ ≠ c₂) :
    FactorsThrough (fun k : Critique Claim => k.valid) (fun k => k.valid) ∧
    ¬ FactorsThrough (fun k : Critique Claim => k.valid) (fun k => k.target) :=
  ⟨⟨id, fun _ => rfl⟩, critique_validity_does_not_recover_target hne⟩

/-! ## Section 22. Delegation relocates residual will, and conceals it

External certification does not remove the act of selection. It moves it — into
the choice of verifier, and into that verifier's declared axiom basis — where it
is less apparent. L70 is the concealment half and is the substantive one.
-/

def UniqueOutcome {J S : Type*} (Admissible : J → Prop) (outcome : J → S) : Prop :=
  ∃ s : S, ∀ j, Admissible j → outcome j = s

def ResidualWill {J S : Type*} (Admissible : J → Prop) (outcome : J → S)
    (chosen : J) : Prop :=
  Admissible chosen ∧ ¬ UniqueOutcome Admissible outcome

/-- L67. I:K11 restated for self-containment. -/
theorem residual_selection {J S : Type*} (Admissible : J → Prop) (outcome : J → S)
    {j₁ j₂ : J} (h₁ : Admissible j₁) (h₂ : Admissible j₂)
    (hdiff : outcome j₁ ≠ outcome j₂) :
    ¬ UniqueOutcome Admissible outcome := by
  rintro ⟨s, hs⟩
  exact hdiff ((hs j₁ h₁).trans (hs j₂ h₂).symm)

structure Verifier (Basis Claim : Type*) where
  basis : Basis
  verdict : Claim → Bool

/-- L68. Two admissible verifiers disagreeing on one claim defeat unique
outcome. Delegation does not, by itself, force a verdict. -/
theorem competing_verifiers_defeat_unique_outcome
    {Basis Claim : Type*} (Admissible : Verifier Basis Claim → Prop) (c : Claim)
    {v₁ v₂ : Verifier Basis Claim}
    (h₁ : Admissible v₁) (h₂ : Admissible v₂)
    (hdiff : v₁.verdict c ≠ v₂.verdict c) :
    ¬ UniqueOutcome Admissible (fun v => v.verdict c) :=
  residual_selection Admissible (fun v => v.verdict c) h₁ h₂ hdiff

/-- L69. DELEGATION PRESERVES RESIDUAL WILL. Choosing an admissible verifier in
a registry that does not force one verdict satisfies the project definition of
will. Certification by an outside party is a relocation of the selection, not an
elimination of it. -/
theorem delegation_preserves_residual_will
    {Basis Claim : Type*} (Admissible : Verifier Basis Claim → Prop) (c : Claim)
    {chosen v₂ : Verifier Basis Claim}
    (hchosen : Admissible chosen) (h₂ : Admissible v₂)
    (hdiff : chosen.verdict c ≠ v₂.verdict c) :
    ResidualWill Admissible (fun v => v.verdict c) chosen :=
  ⟨hchosen, competing_verifiers_defeat_unique_outcome Admissible c hchosen h₂ hdiff⟩

/-- The public certificate: what a consumer of a verdict actually sees. -/
def certificateLabel {Basis Claim : Type*} (_ : Verifier Basis Claim) : String :=
  "certified"

/-- L70. THE RELOCATION IS ALSO A CONCEALMENT. Two verifiers with different
declared axiom bases expose the same public certificate label, so the label does
not recover the basis. The act of will moved upstream into the choice of
admitted axioms and became less apparent in the same step. This is I:K19 applied
to certification, and it is why a receipt must carry its basis explicitly: the
badge cannot. -/
theorem certificate_does_not_recover_basis
    {Basis Claim : Type*} {b₁ b₂ : Basis} (hb : b₁ ≠ b₂) (f : Claim → Bool) :
    ¬ FactorsThrough (fun v : Verifier Basis Claim => certificateLabel v)
      (fun v => v.basis) :=
  collision_blocks_factorization _ _
    (x₁ := ⟨b₁, f⟩) (x₂ := ⟨b₂, f⟩) rfl hb

/-- L71. DISCHARGE TRANSFERS, IT DOES NOT REDUCE. Proving a previously adopted
premise from a new one leaves the adopted count unchanged. The obligation moves;
it does not vanish. This is the accounting form of positional-recoverability
Remark 5.4 and of the bridge relocation recorded at section 14.3. -/
theorem discharge_does_not_reduce_adoptions {α : Type*} [DecidableEq α]
    (S : Finset α) (b p : α) (hb : b ∈ S) (hp : p ∉ S) :
    (insert p (S.erase b)).card = S.card := by
  have hpe : p ∉ S.erase b := fun h => hp (Finset.mem_of_mem_erase h)
  have hcard : (S.erase b).card = S.card - 1 := Finset.card_erase_of_mem hb
  have hpos : 0 < S.card := Finset.card_pos.mpr ⟨b, hb⟩
  rw [Finset.card_insert_of_notMem hpe, hcard]
  omega


/-! ## Section 23. The symmetry obstruction (imported, not derived)

PROVENANCE. This is `positional_recoverability` Theorem 5.1, restated here in
the vocabulary of this kernel so the file is self-contained. It is **not** a
result of this document. The canonical statement, its quantifier analysis
(Remark 5.2), its costing (Corollary 5.3, "orientation is never free"), and the
admission-accounting remark (Remark 5.4) belong to that paper and are cited, not
re-derived.

WHY IT MATTERS HERE. Sections 1-4 use only the COLLISION route, which requires
exhibiting a pair. The symmetry route requires no witness at all: a symmetry of
the declared vocabulary suffices. It is the stronger of the two, and its absence
from the earlier sections was a real omission.

NOT ENCODED. Corollary 5.3's lower bound is a statement about minimisation over
all layouts and all decoders. That machinery is not present in this file and is
not simulated here. Cite the source.
-/

/-- L72. SYMMETRY BLOCKS RECOVERY. If a readout is invariant under a symmetry
that moves the target, no decoder recovers the target. No collision pair need be
exhibited by the caller: the symmetry supplies it. -/
theorem symmetry_blocks_recovery {X Y Z : Type*}
    (P : X → Y) (Q : X → Z) (σ : X → X)
    (hP : ∀ x, P (σ x) = P x) {x₀ : X} (hQ : Q (σ x₀) ≠ Q x₀) :
    ¬ FactorsThrough P Q :=
  collision_blocks_factorization P Q (hP x₀) hQ

/-- L73. The exchange involution on priority claims instantiates L72: any readout
invariant under exchanging the relata fails to recover which relatum is prior.
Section 14's L42 is this instance, and the corpus had the general form first. -/
theorem exchange_invariant_readout_loses_priority
    {R Y : Type*} (P : PriorityClaim R → Y)
    (hP : ∀ c, P (exchangeRelata c) = P c) (c₀ : PriorityClaim R) :
    ¬ FactorsThrough P (fun c => c.prior) :=
  symmetry_blocks_recovery P (fun c => c.prior) exchangeRelata hP
    (x₀ := c₀) (Ne.symm c₀.distinct)


/-! ## Section 24. Equal-standard adjudication

Two constructions are adjudicated by a standard. This section encodes what
follows when they agree on every DECLARED criterion and receive different
verdicts. It takes no position on whether either construction is correct.
-/

/-- The criteria a standard declares itself to be using. -/
structure DeclaredCriteria where
  estimatesClose : Bool
  residualControlled : Bool
  witnessExhibited : Bool
  familyAdmissible : Bool
  deriving DecidableEq, Repr

/-- A standard is FAIR when its verdict is a function of the declared criteria
and of nothing else. -/
def FairStandard {C : Type*} (criteria : C → DeclaredCriteria)
    (verdict : C → Bool) : Prop :=
  FactorsThrough criteria verdict

/-- L74. FORCED ACCEPTANCE. Under a fair standard, two constructions agreeing on
every declared criterion receive the same verdict. Accepting one forces
accepting the other. -/
theorem equal_criteria_forces_equal_verdict {C : Type*}
    (criteria : C → DeclaredCriteria) (verdict : C → Bool)
    (hfair : FairStandard criteria verdict) {c₁ c₂ : C}
    (hsame : criteria c₁ = criteria c₂) :
    verdict c₁ = verdict c₂ := by
  obtain ⟨g, hg⟩ := hfair
  rw [← hg c₁, ← hg c₂, hsame]

/-- L75. DIFFERENTIAL TREATMENT EXPOSES AN UNDECLARED CRITERION. If the declared
criteria agree and the verdicts differ, the verdict does not factor through the
declared criteria, so some input outside them is doing the work. This says
nothing about what that input is, only that it exists and was not declared. -/
theorem differing_verdicts_defeat_fairness {C : Type*}
    (criteria : C → DeclaredCriteria) (verdict : C → Bool)
    {c₁ c₂ : C} (hsame : criteria c₁ = criteria c₂)
    (hdiff : verdict c₁ ≠ verdict c₂) :
    ¬ FairStandard criteria verdict :=
  collision_blocks_factorization criteria verdict hsame hdiff

/-- L76. THE TRICHOTOMY. For any standard and any two constructions agreeing on
the declared criteria: both accepted, both rejected, or the standard has an
undeclared criterion. There is no fourth option. -/
theorem equal_standard_trichotomy {C : Type*}
    (criteria : C → DeclaredCriteria) (verdict : C → Bool)
    (c₁ c₂ : C) (hsame : criteria c₁ = criteria c₂) :
    (verdict c₁ = true ∧ verdict c₂ = true) ∨
    (verdict c₁ = false ∧ verdict c₂ = false) ∨
    ¬ FairStandard criteria verdict := by
  by_cases h : verdict c₁ = verdict c₂
  · cases hv : verdict c₁ with
    | false => exact Or.inr (Or.inl ⟨rfl, by rw [← h]; exact hv⟩)
    | true  => exact Or.inl ⟨rfl, by rw [← h]; exact hv⟩
  · exact Or.inr (Or.inr (differing_verdicts_defeat_fairness criteria verdict hsame h))

/-! ## Section 25. One term, two readings, and the label that carries neither

The deflation case, encoded here for the term at issue. Lean certifies both
readings, certifies that they are incompatible, and certifies that the shared
public term does not recover which was used.
-/

/-- Two readings of one term. The forced reading admits a constructed forcing
term; the unforced reading requires it to vanish. -/
inductive SingularityReading where
  | forcedAdmitted
  | forcingMustVanish
  deriving DecidableEq, Repr

/-- What each reading requires of the forcing term. -/
def requiresZeroForcing : SingularityReading → Bool
  | .forcedAdmitted => false
  | .forcingMustVanish => true

/-- The public term exposed by both readings. -/
def publicTerm (_ : SingularityReading) : String := "singularity"

/-- L77. Both readings expose the same public term. -/
theorem singularity_term_shared :
    publicTerm .forcedAdmitted = publicTerm .forcingMustVanish := rfl

/-- L78. ONE TERM CANNOT CARRY BOTH. The readings agree on the public term and
disagree on what they require of the forcing, so no single claim satisfies both. -/
theorem singularity_readings_incompatible :
    publicTerm .forcedAdmitted = publicTerm .forcingMustVanish ∧
    requiresZeroForcing .forcedAdmitted ≠ requiresZeroForcing .forcingMustVanish := by
  refine ⟨rfl, by decide⟩

/-- L79. The public term does not recover the reading. A reader who sees only the
term cannot determine which requirement was in force — and neither can a
certificate that reports only the term. -/
theorem singularity_term_does_not_recover_reading :
    ¬ FactorsThrough publicTerm requiresZeroForcing :=
  collision_blocks_factorization publicTerm requiresZeroForcing
    (x₁ := SingularityReading.forcedAdmitted)
    (x₂ := SingularityReading.forcingMustVanish) rfl (by decide)

/-- L80. THE ESCAPE IS CLOSED. A standard cannot rescue differential treatment by
appealing to certification, because the certificate's public report does not
recover which proposition was encoded (L70, L79). Adding "certified" to the
declared criteria therefore adds a field whose value is the same for both
readings, leaving L75 in force. -/
theorem certification_does_not_separate_readings
    (report : SingularityReading → String)
    (hreport : ∀ r, report r = publicTerm r) :
    ¬ FactorsThrough report requiresZeroForcing := by
  have hfun : report = publicTerm := funext hreport
  rw [hfun]
  exact singularity_term_does_not_recover_reading


/-! ## Section 26. Quantifier structure, parity, and priority

Everything in this section is encoded at the level of QUANTIFIER STRUCTURE: what
form a claim takes, not whether it is correct. No declaration here asserts that
any construction is valid, invalid, better, or worse. Each field below is a
sourced, checkable property of a published artifact.
-/

/-- The logical form of a finite-time-blowup claim, at the level that decides
what kind of verification it admits. -/
structure BlowupClaim where
  /-- The family of admissible configurations is declared. -/
  familyDeclared : Bool
  /-- A single configuration is exhibited in closed form for direct term-by-term
      substitution into the equations. -/
  witnessExhibited : Bool
  /-- The property is established by estimates closing over the family. -/
  estimatesClose : Bool
  /-- The forcing term is permitted to be nonzero. -/
  forcingAdmitted : Bool
  deriving DecidableEq, Repr

/-- L81. PARITY OF QUANTIFIER STRUCTURE. Two claims agreeing on every structural
field are indistinguishable to any standard that reads only those fields. A
standard separating them is reading something else. -/
theorem same_structure_same_verdict
    (structureOf : BlowupClaim → BlowupClaim) (verdict : BlowupClaim → Bool)
    (hfair : FactorsThrough structureOf verdict)
    {c₁ c₂ : BlowupClaim} (hsame : structureOf c₁ = structureOf c₂) :
    verdict c₁ = verdict c₂ := by
  obtain ⟨g, hg⟩ := hfair
  rw [← hg c₁, ← hg c₂, hsame]

/-- L82. BOTH OR NEITHER. Restricted to the shared structural fields — family
declared, no closed-form witness exhibited, established by estimates — any fair
standard returns the same verdict on both. Accepting one while rejecting the
other requires a criterion outside those fields, and that criterion is then
undeclared until stated. -/
theorem parity_on_shared_fields
    (verdict : BlowupClaim → Bool)
    (hfair : FactorsThrough
      (fun c : BlowupClaim => (c.familyDeclared, c.witnessExhibited, c.estimatesClose)) verdict)
    {c₁ c₂ : BlowupClaim}
    (hF : c₁.familyDeclared = c₂.familyDeclared)
    (hW : c₁.witnessExhibited = c₂.witnessExhibited)
    (hE : c₁.estimatesClose = c₂.estimatesClose) :
    verdict c₁ = verdict c₂ := by
  obtain ⟨g, hg⟩ := hfair
  have hs : (c₁.familyDeclared, c₁.witnessExhibited, c₁.estimatesClose) =
      (c₂.familyDeclared, c₂.witnessExhibited, c₂.estimatesClose) := by rw [hF, hW, hE]
  rw [← hg c₁, ← hg c₂]
  exact congrArg g hs

/-! ### The two artifacts, by their own statements

Every field below is sourced. The `forcingAdmitted` values are the decisive
difference and are taken from each paper's own theorem statement.
-/

/-- Archived 2025-09-12. Claims Option C with forcing required to vanish. -/
def claimA : BlowupClaim :=
  { familyDeclared := true, witnessExhibited := false,
    estimatesClose := true, forcingAdmitted := false }

/-- Published 2026-09-08. Its Theorem 1.1 asserts the existence of a force
f in C-infinity-compact; its section 2 defines that force as the residual of the
constructed flow. -/
def claimB : BlowupClaim :=
  { familyDeclared := true, witnessExhibited := false,
    estimatesClose := true, forcingAdmitted := true }

/-- L83. The two claims agree on every field except forcing. In particular
neither exhibits a closed-form configuration for direct substitution. -/
theorem claims_agree_off_forcing :
    claimA.familyDeclared = claimB.familyDeclared ∧
    claimA.witnessExhibited = claimB.witnessExhibited ∧
    claimA.estimatesClose = claimB.estimatesClose ∧
    claimA.forcingAdmitted ≠ claimB.forcingAdmitted := by
  refine ⟨rfl, rfl, rfl, by decide⟩

/-- L84. FORCED PARITY. Any standard whose verdict reads only the three shared
structural fields returns the same verdict on both. -/
theorem parity_forced (verdict : BlowupClaim → Bool)
    (hfair : FactorsThrough
      (fun c => (c.familyDeclared, c.witnessExhibited, c.estimatesClose)) verdict) :
    verdict claimA = verdict claimB := by
  obtain ⟨g, hg⟩ := hfair
  rw [← hg claimA, ← hg claimB]
  rfl

/-! ### Scope: which Clay alternative is established -/

inductive ClayAlternative where
  | AB_unforced
  | CD_forced
  deriving DecidableEq, Repr

def alternativeOf (c : BlowupClaim) : ClayAlternative :=
  if c.forcingAdmitted then .CD_forced else .AB_unforced

/-- L85. The alternatives are distinct. A result establishing one does not
establish the other. -/
theorem alternatives_distinct :
    ClayAlternative.AB_unforced ≠ ClayAlternative.CD_forced := by decide

/-- L86. RESCOPING IS FORCED BY THE ARTIFACT'S OWN STATEMENT. A claim admitting a
nonzero forcing establishes the forced alternative and not the unforced one. -/
theorem forced_claim_establishes_only_CD (c : BlowupClaim)
    (h : c.forcingAdmitted = true) :
    alternativeOf c = ClayAlternative.CD_forced ∧
    alternativeOf c ≠ ClayAlternative.AB_unforced := by
  constructor
  · simp [alternativeOf, h]
  · simp [alternativeOf, h]

/-- L87. The public headline does not recover the alternative. Both alternatives
are reported under one phrase, so no reader of the phrase can determine which was
established — and no certificate reporting only the phrase can either. -/
def headline (_ : ClayAlternative) : String := "the Navier-Stokes problem"

theorem headline_does_not_recover_alternative :
    ¬ FactorsThrough headline (fun a => a) :=
  collision_blocks_factorization headline (fun a => a)
    (x₁ := ClayAlternative.AB_unforced) (x₂ := ClayAlternative.CD_forced)
    rfl (by decide)

/-! ### Priority of the claim -/

/-- A dated public claim. Dates are encoded as ordinals on a single timeline. -/
structure DatedClaim where
  day : Nat
  claim : BlowupClaim

/-- 2025-09-12, archived publicly. -/
def datedA : DatedClaim := { day := 20250912, claim := claimA }
/-- 2026-09-08, published publicly. -/
def datedB : DatedClaim := { day := 20260908, claim := claimB }

/-- L88. PRIORITY IS A TOTAL ORDER FACT. The earlier public claim is earlier.
This asserts nothing about correctness, method, or influence. -/
theorem priority_of_public_claim : datedA.day < datedB.day := by decide

/-- L89. Priority does not factor through the verdict: a standard's acceptance
decision carries no information about which claim was public first, so acceptance
can never establish or remove priority. -/
theorem verdict_does_not_recover_priority (verdict : DatedClaim → Bool)
    (hconst : ∀ d, verdict d = true) :
    ¬ FactorsThrough verdict (fun d => d.day) := by
  intro hfac
  obtain ⟨g, hg⟩ := hfac
  have h1 := hg datedA
  have h2 := hg datedB
  rw [hconst datedA] at h1
  rw [hconst datedB] at h2
  have : datedA.day = datedB.day := h1.symm.trans h2
  exact absurd this (by decide)

end LambdaIII

section AuditChecks
open LambdaIII

#check @collision_blocks_factorization
#check @id_factors_implies_injective
#check @injective_factors_all
#check @factorization_dichotomy
#check @not_injective_iff_collision
#check @scope_retained_is_recoverable
#check @scope_forgotten_is_not_recoverable
#check @only_error_retracts
#check @warrant_lapse_does_not_retract
#check @criterion_sides_exhaustive
#check @criterion_sides_exclusive
#check @double_exclusion_is_double_negation
#check @double_exclusion_collapse
#check @binary_criterion_has_collision
#check @binary_criterion_not_faithful
#check @absolute_with_both_rules_is_identity
#check @complement_requirement_blocks_absolute_priority
#check @no_first_position_cyclic
#check @preserves_and
#check @preserves_or
#check @preserves_not
#check @preserves_imp
#check @preserved_predicate_agrees_despite_noncommutation
#check @finite_budget_forces_tradeoff_n
#check @finite_metadata_leaves_freedom
#check @nat_cost_registry_attains_minimum
#check @gaps_determine_up_to_shift
#check @affine_calibration_unique
#check @distinct_count_parity
#check @boost_preserves_time_orientation
#check @boost_normalization_composes
#check @planck_rescaling_rigid
#check @no_first_position_premises_necessary
#check @lorentz_normalization_necessary
#check @budget_demand_hypothesis_necessary
#check @nontriviality_hypothesis_necessary
#check @velocity_bound_necessary
#check @E09_nonzero_hypothesis_redundant
#check @P07_length_hypothesis_redundant
#check @E15_first_conjunct_is_contentless
#check @priority_claim_uses_individuation
#check @priority_claim_uses_directed_order
#check @assertion_bridge_nonvacuous
#check @no_first_position_assertion_reading
#check @timelike_not_time_only
#check @timelike_not_space_only
#check @taxonomy_encoding_is_lossy
#check @planck_two_constants_insufficient
#check @spectral_read_inversion_invariant
#check @spectral_fibre_at_most_pair
#check @spectral_fibre_singleton_iff
#check @cardinality_forces_collision
#check @cardinality_forces_unfaithfulness
#check @kary_criterion_has_collision
#check @kary_criterion_not_faithful
#check @residue_monotone
#check @conservative_expansion_can_lower_cost_strictly
#check @conservative_expansion_need_not_lower_cost
#check @dichotomy_nonemptiness_necessary
#check @no_first_position_without_B03_is_trivial
#check @gaps_determine_up_to_shift_ring
#check @affine_calibration_unique_field
#check @straw_man_leaves_claim_standing
#check @motte_bailey_does_not_establish_claim
#check @critique_validity_does_not_recover_target
#check @critique_is_pharmakon
#check @residual_selection
#check @competing_verifiers_defeat_unique_outcome
#check @delegation_preserves_residual_will
#check @certificate_does_not_recover_basis
#check @discharge_does_not_reduce_adoptions
#check @symmetry_blocks_recovery
#check @exchange_invariant_readout_loses_priority
#check @equal_criteria_forces_equal_verdict
#check @differing_verdicts_defeat_fairness
#check @equal_standard_trichotomy
#check @singularity_term_shared
#check @singularity_readings_incompatible
#check @singularity_term_does_not_recover_reading
#check @certification_does_not_separate_readings
#check @same_structure_same_verdict
#check @parity_on_shared_fields
#check @claims_agree_off_forcing
#check @parity_forced
#check @alternatives_distinct
#check @forced_claim_establishes_only_CD
#check @headline_does_not_recover_alternative
#check @priority_of_public_claim
#check @verdict_does_not_recover_priority

#print axioms collision_blocks_factorization
#print axioms id_factors_implies_injective
#print axioms injective_factors_all
#print axioms factorization_dichotomy
#print axioms not_injective_iff_collision
#print axioms scope_retained_is_recoverable
#print axioms scope_forgotten_is_not_recoverable
#print axioms only_error_retracts
#print axioms warrant_lapse_does_not_retract
#print axioms criterion_sides_exhaustive
#print axioms criterion_sides_exclusive
#print axioms double_exclusion_is_double_negation
#print axioms double_exclusion_collapse
#print axioms binary_criterion_has_collision
#print axioms binary_criterion_not_faithful
#print axioms absolute_with_both_rules_is_identity
#print axioms complement_requirement_blocks_absolute_priority
#print axioms no_first_position_cyclic
#print axioms preserves_and
#print axioms preserves_or
#print axioms preserves_not
#print axioms preserves_imp
#print axioms preserved_predicate_agrees_despite_noncommutation
#print axioms finite_budget_forces_tradeoff_n
#print axioms finite_metadata_leaves_freedom
#print axioms nat_cost_registry_attains_minimum
#print axioms gaps_determine_up_to_shift
#print axioms affine_calibration_unique
#print axioms distinct_count_parity
#print axioms boost_preserves_time_orientation
#print axioms boost_normalization_composes
#print axioms planck_rescaling_rigid
#print axioms no_first_position_premises_necessary
#print axioms lorentz_normalization_necessary
#print axioms budget_demand_hypothesis_necessary
#print axioms nontriviality_hypothesis_necessary
#print axioms velocity_bound_necessary
#print axioms E09_nonzero_hypothesis_redundant
#print axioms P07_length_hypothesis_redundant
#print axioms E15_first_conjunct_is_contentless
#print axioms priority_claim_uses_individuation
#print axioms priority_claim_uses_directed_order
#print axioms assertion_bridge_nonvacuous
#print axioms no_first_position_assertion_reading
#print axioms timelike_not_time_only
#print axioms timelike_not_space_only
#print axioms taxonomy_encoding_is_lossy
#print axioms planck_two_constants_insufficient
#print axioms spectral_read_inversion_invariant
#print axioms spectral_fibre_at_most_pair
#print axioms spectral_fibre_singleton_iff
#print axioms cardinality_forces_collision
#print axioms cardinality_forces_unfaithfulness
#print axioms kary_criterion_has_collision
#print axioms kary_criterion_not_faithful
#print axioms residue_monotone
#print axioms conservative_expansion_can_lower_cost_strictly
#print axioms conservative_expansion_need_not_lower_cost
#print axioms dichotomy_nonemptiness_necessary
#print axioms no_first_position_without_B03_is_trivial
#print axioms gaps_determine_up_to_shift_ring
#print axioms affine_calibration_unique_field
#print axioms straw_man_leaves_claim_standing
#print axioms motte_bailey_does_not_establish_claim
#print axioms critique_validity_does_not_recover_target
#print axioms critique_is_pharmakon
#print axioms residual_selection
#print axioms competing_verifiers_defeat_unique_outcome
#print axioms delegation_preserves_residual_will
#print axioms certificate_does_not_recover_basis
#print axioms discharge_does_not_reduce_adoptions
#print axioms symmetry_blocks_recovery
#print axioms exchange_invariant_readout_loses_priority
#print axioms equal_criteria_forces_equal_verdict
#print axioms differing_verdicts_defeat_fairness
#print axioms equal_standard_trichotomy
#print axioms singularity_term_shared
#print axioms singularity_readings_incompatible
#print axioms singularity_term_does_not_recover_reading
#print axioms certification_does_not_separate_readings
#print axioms same_structure_same_verdict
#print axioms parity_on_shared_fields
#print axioms claims_agree_off_forcing
#print axioms parity_forced
#print axioms alternatives_distinct
#print axioms forced_claim_establishes_only_CD
#print axioms headline_does_not_recover_alternative
#print axioms priority_of_public_claim
#print axioms verdict_does_not_recover_priority

#eval Lean.versionString
#eval "LAMBDA_PART_III_SUCCESSOR_R1"

end AuditChecks

#eval Lean.versionString
#eval "LAMBDA_R4_PARTIII_END"

SHA-256: f1769ecdf131297fef4fb1e2389166f4e78638753ae301b0dfc82c38c5be9904

import Lean

/-!
# Lambda, Reference, and the Spatiotemporal Descriptive Frame
Formal kernel for the companion paper.

Scope:
This file checks only the propositions encoded below.  The terms `self`, `other`,
`space`, `time`, `will`, `absolute`, and `meaning` receive only the formal roles
explicitly assigned here.  Physical, phenomenological, linguistic, or ontological
interpretations require separate bridge arguments in the paper.
-/

namespace LambdaSpatiotemporal

/-! ## 1. Reference polarity -/

inductive RefRole where
  | source
  | target
  deriving DecidableEq, Repr

structure RoleTagged (X : Type) where
  carrier : X
  role : RefRole
  deriving DecidableEq, Repr

def asSource {X : Type} (x : X) : RoleTagged X := ⟨x, .source⟩
def asTarget {X : Type} (x : X) : RoleTagged X := ⟨x, .target⟩

theorem source_target_roles_distinct : RefRole.source ≠ RefRole.target := by
  intro h
  cases h

theorem reference_polarity {X : Type} (x y : X) :
    asSource x ≠ asTarget y := by
  intro h
  have hr : RefRole.source = RefRole.target := congrArg RoleTagged.role h
  exact source_target_roles_distinct hr

/-- Even when the carrier is the same, referring and referred-to roles remain distinct. -/
theorem reflexive_reference_preserves_role_distinction {X : Type} (x : X) :
    asSource x ≠ asTarget x :=
  reference_polarity x x

/-- Repeating the tagging operation at any indexed station preserves role polarity. -/
theorem iterated_reference_polarity {X : Type} (x : X) (n : Nat) :
    (n, asSource x) ≠ (n, asTarget x) := by
  intro h
  have ht : asSource x = asTarget x := congrArg Prod.snd h
  exact reflexive_reference_preserves_role_distinction x ht

/-! ## 2. Binary partition and self/other bridge -/

def SelfSide {X : Type} (criterion : X → Bool) (x : X) : Prop := criterion x = true
def OtherSide {X : Type} (criterion : X → Bool) (x : X) : Prop := criterion x = false

def NontrivialCriterion {X : Type} (criterion : X → Bool) : Prop :=
  (∃ x, SelfSide criterion x) ∧ (∃ y, OtherSide criterion y)

theorem nontrivial_criterion_exhibits_poles {X : Type} (criterion : X → Bool)
    (h : NontrivialCriterion criterion) :
    ∃ x y, SelfSide criterion x ∧ OtherSide criterion y := by
  rcases h with ⟨⟨x, hx⟩, ⟨y, hy⟩⟩
  exact ⟨x, y, hx, hy⟩

theorem nontrivial_criterion_exhibits_distinct_states {X : Type} (criterion : X → Bool)
    (h : NontrivialCriterion criterion) :
    ∃ x y : X, x ≠ y := by
  rcases h with ⟨⟨x, hx⟩, ⟨y, hy⟩⟩
  refine ⟨x, y, ?_⟩
  intro hxy
  subst y
  have : true = false := hx.symm.trans hy
  cases this

/-! ## 3. Exclusion is indexed to a criterion -/

def ExcludedBy {X : Type} (criterion : X → Prop) (x : X) : Prop := ¬ criterion x

theorem exclusion_is_criterion_relative {X : Type} (criterion : X → Prop) (x : X) :
    ExcludedBy criterion x ↔ ¬ criterion x :=
  Iff.rfl

/-! ## 4. Lambda projection / fibre obstruction -/

theorem postprocessing_cannot_split_fibre
    {X Y Z : Type} (projection : X → Y) (g : Y → Z) {x₁ x₂ : X}
    (h : projection x₁ = projection x₂) :
    g (projection x₁) = g (projection x₂) :=
  congrArg g h

def FactorsThrough {X Y Z : Type} (projection : X → Y) (target : X → Z) : Prop :=
  ∃ g : Y → Z, ∀ x, g (projection x) = target x

theorem target_difference_blocks_factorization
    {X Y Z : Type} (projection : X → Y) (target : X → Z)
    {x₁ x₂ : X} (hproj : projection x₁ = projection x₂)
    (htarget : target x₁ ≠ target x₂) :
    ¬ FactorsThrough projection target := by
  intro hfac
  rcases hfac with ⟨g, hg⟩
  apply htarget
  calc
    target x₁ = g (projection x₁) := (hg x₁).symm
    _ = g (projection x₂) := congrArg g hproj
    _ = target x₂ := hg x₂

/-! ## 5. Compression may be exact for a target while remaining non-injective -/

def InjectiveMap {X Y : Type} (f : X → Y) : Prop :=
  ∀ ⦃x y⦄, f x = f y → x = y

theorem target_exact_compression_can_lose_other_distinctions :
    ∃ (compress : Bool × Bool → Bool) (target : Bool × Bool → Bool),
      FactorsThrough compress target ∧ ¬ InjectiveMap compress := by
  let compress : Bool × Bool → Bool := fun p => p.1
  let target : Bool × Bool → Bool := fun p => p.1
  refine ⟨compress, target, ?_, ?_⟩
  · refine ⟨(fun b => b), ?_⟩
    intro x
    rfl
  · intro hinj
    have hpair : (false, false) = (false, true) := hinj rfl
    have hsnd : false = true := congrArg Prod.snd hpair
    cases hsnd

/-! ## 6. Residual selection / will kernel -/

def UniqueOutcome {J S : Type} (Admissible : J → Prop) (outcome : J → S) : Prop :=
  ∃ s : S, ∀ j, Admissible j → outcome j = s

theorem residual_selection
    {J S : Type} (Admissible : J → Prop) (outcome : J → S)
    {j₁ j₂ : J} (h₁ : Admissible j₁) (h₂ : Admissible j₂)
    (hdiff : outcome j₁ ≠ outcome j₂) :
    ¬ UniqueOutcome Admissible outcome := by
  intro huniq
  rcases huniq with ⟨s, hs⟩
  apply hdiff
  calc
    outcome j₁ = s := hs j₁ h₁
    _ = outcome j₂ := (hs j₂ h₂).symm

/-- Formal role used by the paper's term `will`: an admissible selected procedure
    in a registry whose admissible procedures do not determine one unique outcome. -/
def ResidualWill {J S : Type} (Admissible : J → Prop) (outcome : J → S) (chosen : J) : Prop :=
  Admissible chosen ∧ ¬ UniqueOutcome Admissible outcome

theorem residual_will_from_competing_admissible_procedures
    {J S : Type} (Admissible : J → Prop) (outcome : J → S)
    {chosen j₂ : J} (hchosen : Admissible chosen) (h₂ : Admissible j₂)
    (hdiff : outcome chosen ≠ outcome j₂) :
    ResidualWill Admissible outcome chosen := by
  exact ⟨hchosen, residual_selection Admissible outcome hchosen h₂ hdiff⟩

/-- A selected procedure can index a criterion without the criterion being uniquely forced by
    the predecessor registry.  The substantive premise is that two admissible procedures induce
    different criteria. -/
def SelectedCriterion {J X : Type} (criterionOf : J → X → Bool) (chosen : J) : X → Bool :=
  criterionOf chosen

theorem competing_admissible_criteria_not_uniquely_forced
    {J X : Type} (Admissible : J → Prop) (criterionOf : J → X → Bool)
    {j₁ j₂ : J} (h₁ : Admissible j₁) (h₂ : Admissible j₂)
    (hdiff : criterionOf j₁ ≠ criterionOf j₂) :
    ¬ UniqueOutcome Admissible criterionOf :=
  residual_selection Admissible criterionOf h₁ h₂ hdiff

/-! ## 7. Absolute-priority schema and no-first-position kernel -/

def AbsolutePriority {C : Type} (Priority UsesComplement : C → Prop) (c : C) : Prop :=
  Priority c ∧ ¬ UsesComplement c

theorem complement_requirement_blocks_absolute_priority
    {C : Type} (Priority UsesComplement : C → Prop)
    (hbridge : ∀ c, Priority c → UsesComplement c) :
    ¬ ∃ c, AbsolutePriority Priority UsesComplement c := by
  intro h
  rcases h with ⟨c, hp, hnot⟩
  exact hnot (hbridge c hp)

structure SpatiotemporalBridge (Claim : Type) where
  SpaceFirst : Claim → Prop
  TimeFirst : Claim → Prop
  UsesTemporalResource : Claim → Prop
  UsesSpatialResource : Claim → Prop
  spaceFirstUsesTemporal : ∀ c, SpaceFirst c → UsesTemporalResource c
  timeFirstUsesSpatial : ∀ c, TimeFirst c → UsesSpatialResource c

def AbsoluteSpaceFirst {Claim : Type} (B : SpatiotemporalBridge Claim) (c : Claim) : Prop :=
  AbsolutePriority B.SpaceFirst B.UsesTemporalResource c

def AbsoluteTimeFirst {Claim : Type} (B : SpatiotemporalBridge Claim) (c : Claim) : Prop :=
  AbsolutePriority B.TimeFirst B.UsesSpatialResource c

theorem no_first_position {Claim : Type} (B : SpatiotemporalBridge Claim) :
    (¬ ∃ c, AbsoluteSpaceFirst B c) ∧ (¬ ∃ c, AbsoluteTimeFirst B c) := by
  constructor
  · exact complement_requirement_blocks_absolute_priority
      B.SpaceFirst B.UsesTemporalResource B.spaceFirstUsesTemporal
  · exact complement_requirement_blocks_absolute_priority
      B.TimeFirst B.UsesSpatialResource B.timeFirstUsesSpatial

/-! ## 8. Frame-local warrant does not self-promote to universal warrant -/

inductive TwoFrame where
  | local
  | other
  deriving DecidableEq, Repr

def SampleWarrant : TwoFrame → Prop
  | .local => True
  | .other => False

def UniversalWarrant {F : Type} (Warrant : F → Prop) : Prop := ∀ f, Warrant f

theorem local_warrant_not_universal_in_general :
    SampleWarrant .local ∧ ¬ UniversalWarrant SampleWarrant := by
  constructor
  · exact True.intro
  · intro hall
    exact hall .other

/-- A predicate named or intended as `absolute` has no elimination rule by logic alone. -/
theorem absolute_label_does_not_self_license :
    ¬ (∀ (Absolute : Prop → Prop) (p : Prop), Absolute p → p) := by
  intro h
  have hfalse : False := h (fun _ => True) False True.intro
  exact hfalse

/-! ## 9. Public-label compression can suppress operative meaning -/

inductive Usage where
  | original
  | extended
  deriving DecidableEq, Repr

inductive TinyState where
  | bare
  | marked
  deriving DecidableEq, Repr

def tinyMeaning : Usage → TinyState → Bool
  | .original, .bare => true
  | .original, .marked => false
  | .extended, _ => true

def publicLabel (_ : Usage) : String := "singularity"

theorem same_public_label : publicLabel .original = publicLabel .extended := rfl

theorem same_label_can_hide_different_meanings :
    publicLabel .original = publicLabel .extended ∧
    tinyMeaning .original .marked ≠ tinyMeaning .extended .marked := by
  constructor
  · rfl
  · decide

/-! ## 10. Translation bridges: preservation and noncommutation -/

def PreservesPredicate {A B : Type} (f : A → B) (P : A → Prop) (Q : B → Prop) : Prop :=
  ∀ a, P a ↔ Q (f a)

theorem predicate_preservation_composes
    {A B C : Type} (f : A → B) (g : B → C)
    (P : A → Prop) (Q : B → Prop) (R : C → Prop)
    (hAB : PreservesPredicate f P Q)
    (hBC : PreservesPredicate g Q R) :
    PreservesPredicate (fun a => g (f a)) P R := by
  intro a
  exact Iff.trans (hAB a) (hBC (f a))

theorem translations_need_not_commute :
    ∃ (AB BC AC : Bool → Bool) (x : Bool), AC x ≠ BC (AB x) := by
  refine ⟨(fun b => b), (fun b => b), Bool.not, false, ?_⟩
  decide

/-! ## 11. Finite resource budget forces a tradeoff when full demand exceeds it -/

theorem finite_budget_forces_tradeoff
    (costA costB allocA allocB budget : Nat)
    (hDemand : budget < costA + costB)
    (hBudget : allocA + allocB ≤ budget)
    (hA : costA ≤ allocA)
    (hB : costB ≤ allocB) : False := by
  have hsum : costA + costB ≤ allocA + allocB := Nat.add_le_add hA hB
  have hfit : costA + costB ≤ budget := Nat.le_trans hsum hBudget
  exact (Nat.not_le_of_lt hDemand) hfit

/-! ## 12. Frozen inscription does not by logic alone freeze interpretation -/

theorem same_input_can_receive_different_interpretations :
    ∃ (I₀ I₁ : Bool → Bool) (r : Bool), I₀ r ≠ I₁ r := by
  refine ⟨(fun b => b), Bool.not, false, ?_⟩
  decide

/-! ## 13. Audit checks -/

#check source_target_roles_distinct
#check reference_polarity
#check reflexive_reference_preserves_role_distinction
#check iterated_reference_polarity
#check nontrivial_criterion_exhibits_poles
#check nontrivial_criterion_exhibits_distinct_states
#check exclusion_is_criterion_relative
#check postprocessing_cannot_split_fibre
#check target_difference_blocks_factorization
#check target_exact_compression_can_lose_other_distinctions
#check residual_selection
#check residual_will_from_competing_admissible_procedures
#check SelectedCriterion
#check competing_admissible_criteria_not_uniquely_forced
#check complement_requirement_blocks_absolute_priority
#check no_first_position
#check local_warrant_not_universal_in_general
#check absolute_label_does_not_self_license
#check same_public_label
#check same_label_can_hide_different_meanings
#check predicate_preservation_composes
#check translations_need_not_commute
#check finite_budget_forces_tradeoff
#check same_input_can_receive_different_interpretations

#print axioms source_target_roles_distinct
#print axioms reference_polarity
#print axioms reflexive_reference_preserves_role_distinction
#print axioms iterated_reference_polarity
#print axioms nontrivial_criterion_exhibits_poles
#print axioms nontrivial_criterion_exhibits_distinct_states
#print axioms exclusion_is_criterion_relative
#print axioms postprocessing_cannot_split_fibre
#print axioms target_difference_blocks_factorization
#print axioms target_exact_compression_can_lose_other_distinctions
#print axioms residual_selection
#print axioms residual_will_from_competing_admissible_procedures
#print axioms competing_admissible_criteria_not_uniquely_forced
#print axioms complement_requirement_blocks_absolute_priority
#print axioms no_first_position
#print axioms local_warrant_not_universal_in_general
#print axioms absolute_label_does_not_self_license
#print axioms same_public_label
#print axioms same_label_can_hide_different_meanings
#print axioms predicate_preservation_composes
#print axioms translations_need_not_commute
#print axioms finite_budget_forces_tradeoff
#print axioms same_input_can_receive_different_interpretations

#eval Lean.versionString
#eval "LAMBDA_SPATIOTEMPORAL_TRANSLATION_AUDIT_COMPLETE"

end LambdaSpatiotemporal

SHA-256: a6e97beb2097c176ce42144c88bf0cd9152c943d1f5734b54688d522fb7e52d6

import Lean

/-!
# Deflation of Pharmakon-Based Delusion
A formal example of undisclosed meaning change under one public label.
The finite model illustrates logical structure, not a physical model.
-/
namespace SemanticDeflation

/-- The new use cannot retain every constraint of the old use. -/
theorem deflation
    {X : Type} (A B P : X → Prop)
    (hA : ∀ x, A x → ¬ P x)
    (hB : ∃ x, B x ∧ P x) :
    ¬ (∀ x, B x → A x) := by
  intro hBA
  rcases hB with ⟨x, hBx, hPx⟩
  exact hA x (hBA x hBx) hPx

/-- Identify a witness at which the original definition no longer applies. -/
theorem constraint_loss
    {X : Type} (A B P : X → Prop)
    (hA : ∀ x, A x → ¬ P x)
    (hB : ∃ x, B x ∧ P x) :
    ∃ x, B x ∧ P x ∧ ¬ A x := by
  rcases hB with ⟨x, hBx, hPx⟩
  exact ⟨x, hBx, hPx, fun hAx => hA x hAx hPx⟩

/-- No single predicate can be equivalent to both uses. -/
theorem no_shared_definition
    {X : Type} (A B P : X → Prop)
    (hA : ∀ x, A x → ¬ P x)
    (hB : ∃ x, B x ∧ P x) :
    ¬ ∃ S : X → Prop,
      (∀ x, S x ↔ A x) ∧ (∀ x, S x ↔ B x) := by
  intro h
  rcases h with ⟨S, hSA, hSB⟩
  exact deflation A B P hA hB
    (fun x hBx => (hSA x).mp ((hSB x).mpr hBx))

/-- Forcing both arms onto one unchanged meaning yields False. -/
theorem same_meaning_conflict
    {X : Type} (S P : X → Prop)
    (hNo : ∀ x, S x → ¬ P x)
    (hYes : ∃ x, S x ∧ P x) : False := by
  rcases hYes with ⟨x, hSx, hPx⟩
  exact hNo x hSx hPx

inductive State where
  | bare
  | marked

def HasTrait : State → Prop
  | .bare => False
  | .marked => True

def Original (x : State) : Prop := ¬ HasTrait x
def Extended (_x : State) : Prop := True

inductive Usage where
  | original
  | extended

def meaning : Usage → State → Prop
  | .original => Original
  | .extended => Extended

/-- This public label suppresses which predicate supplies its meaning. -/
def publicLabel (_u : Usage) : String := "singularity"

theorem original_inhabited : ∃ x, Original x := by
  exact ⟨State.bare, fun h => h⟩

theorem original_excludes_trait :
    ∀ x, Original x → ¬ HasTrait x := by
  intro x h
  exact h

theorem extended_admits_trait :
    ∃ x, Extended x ∧ HasTrait x := by
  exact ⟨State.marked, True.intro, True.intro⟩

theorem original_is_extended :
    ∀ x, Original x → Extended x := by
  intro x _
  exact True.intro

/-- Both scoped arms hold, with a nonempty old use and the same public name. -/
theorem two_checked_branches_one_label :
    (∃ x, meaning Usage.original x) ∧
    (∀ x, meaning Usage.original x → ¬ HasTrait x) ∧
    (∃ x, meaning Usage.extended x ∧ HasTrait x) ∧
    publicLabel Usage.original = publicLabel Usage.extended := by
  exact ⟨original_inhabited, original_excludes_trait,
    extended_admits_trait, rfl⟩

/-- Equal printed names do not justify identifying the two definitions. -/
theorem shared_label_does_not_preserve_meaning :
    publicLabel Usage.original = publicLabel Usage.extended ∧
    ¬ (∀ x, meaning Usage.original x ↔ meaning Usage.extended x) := by
  constructor
  · rfl
  · intro h
    exact deflation Original Extended HasTrait
      original_excludes_trait extended_admits_trait
      (fun x hx => (h x).mpr hx)

end SemanticDeflation

-- Explicit verification observations
#check SemanticDeflation.deflation
#print axioms SemanticDeflation.deflation

#check SemanticDeflation.constraint_loss
#print axioms SemanticDeflation.constraint_loss

#check SemanticDeflation.no_shared_definition
#print axioms SemanticDeflation.no_shared_definition

#check SemanticDeflation.same_meaning_conflict
#print axioms SemanticDeflation.same_meaning_conflict

#check SemanticDeflation.original_inhabited
#print axioms SemanticDeflation.original_inhabited

#check SemanticDeflation.original_excludes_trait
#print axioms SemanticDeflation.original_excludes_trait

#check SemanticDeflation.extended_admits_trait
#print axioms SemanticDeflation.extended_admits_trait

#check SemanticDeflation.original_is_extended
#print axioms SemanticDeflation.original_is_extended

#check SemanticDeflation.two_checked_branches_one_label
#print axioms SemanticDeflation.two_checked_branches_one_label

#check SemanticDeflation.shared_label_does_not_preserve_meaning
#print axioms SemanticDeflation.shared_label_does_not_preserve_meaning

#eval Lean.versionString
#eval "SEMANTIC_DEFLATION_AUDIT_COMPLETE"

SHA-256: 984bc83ee8750119bb18b0a404372669ca0ec1946afd3f1c525a9b9f9c4d67b7

import Lean

/-
================================================================================
  THE UNWITNESSABLE VERDICT  —  LEAN DEMONSTRATOR
  A self-contained enactment of the paper's central distinction.

  Lu Semita · EmergenceByDesign

  WHAT THIS FILE IS.
    This file does not "prove the paper." It cannot, and that impossibility
    IS the paper's thesis. What it does is make a proof assistant PERFORM the
    thesis: a passing kernel check certifies that a derivation is valid (the
    paper's C*), and NEVER that the formal statement captures the informal
    claim a human reader means (the paper's C). Run this file through Lean and
    the green check is itself the demonstration — the oracle pronouncing its
    own limit.

  HOW TO VERIFY.
    Paste the whole file into the official Lean 4 playground at
    https://live.lean-lang.org/ and wait for it to load. No install, no
    mathlib. Every `theorem` below should check. The `#print axioms` lines
    report, in public, exactly which adoptions each result rests on.

  HOW TO READ THE STATUS OF EACH LINE.
    [CHK]  a finitely checkable claim. Emitted as `theorem`. Lean proves it.
    [ADPT] a declared adoption. Emitted as `def`. Lean ACCEPTS it and
           certifies NOTHING by doing so — a definition has no truth value.
    The paper's tail-level thesis ("truth is unwitnessable from any state that
    could draw the distinction") is emitted as NEITHER. It appears nowhere as
    a `theorem`, because no station proves it, and nowhere as an `axiom`,
    because we refuse to assume what we are discussing. Its ABSENCE is the
    point: a file that "proved the thesis" would commit the paper's error
    inside the theorem prover.

  THE ONE ADOPTION THIS WHOLE ARTIFACT RESTS ON.
    That the Lean statements below faithfully render the informal sentences in
    their comments. No green build can close this gap — it is precisely the
    specification-adequacy residue the file is about. It is declared here, in
    the open, and it is the correct target of any refutation.
================================================================================
-/

namespace UnwitnessableVerdict

/- ============================================================================
   PART A — THE CHECKABLE KERNEL  [CHK]
   Claims the paper marks as finitely checkable. Lean proves them outright.
   ============================================================================ -/

/-- Lemma 3.2 (Verification asymmetry), the witnessed half.
    A single counterexample refutes a universal claim: refutation has a finite
    station witness. (The other half — that no finite set of instances CROWNS
    a universal — is the untyped tail, and by design it is NOT provable here.) -/
theorem refutation_is_witnessed
    {α : Type} (P : α → Prop) (a : α) (h : ¬ P a) :
    ¬ (∀ x, P x) :=
  fun hall => h (hall a)


/- ============================================================================
   PART B — THE SPECIFICATION GAP  (the centerpiece)
   Lean certifies that a derivation is valid. It does NOT certify that the
   formal statement means what the English sentence means. We exhibit theorems
   that PASS the kernel while carrying no information about their stated target.
   ============================================================================ -/

/-- The specification gap in its purest form.
    If a hypothesis H is satisfied by nothing, then `∀ x, H x → G x` holds for
    EVERY conclusion G — the kernel certifies it without G ever being examined.
    A formalization whose hypothesis is mis-scoped (true of nothing in the
    intended domain) passes VACUOUSLY and says nothing about the intended G.
    This is C* (the derivation checks) with C (the claim about the real
    objects) left entirely untouched. -/
theorem vacuous_pass
    {α : Type} (H G : α → Prop) (empty : ∀ x, ¬ H x) :
    ∀ x, H x → G x :=
  fun x hx => absurd hx (empty x)

/-  A concrete, vivid instance. "No natural number is negative" is the
    mis-scoped hypothesis. Watch: BOTH of the following pass the kernel, though
    their conclusions flatly contradict each other. The conclusion after the
    arrow is never tested — that IS the gap. A green check on either one tells
    a reader nothing about whether the intended claim holds.                  -/

/-- Passes. Says every "negative natural" equals itself. -/
theorem misscoped_says_equal :
    ∀ n : Nat, n < 0 → n = n :=
  fun n h => absurd h (Nat.not_lt_zero n)

/-- Also passes. Says every "negative natural" does NOT equal itself.
    Two contradictory "theorems," both kernel-certified, because in each the
    conclusion is vacuously reached. The build is green; the meaning is empty. -/
theorem misscoped_says_not_equal :
    ∀ n : Nat, n < 0 → n ≠ n :=
  fun n h => absurd h (Nat.not_lt_zero n)


/- ============================================================================
   PART C — BULLETPROOFING, THE DECIDABLE HEART  [CHK]
   Lemma 3.4: the outcome of a finite check is settled mechanically. That, and
   only that, is what C* asserts.
   ============================================================================ -/

/-- A finite check yields a determinate Boolean outcome. -/
def checkPasses (b : Bool) : Bool := b

/-- The outcome is settled: it is one value or the other, decided by the check
    itself, with no appeal to anything outside it. This is the exact and
    attainable sense in which C* is bulletproof. -/
theorem check_outcome_settled (b : Bool) :
    checkPasses b = true ∨ checkPasses b = false := by
  cases b
  · exact Or.inr rfl
  · exact Or.inl rfl


/- ============================================================================
   PART D — THE DISCHARGE CRITERION  [ADPT]
   Definition 7.2 is an ADOPTION, not a theorem. Emitting it as a `def` makes
   that visible: Lean accepts the definition and certifies NOTHING by doing so.
   The file does not launder a definition into a proof.
   ============================================================================ -/

/-- A premise is discharged when it does NOT occur free in the conclusion's
    warrant. This is a definition we ADOPT; accepting it proves nothing. -/
def Discharged (premiseOccursFreeInConclusion : Bool) : Prop :=
  premiseOccursFreeInConclusion = false


/- ============================================================================
   PART E — EXPOSING THE SUBSCRIPT
   `#print axioms` is the Discharge Test, automated. It reports, in public, the
   adoptions each result leans on. The checkable kernel below leans on none.
   (If anyone ever patches a proof with `sorry`, these same lines flag
   `sorryAx` — the incompleteness is exposed even though the build stays green.)
   ============================================================================ -/

#print axioms refutation_is_witnessed
#print axioms vacuous_pass
#print axioms misscoped_says_equal
#print axioms misscoped_says_not_equal
#print axioms check_outcome_settled


/- ============================================================================
   PART F — THE REFLEXIVE CAPSTONE  (comment only; deliberately not a theorem)

   Con(Lean) is unprovable in Lean. If Lean's logic is consistent, Lean cannot
   prove its own consistency — this is Gödel's second theorem pointed at the
   prover, i.e. the paper's Theorem 4.3 applied to the checker itself. The
   trust concentrated in Lean's small kernel is RISK REDUCTION on an
   unwitnessable-from-inside property, never a certificate of it. The kernel's
   soundness is adopted, not proved.

   Therefore "Lean is infallible" is false in the exact grammar the paper
   diagnoses: it applies a station observable's confidence ("this proof
   checks") to a tail predicate ("this system is sound"). Lean is a frame. It
   has maximal [CHK] power and no more. It cannot witness its own tail either —
   which is why a passing check of THIS file, and the absence within it of any
   proof of the thesis, is the most trusted available witness that witnessing
   has limits.
   ============================================================================ -/

end UnwitnessableVerdict

#check UnwitnessableVerdict.refutation_is_witnessed
#check UnwitnessableVerdict.vacuous_pass
#check UnwitnessableVerdict.misscoped_says_equal
#check UnwitnessableVerdict.misscoped_says_not_equal
#check UnwitnessableVerdict.check_outcome_settled

#eval Lean.versionString
#eval "UNWITNESSABLE_VERDICT_AUDIT_COMPLETE"

Lean 4.34.0-rc2. Zero reported errors and warnings. Source SHA-256: abd66b0e735f12b0b3ade0d993435ae964604e36a8e5f1e938401c930c48ba9d

Open this exact source in Lean

MathlibDemo.lean:1:0
No info found.
All Messages ( 182)
MathlibDemo.lean:1273:0
@collision_blocks_factorization : ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} (P : X → Y) (Q : X → Z) {x₁ x₂ : X},
  P x₁ = P x₂ → Q x₁ ≠ Q x₂ → ¬FactorsThrough P Q
MathlibDemo.lean:1274:0
@id_factors_implies_injective : ∀ {X : Type u_1} {Y : Type u_2} (P : X → Y), FactorsThrough P id → Function.Injective P
MathlibDemo.lean:1275:0
@injective_factors_all : ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [Nonempty X] (P : X → Y),
  Function.Injective P → ∀ (Q : X → Z), FactorsThrough P Q
MathlibDemo.lean:1276:0
@factorization_dichotomy : ∀ {X : Type u_1} {Y : Type u_2} [Nonempty X] (P : X → Y),
  Function.Injective P ↔ FactorsThrough P id
MathlibDemo.lean:1277:0
@not_injective_iff_collision : ∀ {X : Type u_1} {Y : Type u_2} (P : X → Y),
  ¬Function.Injective P ↔ ∃ x₁ x₂, P x₁ = P x₂ ∧ x₁ ≠ x₂
MathlibDemo.lean:1278:0
@scope_retained_is_recoverable : ∀ {P : Type u_1} {S : Type u_2},
  FactorsThrough (fun c ↦ (c.prop, c.scope)) fun c ↦ c.scope
MathlibDemo.lean:1279:0
@scope_forgotten_is_not_recoverable : ∀ {P : Type u_1} {S : Type u_2} (p : P) {s₁ s₂ : S},
  s₁ ≠ s₂ → ¬FactorsThrough (fun c ↦ c.prop) fun c ↦ c.scope
MathlibDemo.lean:1280:0
only_error_retracts : ∀ (k : SuccessorKind), RetractsFormalResult k = true ↔ k = SuccessorKind.error
MathlibDemo.lean:1281:0
warrant_lapse_does_not_retract : RetractsFormalResult SuccessorKind.warrantLapse = false
MathlibDemo.lean:1282:0
@criterion_sides_exhaustive : ∀ {X : Type u_1} (c : X → Bool) (x : X), SelfSide c x ∨ OtherSide c x
MathlibDemo.lean:1283:0
@criterion_sides_exclusive : ∀ {X : Type u_1} (c : X → Bool) (x : X), ¬(SelfSide c x ∧ OtherSide c x)
MathlibDemo.lean:1284:0
@double_exclusion_is_double_negation : ∀ {X : Type u_1} (P : X → Prop) (x : X), ExcludedBy (ExcludedBy P) x ↔ ¬¬P x
MathlibDemo.lean:1285:0
@double_exclusion_collapse : ∀ {X : Type u_1} (P : X → Prop) (x : X), ExcludedBy (ExcludedBy P) x ↔ P x
MathlibDemo.lean:1286:0
@binary_criterion_has_collision : ∀ {X : Type u_1} [inst : Fintype X] (c : X → Bool),
  2 < Fintype.card X → ∃ x₁ x₂, c x₁ = c x₂ ∧ x₁ ≠ x₂
MathlibDemo.lean:1287:0
@binary_criterion_not_faithful : ∀ {X : Type u_1} [inst : Fintype X] (c : X → Bool),
  2 < Fintype.card X → ¬FactorsThrough c id
MathlibDemo.lean:1288:0
absolute_with_both_rules_is_identity : ∀ (A : Prop → Prop), (∀ (p : Prop), p → A p) → (∀ (p : Prop), A p → p) → A = id
MathlibDemo.lean:1289:0
@complement_requirement_blocks_absolute_priority : ∀ {C : Type u_1} (Priority UsesComplement : C → Prop),
  (∀ (c : C), Priority c → UsesComplement c) → ¬∃ c, AbsolutePriority Priority UsesComplement c
MathlibDemo.lean:1290:0
@no_first_position_cyclic : ∀ {n : ℕ} [inst : NeZero n] {Claim : Type u_1} (R : ResourceChain n Claim) (i : Fin n),
  ¬∃ c, AbsolutePriorityAt R i c
MathlibDemo.lean:1291:0
@preserves_and : ∀ {A : Type u_1} {B : Type u_2} (f : A → B) (P₁ P₂ : A → Prop) (Q₁ Q₂ : B → Prop),
  PreservesPredicate f P₁ Q₁ →
    PreservesPredicate f P₂ Q₂ → PreservesPredicate f (fun a ↦ P₁ a ∧ P₂ a) fun b ↦ Q₁ b ∧ Q₂ b
MathlibDemo.lean:1292:0
@preserves_or : ∀ {A : Type u_1} {B : Type u_2} (f : A → B) (P₁ P₂ : A → Prop) (Q₁ Q₂ : B → Prop),
  PreservesPredicate f P₁ Q₁ →
    PreservesPredicate f P₂ Q₂ → PreservesPredicate f (fun a ↦ P₁ a ∨ P₂ a) fun b ↦ Q₁ b ∨ Q₂ b
MathlibDemo.lean:1293:0
@preserves_not : ∀ {A : Type u_1} {B : Type u_2} (f : A → B) (P : A → Prop) (Q : B → Prop),
  PreservesPredicate f P Q → PreservesPredicate f (fun a ↦ ¬P a) fun b ↦ ¬Q b
MathlibDemo.lean:1294:0
@preserves_imp : ∀ {A : Type u_1} {B : Type u_2} (f : A → B) (P₁ P₂ : A → Prop) (Q₁ Q₂ : B → Prop),
  PreservesPredicate f P₁ Q₁ →
    PreservesPredicate f P₂ Q₂ → PreservesPredicate f (fun a ↦ P₁ a → P₂ a) fun b ↦ Q₁ b → Q₂ b
MathlibDemo.lean:1295:0
@preserved_predicate_agrees_despite_noncommutation : ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} (AB : A → B)
  (BC : B → C) (AC : A → C) (P : A → Prop) (Q : B → Prop) (R : C → Prop),
  PreservesPredicate AB P Q →
    PreservesPredicate BC Q R → PreservesPredicate AC P R → ∀ (a : A), R (AC a) ↔ R (BC (AB a))
MathlibDemo.lean:1296:0
@finite_budget_forces_tradeoff_n : ∀ {ι : Type u_1} (s : Finset ι) (cost alloc : ι → ℕ),
  ∀ budget < ∑ i ∈ s, cost i, ∑ i ∈ s, alloc i ≤ budget → (∀ i ∈ s, cost i ≤ alloc i) → False
MathlibDemo.lean:1297:0
finite_metadata_leaves_freedom : ∀ (s : Finset ℕ), ∃ I₀ I₁, (∀ n ∈ s, I₀ n = I₁ n) ∧ I₀ ≠ I₁
MathlibDemo.lean:1298:0
nat_cost_registry_attains_minimum : ∀ (S : Set ℕ) (cost : ℕ → ℕ), (∃ x, x ∈ S) → ∃ x ∈ S, ∀ y ∈ S, cost x ≤ cost y
MathlibDemo.lean:1299:0
@gaps_determine_up_to_shift : ∀ {I : Type u_1} (E F : I → ℝ) (i₀ : I),
  (∀ (i j : I), E i - E j = F i - F j) → ∀ (i : I), F i = E i + (F i₀ - E i₀)
MathlibDemo.lean:1300:0
@affine_calibration_unique : ∀ {I : Type u_1} (E : I → ℝ) (a a' b b' : ℝ) (i j : I),
  E i ≠ E j → (∀ (k : I), a * E k + b = a' * E k + b') → a = a' ∧ b = b'
MathlibDemo.lean:1301:0
distinct_count_parity : ∀ (g : ℕ), (g + g.gcd 2) / 2 = g / 2 + 1
MathlibDemo.lean:1302:0
boost_preserves_time_orientation : ∀ (g b T x : ℝ),
  0 < g → -1 < b → b < 1 → x ^ 2 < T ^ 2 → 0 < T → 0 < boostTime g b T x
MathlibDemo.lean:1303:0
boost_normalization_composes : ∀ (b₁ b₂ b g₁ g₂ g : ℝ),
  g₁ ^ 2 * (1 - b₁ ^ 2) = 1 →
    g₂ ^ 2 * (1 - b₂ ^ 2) = 1 → b * (1 + b₁ * b₂) = b₁ + b₂ → g = g₁ * g₂ * (1 + b₁ * b₂) → g ^ 2 * (1 - b ^ 2) = 1
MathlibDemo.lean:1304:0
planck_rescaling_rigid : ∀ (c h G L U M : ℝ),
  c ≠ 0 →
    h ≠ 0 →
      G ≠ 0 →
        0 < L →
          0 < U → 0 < M → c * U = c * L → h * U = h * (L ^ 2 * M) → G * U ^ 2 * M = G * L ^ 3 → L = 1 ∧ U = 1 ∧ M = 1
MathlibDemo.lean:1305:0
no_first_position_premises_necessary : ∃ Priority UsesComplement c, AbsolutePriority Priority UsesComplement c
MathlibDemo.lean:1306:0
lorentz_normalization_necessary : ∃ g b T x, interval (boostTime g b T x) (boostSpace g b T x) ≠ interval T x
MathlibDemo.lean:1307:0
budget_demand_hypothesis_necessary : ∃ costA costB allocA allocB budget,
  ¬budget < costA + costB ∧ allocA + allocB ≤ budget ∧ costA ≤ allocA ∧ costB ≤ allocB
MathlibDemo.lean:1308:0
nontriviality_hypothesis_necessary : ∃ c, ¬∃ x, SelfSide c x
MathlibDemo.lean:1309:0
velocity_bound_necessary : ∃ g b T x, 0 < g ∧ 0 < T ∧ x ^ 2 < T ^ 2 ∧ boostTime g b T x < 0
MathlibDemo.lean:1310:0
E09_nonzero_hypothesis_redundant : ∀ (z : ℂ), z ≠ z⁻¹ → z ≠ 0
MathlibDemo.lean:1311:0
P07_length_hypothesis_redundant : ∀ (c L U : ℝ), c ≠ 0 → c * U / L = c → L ≠ 0
MathlibDemo.lean:1312:0
E15_first_conjunct_is_contentless : ∀ (x : ℝ), 0 < x → 0 < x
MathlibDemo.lean:1313:0
@priority_claim_uses_individuation : ∀ {R : Type u_1} (c : PriorityClaim R), UsesIndividuation c
MathlibDemo.lean:1314:0
@priority_claim_uses_directed_order : ∀ {R : Type u_1} (c : PriorityClaim R), UsesDirectedOrder c
MathlibDemo.lean:1315:0
assertion_bridge_nonvacuous : (∃ c, assertionBridge.SpaceFirst c) ∧ ∃ c, assertionBridge.TimeFirst c
MathlibDemo.lean:1316:0
no_first_position_assertion_reading : (¬∃ c,
      AbsolutePriority assertionBridge.SpaceFirst assertionBridge.UsesTemporalResource c) ∧
  ¬∃ c, AbsolutePriority assertionBridge.TimeFirst assertionBridge.UsesSpatialResource c
MathlibDemo.lean:1317:0
timelike_not_time_only : ¬∃ P, ∀ (T x : ℝ), P T ↔ interval T x < 0
MathlibDemo.lean:1318:0
timelike_not_space_only : ¬∃ P, ∀ (T x : ℝ), P x ↔ interval T x < 0
MathlibDemo.lean:1319:0
taxonomy_encoding_is_lossy : ¬FactorsThrough RetractsFormalResult id
MathlibDemo.lean:1320:0
planck_two_constants_insufficient : ∀ (c h : ℝ),
  ∃ L U M, 0 < L ∧ 0 < U ∧ 0 < M ∧ ¬(L = 1 ∧ U = 1 ∧ M = 1) ∧ c * U = c * L ∧ h * U = h * (L ^ 2 * M)
MathlibDemo.lean:1321:0
spectral_read_inversion_invariant : ∀ (z : ℂ), spectralRead z⁻¹ = spectralRead z
MathlibDemo.lean:1322:0
spectral_fibre_at_most_pair : ∀ (z w : ℂ), z ≠ 0 → w ≠ 0 → spectralRead z = spectralRead w → w = z ∨ w = z⁻¹
MathlibDemo.lean:1323:0
spectral_fibre_singleton_iff : ∀ (z : ℂ), z ≠ 0 → (z = z⁻¹ ↔ z ^ 2 = 1)
MathlibDemo.lean:1324:0
@cardinality_forces_collision : ∀ {X : Type u_1} {Y : Type u_2} [inst : Fintype X] [inst_1 : Fintype Y] (c : X → Y),
  Fintype.card Y < Fintype.card X → ∃ x₁ x₂, c x₁ = c x₂ ∧ x₁ ≠ x₂
MathlibDemo.lean:1325:0
@cardinality_forces_unfaithfulness : ∀ {X : Type u_1} {Y : Type u_2} [inst : Fintype X] [inst_1 : Fintype Y]
  (c : X → Y), Fintype.card Y < Fintype.card X → ¬FactorsThrough c id
MathlibDemo.lean:1326:0
@kary_criterion_has_collision : ∀ {X : Type u_1} [inst : Fintype X] {k : ℕ} (c : X → Fin k),
  k < Fintype.card X → ∃ x₁ x₂, c x₁ = c x₂ ∧ x₁ ≠ x₂
MathlibDemo.lean:1327:0
@kary_criterion_not_faithful : ∀ {X : Type u_1} [inst : Fintype X] {k : ℕ} (c : X → Fin k),
  k < Fintype.card X → ¬FactorsThrough c id
MathlibDemo.lean:1328:0
@residue_monotone : ∀ {A : Type u_1} (S T : Set A) (cost : A → ENNReal),
  S ⊆ T → indexedResidue T cost ≤ indexedResidue S cost
MathlibDemo.lean:1329:0
conservative_expansion_can_lower_cost_strictly : ∃ R0 R1 cost conclusion expand,
  R0 ⊆ R1 ∧
    (∀ p ∈ R1, expand p ∈ R0 ∧ conclusion (expand p) = conclusion p) ∧
      (∀ (target : Unit), (∃ p ∈ R0, conclusion p = target) ↔ ∃ p ∈ R1, conclusion p = target) ∧
        indexedResidue R1 cost < indexedResidue R0 cost
MathlibDemo.lean:1330:0
conservative_expansion_need_not_lower_cost : ∃ R0 R1 cost, R0 ⊆ R1 ∧ indexedResidue R1 cost = indexedResidue R0 cost
MathlibDemo.lean:1331:0
dichotomy_nonemptiness_necessary : ∃ P, Function.Injective P ∧ ¬FactorsThrough P id
MathlibDemo.lean:1332:0
@no_first_position_without_B03_is_trivial : ∀ {R : Type u_1},
  (¬∃ c, UsesDirectedOrder c ∧ ¬UsesDirectedOrder c) ∧ ¬∃ c, UsesIndividuation c ∧ ¬UsesIndividuation c
MathlibDemo.lean:1333:0
@gaps_determine_up_to_shift_ring : ∀ {K : Type u_1} [inst : CommRing K] {I : Type u_2} (E F : I → K) (i₀ : I),
  (∀ (i j : I), E i - E j = F i - F j) → ∀ (i : I), F i = E i + (F i₀ - E i₀)
MathlibDemo.lean:1334:0
@affine_calibration_unique_field : ∀ {K : Type u_1} [inst : Field K] {I : Type u_2} (E : I → K) (a a' b b' : K)
  (i j : I), E i ≠ E j → (∀ (k : I), a * E k + b = a' * E k + b') → a = a' ∧ b = b'
MathlibDemo.lean:1335:0
straw_man_leaves_claim_standing : ∃ c cPlus, (cPlus → c) ∧ ¬cPlus ∧ c
MathlibDemo.lean:1336:0
motte_bailey_does_not_establish_claim : ∃ c cMinus, (c → cMinus) ∧ cMinus ∧ ¬c
MathlibDemo.lean:1337:0
@critique_validity_does_not_recover_target : ∀ {Claim : Type u_1} {c₁ c₂ : Claim},
  c₁ ≠ c₂ → ¬FactorsThrough (fun k ↦ k.valid) fun k ↦ k.target
MathlibDemo.lean:1338:0
@critique_is_pharmakon : ∀ {Claim : Type u_1} {c₁ c₂ : Claim},
  c₁ ≠ c₂ → (FactorsThrough (fun k ↦ k.valid) fun k ↦ k.valid) ∧ ¬FactorsThrough (fun k ↦ k.valid) fun k ↦ k.target
MathlibDemo.lean:1339:0
@residual_selection : ∀ {J : Type u_1} {S : Type u_2} (Admissible : J → Prop) (outcome : J → S) {j₁ j₂ : J},
  Admissible j₁ → Admissible j₂ → outcome j₁ ≠ outcome j₂ → ¬UniqueOutcome Admissible outcome
MathlibDemo.lean:1340:0
@competing_verifiers_defeat_unique_outcome : ∀ {Basis : Type u_1} {Claim : Type u_2}
  (Admissible : Verifier Basis Claim → Prop) (c : Claim) {v₁ v₂ : Verifier Basis Claim},
  Admissible v₁ → Admissible v₂ → v₁.verdict c ≠ v₂.verdict c → ¬UniqueOutcome Admissible fun v ↦ v.verdict c
MathlibDemo.lean:1341:0
@delegation_preserves_residual_will : ∀ {Basis : Type u_1} {Claim : Type u_2} (Admissible : Verifier Basis Claim → Prop)
  (c : Claim) {chosen v₂ : Verifier Basis Claim},
  Admissible chosen →
    Admissible v₂ → chosen.verdict c ≠ v₂.verdict c → ResidualWill Admissible (fun v ↦ v.verdict c) chosen
MathlibDemo.lean:1342:0
@certificate_does_not_recover_basis : ∀ {Basis : Type u_1} {Claim : Type u_2} {b₁ b₂ : Basis},
  b₁ ≠ b₂ → ∀ (f : Claim → Bool), ¬FactorsThrough (fun v ↦ certificateLabel v) fun v ↦ v.basis
MathlibDemo.lean:1343:0
@discharge_does_not_reduce_adoptions : ∀ {α : Type u_1} [inst : DecidableEq α] (S : Finset α) (b p : α),
  b ∈ S → p ∉ S → (insert p (S.erase b)).card = S.card
MathlibDemo.lean:1344:0
@symmetry_blocks_recovery : ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} (P : X → Y) (Q : X → Z) (σ : X → X),
  (∀ (x : X), P (σ x) = P x) → ∀ {x₀ : X}, Q (σ x₀) ≠ Q x₀ → ¬FactorsThrough P Q
MathlibDemo.lean:1345:0
@exchange_invariant_readout_loses_priority : ∀ {R : Type u_1} {Y : Type u_2} (P : PriorityClaim R → Y),
  (∀ (c : PriorityClaim R), P (exchangeRelata c) = P c) → ∀ (c₀ : PriorityClaim R), ¬FactorsThrough P fun c ↦ c.prior
MathlibDemo.lean:1346:0
@equal_criteria_forces_equal_verdict : ∀ {C : Type u_1} (criteria : C → DeclaredCriteria) (verdict : C → Bool),
  FairStandard criteria verdict → ∀ {c₁ c₂ : C}, criteria c₁ = criteria c₂ → verdict c₁ = verdict c₂
MathlibDemo.lean:1347:0
@differing_verdicts_defeat_fairness : ∀ {C : Type u_1} (criteria : C → DeclaredCriteria) (verdict : C → Bool)
  {c₁ c₂ : C}, criteria c₁ = criteria c₂ → verdict c₁ ≠ verdict c₂ → ¬FairStandard criteria verdict
MathlibDemo.lean:1348:0
@equal_standard_trichotomy : ∀ {C : Type u_1} (criteria : C → DeclaredCriteria) (verdict : C → Bool) (c₁ c₂ : C),
  criteria c₁ = criteria c₂ →
    verdict c₁ = true ∧ verdict c₂ = true ∨ verdict c₁ = false ∧ verdict c₂ = false ∨ ¬FairStandard criteria verdict
MathlibDemo.lean:1349:0
singularity_term_shared : publicTerm SingularityReading.forcedAdmitted = publicTerm SingularityReading.forcingMustVanish
MathlibDemo.lean:1350:0
singularity_readings_incompatible : publicTerm SingularityReading.forcedAdmitted =
    publicTerm SingularityReading.forcingMustVanish ∧
  requiresZeroForcing SingularityReading.forcedAdmitted ≠ requiresZeroForcing SingularityReading.forcingMustVanish
MathlibDemo.lean:1351:0
singularity_term_does_not_recover_reading : ¬FactorsThrough publicTerm requiresZeroForcing
MathlibDemo.lean:1352:0
certification_does_not_separate_readings : ∀ (report : SingularityReading → String),
  (∀ (r : SingularityReading), report r = publicTerm r) → ¬FactorsThrough report requiresZeroForcing
MathlibDemo.lean:1353:0
same_structure_same_verdict : ∀ (structureOf : BlowupClaim → BlowupClaim) (verdict : BlowupClaim → Bool),
  FactorsThrough structureOf verdict →
    ∀ {c₁ c₂ : BlowupClaim}, structureOf c₁ = structureOf c₂ → verdict c₁ = verdict c₂
MathlibDemo.lean:1354:0
parity_on_shared_fields : ∀ (verdict : BlowupClaim → Bool),
  FactorsThrough (fun c ↦ (c.familyDeclared, c.witnessExhibited, c.estimatesClose)) verdict →
    ∀ {c₁ c₂ : BlowupClaim},
      c₁.familyDeclared = c₂.familyDeclared →
        c₁.witnessExhibited = c₂.witnessExhibited → c₁.estimatesClose = c₂.estimatesClose → verdict c₁ = verdict c₂
MathlibDemo.lean:1355:0
claims_agree_off_forcing : claimA.familyDeclared = claimB.familyDeclared ∧
  claimA.witnessExhibited = claimB.witnessExhibited ∧
    claimA.estimatesClose = claimB.estimatesClose ∧ claimA.forcingAdmitted ≠ claimB.forcingAdmitted
MathlibDemo.lean:1356:0
parity_forced : ∀ (verdict : BlowupClaim → Bool),
  FactorsThrough (fun c ↦ (c.familyDeclared, c.witnessExhibited, c.estimatesClose)) verdict →
    verdict claimA = verdict claimB
MathlibDemo.lean:1357:0
alternatives_distinct : ClayAlternative.AB_unforced ≠ ClayAlternative.CD_forced
MathlibDemo.lean:1358:0
forced_claim_establishes_only_CD : ∀ (c : BlowupClaim),
  c.forcingAdmitted = true → alternativeOf c = ClayAlternative.CD_forced ∧ alternativeOf c ≠ ClayAlternative.AB_unforced
MathlibDemo.lean:1359:0
headline_does_not_recover_alternative : ¬FactorsThrough headline fun a ↦ a
MathlibDemo.lean:1360:0
priority_of_public_claim : datedA.day < datedB.day
MathlibDemo.lean:1361:0
verdict_does_not_recover_priority : ∀ (verdict : DatedClaim → Bool),
  (∀ (d : DatedClaim), verdict d = true) → ¬FactorsThrough verdict fun d ↦ d.day
MathlibDemo.lean:1363:0
'LambdaIII.collision_blocks_factorization' does not depend on any axioms
MathlibDemo.lean:1364:0
'LambdaIII.id_factors_implies_injective' does not depend on any axioms
MathlibDemo.lean:1365:0
'LambdaIII.injective_factors_all' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1366:0
'LambdaIII.factorization_dichotomy' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1367:0
'LambdaIII.not_injective_iff_collision' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1368:0
'LambdaIII.scope_retained_is_recoverable' does not depend on any axioms
MathlibDemo.lean:1369:0
'LambdaIII.scope_forgotten_is_not_recoverable' does not depend on any axioms
MathlibDemo.lean:1370:0
'LambdaIII.only_error_retracts' depends on axioms: [propext]
MathlibDemo.lean:1371:0
'LambdaIII.warrant_lapse_does_not_retract' depends on axioms: [propext]
MathlibDemo.lean:1372:0
'LambdaIII.criterion_sides_exhaustive' does not depend on any axioms
MathlibDemo.lean:1373:0
'LambdaIII.criterion_sides_exclusive' does not depend on any axioms
MathlibDemo.lean:1374:0
'LambdaIII.double_exclusion_is_double_negation' does not depend on any axioms
MathlibDemo.lean:1375:0
'LambdaIII.double_exclusion_collapse' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1376:0
'LambdaIII.binary_criterion_has_collision' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1377:0
'LambdaIII.binary_criterion_not_faithful' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1378:0
'LambdaIII.absolute_with_both_rules_is_identity' depends on axioms: [propext, Quot.sound]
MathlibDemo.lean:1379:0
'LambdaIII.complement_requirement_blocks_absolute_priority' does not depend on any axioms
MathlibDemo.lean:1380:0
'LambdaIII.no_first_position_cyclic' depends on axioms: [propext]
MathlibDemo.lean:1381:0
'LambdaIII.preserves_and' does not depend on any axioms
MathlibDemo.lean:1382:0
'LambdaIII.preserves_or' does not depend on any axioms
MathlibDemo.lean:1383:0
'LambdaIII.preserves_not' does not depend on any axioms
MathlibDemo.lean:1384:0
'LambdaIII.preserves_imp' does not depend on any axioms
MathlibDemo.lean:1385:0
'LambdaIII.preserved_predicate_agrees_despite_noncommutation' does not depend on any axioms
MathlibDemo.lean:1386:0
'LambdaIII.finite_budget_forces_tradeoff_n' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1387:0
'LambdaIII.finite_metadata_leaves_freedom' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1388:0
'LambdaIII.nat_cost_registry_attains_minimum' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1389:0
'LambdaIII.gaps_determine_up_to_shift' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1390:0
'LambdaIII.affine_calibration_unique' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1391:0
'LambdaIII.distinct_count_parity' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1392:0
'LambdaIII.boost_preserves_time_orientation' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1393:0
'LambdaIII.boost_normalization_composes' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1394:0
'LambdaIII.planck_rescaling_rigid' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1395:0
'LambdaIII.no_first_position_premises_necessary' does not depend on any axioms
MathlibDemo.lean:1396:0
'LambdaIII.lorentz_normalization_necessary' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1397:0
'LambdaIII.budget_demand_hypothesis_necessary' depends on axioms: [propext, Quot.sound]
MathlibDemo.lean:1398:0
'LambdaIII.nontriviality_hypothesis_necessary' depends on axioms: [propext]
MathlibDemo.lean:1399:0
'LambdaIII.velocity_bound_necessary' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1400:0
'LambdaIII.E09_nonzero_hypothesis_redundant' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1401:0
'LambdaIII.P07_length_hypothesis_redundant' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1402:0
'LambdaIII.E15_first_conjunct_is_contentless' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1403:0
'LambdaIII.priority_claim_uses_individuation' does not depend on any axioms
MathlibDemo.lean:1404:0
'LambdaIII.priority_claim_uses_directed_order' does not depend on any axioms
MathlibDemo.lean:1405:0
'LambdaIII.assertion_bridge_nonvacuous' does not depend on any axioms
MathlibDemo.lean:1406:0
'LambdaIII.no_first_position_assertion_reading' does not depend on any axioms
MathlibDemo.lean:1407:0
'LambdaIII.timelike_not_time_only' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1408:0
'LambdaIII.timelike_not_space_only' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1409:0
'LambdaIII.taxonomy_encoding_is_lossy' depends on axioms: [propext]
MathlibDemo.lean:1410:0
'LambdaIII.planck_two_constants_insufficient' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1411:0
'LambdaIII.spectral_read_inversion_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1412:0
'LambdaIII.spectral_fibre_at_most_pair' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1413:0
'LambdaIII.spectral_fibre_singleton_iff' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1414:0
'LambdaIII.cardinality_forces_collision' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1415:0
'LambdaIII.cardinality_forces_unfaithfulness' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1416:0
'LambdaIII.kary_criterion_has_collision' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1417:0
'LambdaIII.kary_criterion_not_faithful' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1418:0
'LambdaIII.residue_monotone' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1419:0
'LambdaIII.conservative_expansion_can_lower_cost_strictly' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1420:0
'LambdaIII.conservative_expansion_need_not_lower_cost' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1421:0
'LambdaIII.dichotomy_nonemptiness_necessary' does not depend on any axioms
MathlibDemo.lean:1422:0
'LambdaIII.no_first_position_without_B03_is_trivial' does not depend on any axioms
MathlibDemo.lean:1423:0
'LambdaIII.gaps_determine_up_to_shift_ring' depends on axioms: [propext]
MathlibDemo.lean:1424:0
'LambdaIII.affine_calibration_unique_field' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1425:0
'LambdaIII.straw_man_leaves_claim_standing' does not depend on any axioms
MathlibDemo.lean:1426:0
'LambdaIII.motte_bailey_does_not_establish_claim' does not depend on any axioms
MathlibDemo.lean:1427:0
'LambdaIII.critique_validity_does_not_recover_target' does not depend on any axioms
MathlibDemo.lean:1428:0
'LambdaIII.critique_is_pharmakon' does not depend on any axioms
MathlibDemo.lean:1429:0
'LambdaIII.residual_selection' does not depend on any axioms
MathlibDemo.lean:1430:0
'LambdaIII.competing_verifiers_defeat_unique_outcome' does not depend on any axioms
MathlibDemo.lean:1431:0
'LambdaIII.delegation_preserves_residual_will' does not depend on any axioms
MathlibDemo.lean:1432:0
'LambdaIII.certificate_does_not_recover_basis' does not depend on any axioms
MathlibDemo.lean:1433:0
'LambdaIII.discharge_does_not_reduce_adoptions' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1434:0
'LambdaIII.symmetry_blocks_recovery' does not depend on any axioms
MathlibDemo.lean:1435:0
'LambdaIII.exchange_invariant_readout_loses_priority' does not depend on any axioms
MathlibDemo.lean:1436:0
'LambdaIII.equal_criteria_forces_equal_verdict' does not depend on any axioms
MathlibDemo.lean:1437:0
'LambdaIII.differing_verdicts_defeat_fairness' does not depend on any axioms
MathlibDemo.lean:1438:0
'LambdaIII.equal_standard_trichotomy' does not depend on any axioms
MathlibDemo.lean:1439:0
'LambdaIII.singularity_term_shared' does not depend on any axioms
MathlibDemo.lean:1440:0
'LambdaIII.singularity_readings_incompatible' does not depend on any axioms
MathlibDemo.lean:1441:0
'LambdaIII.singularity_term_does_not_recover_reading' does not depend on any axioms
MathlibDemo.lean:1442:0
'LambdaIII.certification_does_not_separate_readings' depends on axioms: [Quot.sound]
MathlibDemo.lean:1443:0
'LambdaIII.same_structure_same_verdict' does not depend on any axioms
MathlibDemo.lean:1444:0
'LambdaIII.parity_on_shared_fields' does not depend on any axioms
MathlibDemo.lean:1445:0
'LambdaIII.claims_agree_off_forcing' does not depend on any axioms
MathlibDemo.lean:1446:0
'LambdaIII.parity_forced' does not depend on any axioms
MathlibDemo.lean:1447:0
'LambdaIII.alternatives_distinct' does not depend on any axioms
MathlibDemo.lean:1448:0
'LambdaIII.forced_claim_establishes_only_CD' depends on axioms: [propext]
MathlibDemo.lean:1449:0
'LambdaIII.headline_does_not_recover_alternative' does not depend on any axioms
MathlibDemo.lean:1450:0
'LambdaIII.priority_of_public_claim' does not depend on any axioms
MathlibDemo.lean:1451:0
'LambdaIII.verdict_does_not_recover_priority' does not depend on any axioms
MathlibDemo.lean:1453:0
"4.34.0-rc2"
MathlibDemo.lean:1454:0
"LAMBDA_PART_III_SUCCESSOR_R1"
MathlibDemo.lean:1458:0
"4.34.0-rc2"
MathlibDemo.lean:1459:0
"LAMBDA_R4_PARTIII_END"
Restart File

Lean 4.34.0-rc2. Zero reported errors and warnings. Source SHA-256: ef128d5e67a2e80d086fe83ede585149eadb28ba69a1000832b3db7967c02850

Open this exact source in Lean

MathlibDemo.lean:1:0
No info found.
All Messages ( 259)
MathlibDemo.lean:464:0
LambdaInstrument.recovery_iff_fibre_constancy.{u_1, u_2, u_3} {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [Nonempty Z]
  (read : X → Y) (target : X → Z) :
  LambdaInstrument.Recoverable read target ↔ ∀ (x y : X), read x = read y → target x = target y
MathlibDemo.lean:465:0
'LambdaInstrument.recovery_iff_fibre_constancy' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:466:0
LambdaInstrument.collision_blocks_recovery.{u_1, u_2, u_3} {X : Type u_1} {Y : Type u_2} {Z : Type u_3} (read : X → Y)
  (target : X → Z) {a b : X} (same : read a = read b) (split : target a ≠ target b) :
  ¬LambdaInstrument.Recoverable read target
MathlibDemo.lean:467:0
'LambdaInstrument.collision_blocks_recovery' does not depend on any axioms
MathlibDemo.lean:468:0
LambdaInstrument.postprocessing_preserves_collision.{u_1, u_2, u_3} {X : Type u_1} {Y : Type u_2} {Z : Type u_3}
  (read : X → Y) (post : Y → Z) {a b : X} (h : read a = read b) : post (read a) = post (read b)
MathlibDemo.lean:469:0
'LambdaInstrument.postprocessing_preserves_collision' does not depend on any axioms
MathlibDemo.lean:470:0
LambdaInstrument.enriched_readout_recovers_target.{u_1, u_2, u_3} {X : Type u_1} {Y : Type u_2} {Z : Type u_3}
  (read : X → Y) (target : X → Z) : LambdaInstrument.Recoverable (fun x ↦ (read x, target x)) target
MathlibDemo.lean:471:0
'LambdaInstrument.enriched_readout_recovers_target' does not depend on any axioms
MathlibDemo.lean:472:0
LambdaInstrument.one_sided_certificate_contract.{u_1, u_2} {X : Type u_1} {Y : Type u_2} (read : X → Y)
  (fires : Y → Prop) (target : X → Prop) :
  (∀ (x : X), fires (read x) → target x) ↔ {x | fires (read x)} ⊆ {x | target x}
MathlibDemo.lean:473:0
'LambdaInstrument.one_sided_certificate_contract' does not depend on any axioms
MathlibDemo.lean:474:0
LambdaInstrument.entailed_condition_preserves_acceptance.{u_1} {X : Type u_1} (accept condition : X → Prop)
  (h : ∀ (x : X), accept x → condition x) (x : X) : accept x ∧ condition x ↔ accept x
MathlibDemo.lean:475:0
'LambdaInstrument.entailed_condition_preserves_acceptance' does not depend on any axioms
MathlibDemo.lean:476:0
LambdaInstrument.new_condition_changes_acceptance.{u_1} {X : Type u_1} (accept condition : X → Prop) {x : X}
  (ha : accept x) (hc : ¬condition x) : ¬∀ (y : X), accept y ∧ condition y ↔ accept y
MathlibDemo.lean:477:0
'LambdaInstrument.new_condition_changes_acceptance' does not depend on any axioms
MathlibDemo.lean:478:0
LambdaInstrument.equal_declared_inputs_equal_outputs.{u_1, u_2, u_3} {X : Type u_1} {Y : Type u_2} {Z : Type u_3}
  (read : X → Y) (judge : X → Z) (h : LambdaInstrument.Recoverable read judge) {a b : X} (same : read a = read b) :
  judge a = judge b
MathlibDemo.lean:479:0
'LambdaInstrument.equal_declared_inputs_equal_outputs' does not depend on any axioms
MathlibDemo.lean:480:0
LambdaInstrument.different_outputs_require_distinction.{u_1, u_2, u_3} {X : Type u_1} {Y : Type u_2} {Z : Type u_3}
  (read : X → Y) (judge : X → Z) (h : LambdaInstrument.Recoverable read judge) {a b : X} (split : judge a ≠ judge b) :
  read a ≠ read b
MathlibDemo.lean:481:0
'LambdaInstrument.different_outputs_require_distinction' does not depend on any axioms
MathlibDemo.lean:482:0
LambdaInstrument.no_refutation_is_not_a_general_proof :
  ¬∀ (certified : Prop → Prop) (P : Prop), (∀ (Q : Prop), certified Q → Q) → ¬certified ¬P → P
MathlibDemo.lean:483:0
'LambdaInstrument.no_refutation_is_not_a_general_proof' does not depend on any axioms
MathlibDemo.lean:484:0
LambdaInstrument.completeness_licenses_reversal (certified : Prop → Prop) (P : Prop)
  (completeAtNegation : ¬P → certified ¬P) (noRefutation : ¬certified ¬P) : P
MathlibDemo.lean:485:0
'LambdaInstrument.completeness_licenses_reversal' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:486:0
LambdaInstrument.existential_claim_needs_no_closed_form.{u_1} {X : Type u_1} (P : X → Prop) (construction : ∃ x, P x) :
  ¬∀ (x : X), ¬P x
MathlibDemo.lean:487:0
'LambdaInstrument.existential_claim_needs_no_closed_form' does not depend on any axioms
MathlibDemo.lean:488:0
LambdaInstrument.residual_equation_has_witness.{u_1, u_2} {X : Type u_1} {F : Type u_2} (residual : X → F) (x : X) :
  ∃ f, f = residual x
MathlibDemo.lean:489:0
'LambdaInstrument.residual_equation_has_witness' does not depend on any axioms
MathlibDemo.lean:490:0
LambdaInstrument.residual_admissibility_is_the_obligation.{u_1, u_2} {X : Type u_1} {F : Type u_2} (residual : X → F)
  (admitted : F → Prop) (x : X) : (∃ f, f = residual x ∧ admitted f) ↔ admitted (residual x)
MathlibDemo.lean:491:0
'LambdaInstrument.residual_admissibility_is_the_obligation' does not depend on any axioms
MathlibDemo.lean:492:0
LambdaInstrument.finite_window_has_opposite_extensions (N : ℕ) :
  ∃ good bad,
    LambdaInstrument.Window N good ∧
      LambdaInstrument.Window N bad ∧ LambdaInstrument.AllStages good ∧ ¬LambdaInstrument.AllStages bad
MathlibDemo.lean:493:0
'LambdaInstrument.finite_window_has_opposite_extensions' does not depend on any axioms
MathlibDemo.lean:494:0
LambdaInstrument.no_fixed_window_decides_unrestricted_tail (N : ℕ) :
  ¬∀ (P : ℕ → Prop), LambdaInstrument.Window N P → LambdaInstrument.AllStages P
MathlibDemo.lean:495:0
'LambdaInstrument.no_fixed_window_decides_unrestricted_tail' does not depend on any axioms
MathlibDemo.lean:496:0
LambdaInstrument.universal_proof_closes_all_windows (P : ℕ → Prop) (h : LambdaInstrument.AllStages P) (N : ℕ) :
  LambdaInstrument.Window N P
MathlibDemo.lean:497:0
'LambdaInstrument.universal_proof_closes_all_windows' does not depend on any axioms
MathlibDemo.lean:498:0
LambdaInstrument.all_windows_iff_all_stages (P : ℕ → Prop) :
  (∀ (N : ℕ), LambdaInstrument.Window N P) ↔ LambdaInstrument.AllStages P
MathlibDemo.lean:499:0
'LambdaInstrument.all_windows_iff_all_stages' does not depend on any axioms
MathlibDemo.lean:500:0
LambdaInstrument.actual_failure_refutes_tail (P : ℕ → Prop) {n : ℕ} (failure : ¬P n) : ¬LambdaInstrument.AllStages P
MathlibDemo.lean:501:0
'LambdaInstrument.actual_failure_refutes_tail' does not depend on any axioms
MathlibDemo.lean:502:0
LambdaInstrument.tail_negation_has_failure (P : ℕ → Prop) : ¬LambdaInstrument.AllStages P ↔ ∃ n, ¬P n
MathlibDemo.lean:503:0
'LambdaInstrument.tail_negation_has_failure' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:504:0
LambdaInstrument.unforced_failure_is_admitted_forced_failure.{u_1, u_2} {D : Type u_1} {F : Type u_2} (admD : D → Prop)
  (admF : F → Prop) (global : D → F → Prop) (zeroForce : F) (zeroAdmitted : admF zeroForce)
  (failure : ¬LambdaInstrument.NSGlobal admD global zeroForce) : LambdaInstrument.NSForcedFailure admD admF global
MathlibDemo.lean:505:0
'LambdaInstrument.unforced_failure_is_admitted_forced_failure' depends on axioms: [propext,
 Classical.choice,
 Quot.sound]
MathlibDemo.lean:506:0
LambdaInstrument.forced_failure_can_coexist_with_unforced_global :
  ∃ global,
    LambdaInstrument.NSGlobal (fun x ↦ True) global false ∧
      LambdaInstrument.NSForcedFailure (fun x ↦ True) (fun x ↦ True) global
MathlibDemo.lean:507:0
'LambdaInstrument.forced_failure_can_coexist_with_unforced_global' does not depend on any axioms
MathlibDemo.lean:508:0
LambdaInstrument.ns_regularity_requires_each_window.{u_1} {D : Type u_1} (window : D → ℕ → Prop) (d : D) :
  LambdaInstrument.NSRegular window d ↔ ∀ (N : ℕ), LambdaInstrument.Window N (window d)
MathlibDemo.lean:509:0
'LambdaInstrument.ns_regularity_requires_each_window' does not depend on any axioms
MathlibDemo.lean:510:0
LambdaInstrument.ns_uniform_bound_excludes_encoded_blowup.{u_1, u_2} {D : Type u_1} {Time : Type u_2}
  (before : D → Time → Prop) (size : D → Time → ℝ) (d : D) (bound : ∃ K, ∀ (t : Time), before d t → size d t ≤ K) :
  ¬LambdaInstrument.NSBlowup before size d
MathlibDemo.lean:511:0
'LambdaInstrument.ns_uniform_bound_excludes_encoded_blowup' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:512:0
LambdaInstrument.invariant_exact_classifier.{u_1} {X : Type u_1} (move : X → X) (H B : X → Prop)
  (equiv : ∀ (x : X), H x ↔ B x) (inv : ∀ (x : X), B (move x) ↔ B x) (x : X) : H (move x) ↔ H x
MathlibDemo.lean:513:0
'LambdaInstrument.invariant_exact_classifier' does not depend on any axioms
MathlibDemo.lean:514:0
LambdaInstrument.sufficient_condition_need_not_be_invariant :
  ∃ H B, (∀ (x : Bool), H x → B x) ∧ (∀ (x : Bool), B !x ↔ B x) ∧ ¬(H !false ↔ H false)
MathlibDemo.lean:515:0
'LambdaInstrument.sufficient_condition_need_not_be_invariant' depends on axioms: [propext]
MathlibDemo.lean:516:0
LambdaInstrument.rh_counterexample_duality.{u_1} {Zero : Type u_1} (nontrivial onLine : Zero → Prop) :
  ¬LambdaInstrument.RHForm nontrivial onLine ↔ ∃ z, nontrivial z ∧ ¬onLine z
MathlibDemo.lean:517:0
'LambdaInstrument.rh_counterexample_duality' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:518:0
LambdaInstrument.rh_tail_transport.{u_1} {Zero : Type u_1} (nontrivial onLine : Zero → Prop) (test : ℕ → Prop)
  (bridge : LambdaInstrument.RHForm nontrivial onLine ↔ LambdaInstrument.AllStages test) (closure : ∀ (n : ℕ), test n) :
  LambdaInstrument.RHForm nontrivial onLine
MathlibDemo.lean:519:0
'LambdaInstrument.rh_tail_transport' does not depend on any axioms
MathlibDemo.lean:520:0
LambdaInstrument.uniform_gap_implies_pointwise_positive.{u_1} {State : Type u_1} (excited : State → Prop)
  (energy : State → ℝ) (h : LambdaInstrument.UniformGap excited energy) (s : State) : excited s → 0 < energy s
MathlibDemo.lean:521:0
'LambdaInstrument.uniform_gap_implies_pointwise_positive' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:522:0
LambdaInstrument.pointwise_positive_need_not_have_uniform_gap :
  (∀ (x : { r // 0 < r }), 0 < ↑x) ∧ ¬LambdaInstrument.UniformGap (fun x ↦ True) fun x ↦ ↑x
MathlibDemo.lean:523:0
'LambdaInstrument.pointwise_positive_need_not_have_uniform_gap' depends on axioms: [propext,
 Classical.choice,
 Quot.sound]
MathlibDemo.lean:524:0
LambdaInstrument.common_gap_survives_order_limit.{u_1} {State : Type u_1} (excited : State → Prop) (energy : State → ℝ)
  (approx : ℕ → State → ℝ) (δ : ℝ) (positive : 0 < δ) (bounds : ∀ (n : ℕ) (s : State), excited s → δ ≤ approx n s)
  (passToLimit : ∀ (s : State), (∀ (n : ℕ), δ ≤ approx n s) → δ ≤ energy s) : LambdaInstrument.UniformGap excited energy
MathlibDemo.lean:525:0
'LambdaInstrument.common_gap_survives_order_limit' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:526:0
LambdaInstrument.hodge_actual_cycle_closes_instance.{u_1, u_2} {Instance : Type u_1} {Cycle : Type u_2}
  (represents : Cycle → Instance → Prop) (i : Instance) (c : Cycle) (certificate : represents c i) : ∃ w, represents w i
MathlibDemo.lean:527:0
'LambdaInstrument.hodge_actual_cycle_closes_instance' does not depend on any axioms
MathlibDemo.lean:528:0
LambdaInstrument.hodge_nonmembership_requires_all_cycles.{u_1, u_2} {Instance : Type u_1} {Cycle : Type u_2}
  (represents : Cycle → Instance → Prop) (i : Instance) : (¬∃ c, represents c i) ↔ ∀ (c : Cycle), ¬represents c i
MathlibDemo.lean:529:0
'LambdaInstrument.hodge_nonmembership_requires_all_cycles' depends on axioms: [propext]
MathlibDemo.lean:530:0
LambdaInstrument.hodge_separating_invariant_closes_nonmembership.{u_1, u_2} {Instance : Type u_1} {Cycle : Type u_2}
  (represents : Cycle → Instance → Prop) (invariant : Instance → Prop)
  (sound : ∀ (c : Cycle) (i : Instance), represents c i → invariant i) {i : Instance} (separates : ¬invariant i) :
  ¬∃ c, represents c i
MathlibDemo.lean:531:0
'LambdaInstrument.hodge_separating_invariant_closes_nonmembership' does not depend on any axioms
MathlibDemo.lean:532:0
LambdaInstrument.hodge_finite_empty_search_not_universal (S : Finset ℕ) :
  ∃ witness, (∀ n ∈ S, ¬witness n) ∧ ∃ n, witness n
MathlibDemo.lean:533:0
'LambdaInstrument.hodge_finite_empty_search_not_universal' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:534:0
LambdaInstrument.pnp_quantifier_duality.{u_1, u_2} {Candidate : Type u_1} {Input : Type u_2}
  (correct : Candidate → Input → Prop) :
  ¬LambdaInstrument.PolyCandidateForm correct ↔ ∀ (c : Candidate), ∃ x, ¬correct c x
MathlibDemo.lean:535:0
'LambdaInstrument.pnp_quantifier_duality' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:536:0
LambdaInstrument.pnp_candidate_with_all_input_proof_closes.{u_1, u_2} {Candidate : Type u_1} {Input : Type u_2}
  (correct : Candidate → Input → Prop) (c : Candidate) (allInputs : ∀ (x : Input), correct c x) :
  LambdaInstrument.PolyCandidateForm correct
MathlibDemo.lean:537:0
'LambdaInstrument.pnp_candidate_with_all_input_proof_closes' does not depend on any axioms
MathlibDemo.lean:538:0
LambdaInstrument.bounded_tests_do_not_prove_candidate (N : ℕ) :
  ∃ correct, (∀ n < N, correct () n) ∧ ¬LambdaInstrument.PolyCandidateForm correct
MathlibDemo.lean:539:0
'LambdaInstrument.bounded_tests_do_not_prove_candidate' does not depend on any axioms
MathlibDemo.lean:540:0
LambdaInstrument.bsd_matching_bounds_close_rank (rank lower upper : ℕ) (hl : lower ≤ rank) (hu : rank ≤ upper)
  (meet : lower = upper) : rank = lower
MathlibDemo.lean:541:0
'LambdaInstrument.bsd_matching_bounds_close_rank' depends on axioms: [propext, Quot.sound]
MathlibDemo.lean:542:0
LambdaInstrument.bsd_matching_certificates_close_instance (alg an lower upper : ℕ) (hl : lower ≤ alg) (hu : alg ≤ upper)
  (meet : lower = upper) (analytic : an = lower) : alg = an
MathlibDemo.lean:543:0
'LambdaInstrument.bsd_matching_certificates_close_instance' depends on axioms: [propext, Quot.sound]
MathlibDemo.lean:544:0
LambdaInstrument.exact_order_unique (a : ℕ → ℝ) {r s : ℕ} (hr : LambdaInstrument.ExactOrder a r)
  (hs : LambdaInstrument.ExactOrder a s) : r = s
MathlibDemo.lean:545:0
'LambdaInstrument.exact_order_unique' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:546:0
LambdaInstrument.nonzero_term_alone_not_exact_order : ∃ a, a 1 ≠ 0 ∧ ¬LambdaInstrument.ExactOrder a 1
MathlibDemo.lean:547:0
'LambdaInstrument.nonzero_term_alone_not_exact_order' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:548:0
LambdaInstrument.product_readout_loses_factor : ¬LambdaInstrument.Recoverable (fun p ↦ p.1 * p.2) Prod.fst
MathlibDemo.lean:549:0
'LambdaInstrument.product_readout_loses_factor' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:550:0
LambdaInstrument.anchored_product_recovers_factor (a b c : ℝ) (ha : a ≠ 0) (h : a * b = a * c) : b = c
MathlibDemo.lean:551:0
'LambdaInstrument.anchored_product_recovers_factor' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:552:0
LambdaInstrument.pi_outside_rational_image : ¬∃ q, ↑q = Real.pi
MathlibDemo.lean:553:0
'LambdaInstrument.pi_outside_rational_image' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:554:0
LambdaInstrument.pi_no_finite_base_fraction (a : ℤ) (b n : ℕ) : Real.pi ≠ ↑a / ↑b ^ n
MathlibDemo.lean:555:0
'LambdaInstrument.pi_no_finite_base_fraction' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:556:0
LambdaInstrument.irrational_can_have_arbitrarily_close_rationals (x ε : ℝ) (hε : 0 < ε) : ∃ q, 0 < ↑q - x ∧ ↑q - x < ε
MathlibDemo.lean:557:0
'LambdaInstrument.irrational_can_have_arbitrarily_close_rationals' depends on axioms: [propext,
 Classical.choice,
 Quot.sound]
MathlibDemo.lean:558:0
LambdaInstrument.transcendental_excludes_algebraic_representation (x : ℝ) (hx : Transcendental ℚ x) :
  ¬∃ y, IsAlgebraic ℚ y ∧ y = x
MathlibDemo.lean:559:0
'LambdaInstrument.transcendental_excludes_algebraic_representation' depends on axioms: [propext,
 Classical.choice,
 Quot.sound]
MathlibDemo.lean:560:0
LambdaInstrument.enlarged_real_polynomials_have_exact_root (x : ℝ) : ∃ p, p ≠ 0 ∧ Polynomial.eval x p = 0
MathlibDemo.lean:561:0
'LambdaInstrument.enlarged_real_polynomials_have_exact_root' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:562:0
LambdaInstrument.e_exceeds_every_finite_factorial_sum (n : ℕ) : ∑ i ∈ Finset.range n, 1 / ↑i.factorial < Real.exp 1
MathlibDemo.lean:563:0
'LambdaInstrument.e_exceeds_every_finite_factorial_sum' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:564:0
LambdaInstrument.e_algebraic_class_closure_contract (h : Transcendental ℚ (Real.exp 1)) (p : Polynomial ℚ) :
  p ≠ 0 → (Polynomial.aeval (Real.exp 1)) p ≠ 0
MathlibDemo.lean:565:0
'LambdaInstrument.e_algebraic_class_closure_contract' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:566:0
LambdaInstrument.consideration_has_an_applied_rule.{u_1, u_2, u_3} {C : Type u_1} {S : Type u_2} {E : Type u_3}
  (a : LambdaInstrument.Assessment C S E) : ∃ rule, rule a.scope a.evidence = a.verdict
MathlibDemo.lean:567:0
'LambdaInstrument.consideration_has_an_applied_rule' does not depend on any axioms
MathlibDemo.lean:568:0
LambdaInstrument.challenge_is_an_instance.{u_1, u_2, u_3} {C : Type u_1} {S : Type u_2} {E : Type u_3}
  (a : LambdaInstrument.Assessment C S E) (rejects : a.verdict = LambdaInstrument.Status.rejected) :
  a.rule a.scope a.evidence = LambdaInstrument.Status.rejected
MathlibDemo.lean:569:0
'LambdaInstrument.challenge_is_an_instance' does not depend on any axioms
MathlibDemo.lean:570:0
LambdaInstrument.shared_rule_scope_evidence_force_shared_status.{u_1, u_2, u_3} {C : Type u_1} {S : Type u_2}
  {E : Type u_3} (a b : LambdaInstrument.Assessment C S E) (hr : a.rule = b.rule) (hs : a.scope = b.scope)
  (he : a.evidence = b.evidence) : a.verdict = b.verdict
MathlibDemo.lean:571:0
'LambdaInstrument.shared_rule_scope_evidence_force_shared_status' does not depend on any axioms
MathlibDemo.lean:572:0
LambdaInstrument.same_evidence_can_support_different_declared_rules :
  ∃ a b, a.claim = b.claim ∧ a.scope = b.scope ∧ a.evidence = b.evidence ∧ a.verdict ≠ b.verdict
MathlibDemo.lean:573:0
'LambdaInstrument.same_evidence_can_support_different_declared_rules' does not depend on any axioms
MathlibDemo.lean:574:0
LambdaInstrument.receipt_does_not_certify_rule_soundness :
  ∃ a, a.claim = False ∧ a.verdict = LambdaInstrument.Status.accepted
MathlibDemo.lean:575:0
'LambdaInstrument.receipt_does_not_certify_rule_soundness' does not depend on any axioms
MathlibDemo.lean:576:0
LambdaInstrument.a_sound_rejection_can_defeat_a_claim (P : Prop) (soundRejection : ¬P) : ¬P
MathlibDemo.lean:577:0
'LambdaInstrument.a_sound_rejection_can_defeat_a_claim' does not depend on any axioms
MathlibDemo.lean:578:0
LambdaInstrument.any_finite_comment_can_be_registered (s : String) : ∃ r, r.text = s
MathlibDemo.lean:579:0
'LambdaInstrument.any_finite_comment_can_be_registered' does not depend on any axioms
MathlibDemo.lean:580:0
LambdaInstrument.append_preserves_earlier_records (history : List LambdaInstrument.Record)
  (r old : LambdaInstrument.Record) (h : old ∈ history) : old ∈ LambdaInstrument.append history r
MathlibDemo.lean:581:0
'LambdaInstrument.append_preserves_earlier_records' depends on axioms: [propext]
MathlibDemo.lean:582:0
LambdaInstrument.finite_registry_has_no_fixed_capacity (history : List LambdaInstrument.Record)
  (r : LambdaInstrument.Record) : (LambdaInstrument.append history r).length = history.length + 1
MathlibDemo.lean:583:0
'LambdaInstrument.finite_registry_has_no_fixed_capacity' depends on axioms: [propext]
MathlibDemo.lean:584:0
LambdaInstrument.declared_statuses_exhaustive (s : LambdaInstrument.Status) :
  s = LambdaInstrument.Status.accepted ∨
    s = LambdaInstrument.Status.rejected ∨ s = LambdaInstrument.Status.open ∨ s = LambdaInstrument.Status.scopeChange
MathlibDemo.lean:585:0
'LambdaInstrument.declared_statuses_exhaustive' depends on axioms: [propext]
MathlibDemo.lean:586:0
LambdaInstrument.stop_mode_contract.{u_1} {Actor : Type u_1} (s : LambdaInstrument.StopMode Actor) :
  (∃ b, ∃ (h : b = true), s = LambdaInstrument.StopMode.effective b h) ∨
    ∃ actor, s = LambdaInstrument.StopMode.declared actor
MathlibDemo.lean:587:0
'LambdaInstrument.stop_mode_contract' does not depend on any axioms
MathlibDemo.lean:588:0
"4.34.0-rc2"
MathlibDemo.lean:589:0
"LAMBDA_INSTRUMENT_R1"
MathlibDemo.lean:793:0
EnumerativeEnergy.prime_iff_no_intermediate_divisor (n : ℕ) (hn : 2 ≤ n) : Nat.Prime n ↔ ¬∃ d, d ∣ n ∧ 2 ≤ d ∧ d < n
MathlibDemo.lean:794:0
EnumerativeEnergy.prime_step_gcd_one (p k : ℕ) (hp : Nat.Prime p) (hk : 0 < k) (hkp : k < p) : p.gcd k = 1
MathlibDemo.lean:795:0
EnumerativeEnergy.shared_divisibility (n m d : ℕ) : d ∣ n.gcd m ↔ d ∣ n ∧ d ∣ m
MathlibDemo.lean:796:0
EnumerativeEnergy.simultaneous_return (n m t : ℕ) : n.lcm m ∣ t ↔ n ∣ t ∧ m ∣ t
MathlibDemo.lean:797:0
EnumerativeEnergy.relabeling_preserves_orbit.{u_1, u_2} {A : Type u_1} {B : Type u_2} (e : A ≃ B) (f : A → A) (n : ℕ)
  (x : A) : EnumerativeEnergy.orbit (fun y ↦ e (f (e.symm y))) n (e x) = e (EnumerativeEnergy.orbit f n x)
MathlibDemo.lean:798:0
EnumerativeEnergy.relabeling_preserves_return.{u_1, u_2} {A : Type u_1} {B : Type u_2} (e : A ≃ B) (f : A → A) (n : ℕ)
  (x : A) : EnumerativeEnergy.orbit (fun y ↦ e (f (e.symm y))) n (e x) = e x ↔ EnumerativeEnergy.orbit f n x = x
MathlibDemo.lean:799:0
EnumerativeEnergy.inversion_preserves_spectral_read (z : ℂ) :
  EnumerativeEnergy.spectralRead z⁻¹ = EnumerativeEnergy.spectralRead z
MathlibDemo.lean:800:0
EnumerativeEnergy.spectral_collision_has_two_branches (z w : ℂ) (hz : z ≠ 0) (hw : w ≠ 0)
  (h : EnumerativeEnergy.spectralRead z = EnumerativeEnergy.spectralRead w) : z = w ∨ z * w = 1
MathlibDemo.lean:801:0
EnumerativeEnergy.spectral_read_cannot_recover_phase (z : ℂ) (hz : z ≠ 0) (hd : z ≠ z⁻¹) :
  ¬∃ f, ∀ (w : ℂ), w ≠ 0 → f (EnumerativeEnergy.spectralRead w) = w
MathlibDemo.lean:802:0
EnumerativeEnergy.ordered_count_from_union_data.{u_1} {A : Type u_1} [DecidableEq A] (s t : Finset A) (g f : ℕ)
  (hs : s.card = g) (ht : t.card = g) (hi : (s ∩ t).card = f) : (s ∪ t).card = 2 * g - f
MathlibDemo.lean:803:0
EnumerativeEnergy.common_energy_shift_preserves_gaps (a b offset : ℝ) : a + offset - (b + offset) = a - b
MathlibDemo.lean:804:0
EnumerativeEnergy.calibration_rescaling_preserves_phase (scale energy time : ℝ) (hs : scale ≠ 0) :
  scale * energy * (time / scale) = energy * time
MathlibDemo.lean:805:0
EnumerativeEnergy.residue_monotone.{u_1} {A : Type u_1} (S T : Set A) (cost : A → ENNReal) (h : S ⊆ T) :
  EnumerativeEnergy.indexedResidue T cost ≤ EnumerativeEnergy.indexedResidue S cost
MathlibDemo.lean:806:0
EnumerativeEnergy.conservative_representation_preserves_theorems.{u_1, u_2} {P : Type u_1} {T : Type u_2}
  (R0 R1 : Set P) (conclusion : P → T) (expand : P → P) (hin : R0 ⊆ R1)
  (hex : ∀ p ∈ R1, expand p ∈ R0 ∧ conclusion (expand p) = conclusion p) (target : T) :
  (∃ p ∈ R0, conclusion p = target) ↔ ∃ p ∈ R1, conclusion p = target
MathlibDemo.lean:807:0
EnumerativeEnergy.pointwise_positivity_not_uniform :
  (∀ (x : ℝ), 0 < x → 0 < x) ∧ ¬∃ epsilon, 0 < epsilon ∧ ∀ (x : ℝ), 0 < x → epsilon ≤ x
MathlibDemo.lean:808:0
LambdaPhysical.boosted_time_needs_space (g b : ℝ) (hg : g ≠ 0) (hb : b ≠ 0) :
  ¬∃ f, ∀ (T x : ℝ), f T = LambdaPhysical.boostTime g b T x
MathlibDemo.lean:809:0
LambdaPhysical.boosted_space_needs_time (g b : ℝ) (hg : g ≠ 0) (hb : b ≠ 0) :
  ¬∃ f, ∀ (T x : ℝ), f x = LambdaPhysical.boostSpace g b T x
MathlibDemo.lean:810:0
LambdaPhysical.lorentz_interval_preserved (g b T x : ℝ) (hn : g ^ 2 * (1 - b ^ 2) = 1) :
  LambdaPhysical.interval (LambdaPhysical.boostTime g b T x) (LambdaPhysical.boostSpace g b T x) =
    LambdaPhysical.interval T x
MathlibDemo.lean:811:0
LambdaPhysical.lorentz_null_preserved (g b T x : ℝ) (hn : g ^ 2 * (1 - b ^ 2) = 1) :
  LambdaPhysical.interval (LambdaPhysical.boostTime g b T x) (LambdaPhysical.boostSpace g b T x) = 0 ↔
    LambdaPhysical.interval T x = 0
MathlibDemo.lean:812:0
LambdaPhysical.timelike_not_time_only : ¬∃ P, ∀ (T x : ℝ), P T ↔ LambdaPhysical.interval T x < 0
MathlibDemo.lean:813:0
LambdaPhysical.timelike_not_space_only : ¬∃ P, ∀ (T x : ℝ), P x ↔ LambdaPhysical.interval T x < 0
MathlibDemo.lean:814:0
LambdaPhysical.fixed_c_couples_unit_rescaling (c L U : ℝ) (hc : c ≠ 0) (hL : L ≠ 0) (h : c * U / L = c) : L = U
MathlibDemo.lean:815:0
LambdaPhysical.calibrated_ratios_determine_values.{u_1} {I : Type u_1} (r E F : I → ℝ) (anchor : ℝ)
  (hE : ∀ (i : I), E i = r i * anchor) (hF : ∀ (i : I), F i = r i * anchor) : E = F
MathlibDemo.lean:816:0
'EnumerativeEnergy.prime_iff_no_intermediate_divisor' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:817:0
'EnumerativeEnergy.prime_step_gcd_one' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:818:0
'EnumerativeEnergy.shared_divisibility' depends on axioms: [propext, Quot.sound]
MathlibDemo.lean:819:0
'EnumerativeEnergy.simultaneous_return' depends on axioms: [propext, Quot.sound]
MathlibDemo.lean:820:0
'EnumerativeEnergy.relabeling_preserves_orbit' depends on axioms: [propext, Quot.sound]
MathlibDemo.lean:821:0
'EnumerativeEnergy.relabeling_preserves_return' depends on axioms: [propext, Quot.sound]
MathlibDemo.lean:822:0
'EnumerativeEnergy.inversion_preserves_spectral_read' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:823:0
'EnumerativeEnergy.spectral_collision_has_two_branches' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:824:0
'EnumerativeEnergy.spectral_read_cannot_recover_phase' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:825:0
'EnumerativeEnergy.ordered_count_from_union_data' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:826:0
'EnumerativeEnergy.common_energy_shift_preserves_gaps' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:827:0
'EnumerativeEnergy.calibration_rescaling_preserves_phase' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:828:0
'EnumerativeEnergy.residue_monotone' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:829:0
'EnumerativeEnergy.conservative_representation_preserves_theorems' does not depend on any axioms
MathlibDemo.lean:830:0
'EnumerativeEnergy.pointwise_positivity_not_uniform' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:831:0
'LambdaPhysical.boosted_time_needs_space' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:832:0
'LambdaPhysical.boosted_space_needs_time' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:833:0
'LambdaPhysical.lorentz_interval_preserved' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:834:0
'LambdaPhysical.lorentz_null_preserved' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:835:0
'LambdaPhysical.timelike_not_time_only' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:836:0
'LambdaPhysical.timelike_not_space_only' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:837:0
'LambdaPhysical.fixed_c_couples_unit_rescaling' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:838:0
'LambdaPhysical.calibrated_ratios_determine_values' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:839:0
"4.34.0-rc2"
MathlibDemo.lean:840:0
"LAMBDA_PART_II_AUDIT_COMPLETE"
MathlibDemo.lean:1140:0
LambdaSpatiotemporal.source_target_roles_distinct : RefRole.source ≠ RefRole.target
MathlibDemo.lean:1141:0
LambdaSpatiotemporal.reference_polarity {X : Type} (x y : X) : asSource x ≠ asTarget y
MathlibDemo.lean:1142:0
LambdaSpatiotemporal.reflexive_reference_preserves_role_distinction {X : Type} (x : X) : asSource x ≠ asTarget x
MathlibDemo.lean:1143:0
LambdaSpatiotemporal.iterated_reference_polarity {X : Type} (x : X) (n : ℕ) : (n, asSource x) ≠ (n, asTarget x)
MathlibDemo.lean:1144:0
LambdaSpatiotemporal.nontrivial_criterion_exhibits_poles {X : Type} (criterion : X → Bool)
  (h : NontrivialCriterion criterion) : ∃ x y, SelfSide criterion x ∧ OtherSide criterion y
MathlibDemo.lean:1145:0
LambdaSpatiotemporal.nontrivial_criterion_exhibits_distinct_states {X : Type} (criterion : X → Bool)
  (h : NontrivialCriterion criterion) : ∃ x y, x ≠ y
MathlibDemo.lean:1146:0
LambdaSpatiotemporal.exclusion_is_criterion_relative {X : Type} (criterion : X → Prop) (x : X) :
  ExcludedBy criterion x ↔ ¬criterion x
MathlibDemo.lean:1147:0
LambdaSpatiotemporal.postprocessing_cannot_split_fibre {X Y Z : Type} (projection : X → Y) (g : Y → Z) {x₁ x₂ : X}
  (h : projection x₁ = projection x₂) : g (projection x₁) = g (projection x₂)
MathlibDemo.lean:1148:0
LambdaSpatiotemporal.target_difference_blocks_factorization {X Y Z : Type} (projection : X → Y) (target : X → Z)
  {x₁ x₂ : X} (hproj : projection x₁ = projection x₂) (htarget : target x₁ ≠ target x₂) :
  ¬FactorsThrough projection target
MathlibDemo.lean:1149:0
LambdaSpatiotemporal.target_exact_compression_can_lose_other_distinctions :
  ∃ compress target, FactorsThrough compress target ∧ ¬InjectiveMap compress
MathlibDemo.lean:1150:0
LambdaSpatiotemporal.residual_selection {J S : Type} (Admissible : J → Prop) (outcome : J → S) {j₁ j₂ : J}
  (h₁ : Admissible j₁) (h₂ : Admissible j₂) (hdiff : outcome j₁ ≠ outcome j₂) : ¬UniqueOutcome Admissible outcome
MathlibDemo.lean:1151:0
LambdaSpatiotemporal.residual_will_from_competing_admissible_procedures {J S : Type} (Admissible : J → Prop)
  (outcome : J → S) {chosen j₂ : J} (hchosen : Admissible chosen) (h₂ : Admissible j₂)
  (hdiff : outcome chosen ≠ outcome j₂) : ResidualWill Admissible outcome chosen
MathlibDemo.lean:1152:0
LambdaSpatiotemporal.SelectedCriterion {J X : Type} (criterionOf : J → X → Bool) (chosen : J) : X → Bool
MathlibDemo.lean:1153:0
LambdaSpatiotemporal.competing_admissible_criteria_not_uniquely_forced {J X : Type} (Admissible : J → Prop)
  (criterionOf : J → X → Bool) {j₁ j₂ : J} (h₁ : Admissible j₁) (h₂ : Admissible j₂)
  (hdiff : criterionOf j₁ ≠ criterionOf j₂) : ¬UniqueOutcome Admissible criterionOf
MathlibDemo.lean:1154:0
LambdaSpatiotemporal.complement_requirement_blocks_absolute_priority {C : Type} (Priority UsesComplement : C → Prop)
  (hbridge : ∀ (c : C), Priority c → UsesComplement c) : ¬∃ c, AbsolutePriority Priority UsesComplement c
MathlibDemo.lean:1155:0
LambdaSpatiotemporal.no_first_position {Claim : Type} (B : SpatiotemporalBridge Claim) :
  (¬∃ c, AbsoluteSpaceFirst B c) ∧ ¬∃ c, AbsoluteTimeFirst B c
MathlibDemo.lean:1156:0
LambdaSpatiotemporal.local_warrant_not_universal_in_general :
  SampleWarrant TwoFrame.local ∧ ¬UniversalWarrant SampleWarrant
MathlibDemo.lean:1157:0
LambdaSpatiotemporal.absolute_label_does_not_self_license : ¬∀ (Absolute : Prop → Prop) (p : Prop), Absolute p → p
MathlibDemo.lean:1158:0
LambdaSpatiotemporal.same_public_label : publicLabel Usage.original = publicLabel Usage.extended
MathlibDemo.lean:1159:0
LambdaSpatiotemporal.same_label_can_hide_different_meanings :
  publicLabel Usage.original = publicLabel Usage.extended ∧
    tinyMeaning Usage.original TinyState.marked ≠ tinyMeaning Usage.extended TinyState.marked
MathlibDemo.lean:1160:0
LambdaSpatiotemporal.predicate_preservation_composes {A B C : Type} (f : A → B) (g : B → C) (P : A → Prop)
  (Q : B → Prop) (R : C → Prop) (hAB : PreservesPredicate f P Q) (hBC : PreservesPredicate g Q R) :
  PreservesPredicate (fun a ↦ g (f a)) P R
MathlibDemo.lean:1161:0
LambdaSpatiotemporal.translations_need_not_commute : ∃ AB BC AC x, AC x ≠ BC (AB x)
MathlibDemo.lean:1162:0
LambdaSpatiotemporal.finite_budget_forces_tradeoff (costA costB allocA allocB budget : ℕ)
  (hDemand : budget < costA + costB) (hBudget : allocA + allocB ≤ budget) (hA : costA ≤ allocA) (hB : costB ≤ allocB) :
  False
MathlibDemo.lean:1163:0
LambdaSpatiotemporal.same_input_can_receive_different_interpretations : ∃ I₀ I₁ r, I₀ r ≠ I₁ r
MathlibDemo.lean:1165:0
'LambdaSpatiotemporal.source_target_roles_distinct' does not depend on any axioms
MathlibDemo.lean:1166:0
'LambdaSpatiotemporal.reference_polarity' does not depend on any axioms
MathlibDemo.lean:1167:0
'LambdaSpatiotemporal.reflexive_reference_preserves_role_distinction' does not depend on any axioms
MathlibDemo.lean:1168:0
'LambdaSpatiotemporal.iterated_reference_polarity' does not depend on any axioms
MathlibDemo.lean:1169:0
'LambdaSpatiotemporal.nontrivial_criterion_exhibits_poles' does not depend on any axioms
MathlibDemo.lean:1170:0
'LambdaSpatiotemporal.nontrivial_criterion_exhibits_distinct_states' does not depend on any axioms
MathlibDemo.lean:1171:0
'LambdaSpatiotemporal.exclusion_is_criterion_relative' does not depend on any axioms
MathlibDemo.lean:1172:0
'LambdaSpatiotemporal.postprocessing_cannot_split_fibre' does not depend on any axioms
MathlibDemo.lean:1173:0
'LambdaSpatiotemporal.target_difference_blocks_factorization' does not depend on any axioms
MathlibDemo.lean:1174:0
'LambdaSpatiotemporal.target_exact_compression_can_lose_other_distinctions' does not depend on any axioms
MathlibDemo.lean:1175:0
'LambdaSpatiotemporal.residual_selection' does not depend on any axioms
MathlibDemo.lean:1176:0
'LambdaSpatiotemporal.residual_will_from_competing_admissible_procedures' does not depend on any axioms
MathlibDemo.lean:1177:0
'LambdaSpatiotemporal.competing_admissible_criteria_not_uniquely_forced' does not depend on any axioms
MathlibDemo.lean:1178:0
'LambdaSpatiotemporal.complement_requirement_blocks_absolute_priority' does not depend on any axioms
MathlibDemo.lean:1179:0
'LambdaSpatiotemporal.no_first_position' does not depend on any axioms
MathlibDemo.lean:1180:0
'LambdaSpatiotemporal.local_warrant_not_universal_in_general' does not depend on any axioms
MathlibDemo.lean:1181:0
'LambdaSpatiotemporal.absolute_label_does_not_self_license' does not depend on any axioms
MathlibDemo.lean:1182:0
'LambdaSpatiotemporal.same_public_label' does not depend on any axioms
MathlibDemo.lean:1183:0
'LambdaSpatiotemporal.same_label_can_hide_different_meanings' does not depend on any axioms
MathlibDemo.lean:1184:0
'LambdaSpatiotemporal.predicate_preservation_composes' does not depend on any axioms
MathlibDemo.lean:1185:0
'LambdaSpatiotemporal.translations_need_not_commute' does not depend on any axioms
MathlibDemo.lean:1186:0
'LambdaSpatiotemporal.finite_budget_forces_tradeoff' does not depend on any axioms
MathlibDemo.lean:1187:0
'LambdaSpatiotemporal.same_input_can_receive_different_interpretations' does not depend on any axioms
MathlibDemo.lean:1189:0
"4.34.0-rc2"
MathlibDemo.lean:1190:0
"LAMBDA_SPATIOTEMPORAL_TRANSLATION_AUDIT_COMPLETE"
MathlibDemo.lean:1303:0
SemanticDeflation.deflation {X : Type} (A B P : X → Prop) (hA : ∀ (x : X), A x → ¬P x) (hB : ∃ x, B x ∧ P x) :
  ¬∀ (x : X), B x → A x
MathlibDemo.lean:1304:0
'SemanticDeflation.deflation' does not depend on any axioms
MathlibDemo.lean:1306:0
SemanticDeflation.constraint_loss {X : Type} (A B P : X → Prop) (hA : ∀ (x : X), A x → ¬P x) (hB : ∃ x, B x ∧ P x) :
  ∃ x, B x ∧ P x ∧ ¬A x
MathlibDemo.lean:1307:0
'SemanticDeflation.constraint_loss' does not depend on any axioms
MathlibDemo.lean:1309:0
SemanticDeflation.no_shared_definition {X : Type} (A B P : X → Prop) (hA : ∀ (x : X), A x → ¬P x)
  (hB : ∃ x, B x ∧ P x) : ¬∃ S, (∀ (x : X), S x ↔ A x) ∧ ∀ (x : X), S x ↔ B x
MathlibDemo.lean:1310:0
'SemanticDeflation.no_shared_definition' does not depend on any axioms
MathlibDemo.lean:1312:0
SemanticDeflation.same_meaning_conflict {X : Type} (S P : X → Prop) (hNo : ∀ (x : X), S x → ¬P x)
  (hYes : ∃ x, S x ∧ P x) : False
MathlibDemo.lean:1313:0
'SemanticDeflation.same_meaning_conflict' does not depend on any axioms
MathlibDemo.lean:1315:0
SemanticDeflation.original_inhabited : ∃ x, SemanticDeflation.Original x
MathlibDemo.lean:1316:0
'SemanticDeflation.original_inhabited' does not depend on any axioms
MathlibDemo.lean:1318:0
SemanticDeflation.original_excludes_trait (x : SemanticDeflation.State) :
  SemanticDeflation.Original x → ¬SemanticDeflation.HasTrait x
MathlibDemo.lean:1319:0
'SemanticDeflation.original_excludes_trait' does not depend on any axioms
MathlibDemo.lean:1321:0
SemanticDeflation.extended_admits_trait : ∃ x, SemanticDeflation.Extended x ∧ SemanticDeflation.HasTrait x
MathlibDemo.lean:1322:0
'SemanticDeflation.extended_admits_trait' does not depend on any axioms
MathlibDemo.lean:1324:0
SemanticDeflation.original_is_extended (x : SemanticDeflation.State) :
  SemanticDeflation.Original x → SemanticDeflation.Extended x
MathlibDemo.lean:1325:0
'SemanticDeflation.original_is_extended' does not depend on any axioms
MathlibDemo.lean:1327:0
SemanticDeflation.two_checked_branches_one_label :
  (∃ x, SemanticDeflation.meaning SemanticDeflation.Usage.original x) ∧
    (∀ (x : SemanticDeflation.State),
        SemanticDeflation.meaning SemanticDeflation.Usage.original x → ¬SemanticDeflation.HasTrait x) ∧
      (∃ x, SemanticDeflation.meaning SemanticDeflation.Usage.extended x ∧ SemanticDeflation.HasTrait x) ∧
        SemanticDeflation.publicLabel SemanticDeflation.Usage.original =
          SemanticDeflation.publicLabel SemanticDeflation.Usage.extended
MathlibDemo.lean:1328:0
'SemanticDeflation.two_checked_branches_one_label' does not depend on any axioms
MathlibDemo.lean:1330:0
SemanticDeflation.shared_label_does_not_preserve_meaning :
  SemanticDeflation.publicLabel SemanticDeflation.Usage.original =
      SemanticDeflation.publicLabel SemanticDeflation.Usage.extended ∧
    ¬∀ (x : SemanticDeflation.State),
        SemanticDeflation.meaning SemanticDeflation.Usage.original x ↔
          SemanticDeflation.meaning SemanticDeflation.Usage.extended x
MathlibDemo.lean:1331:0
'SemanticDeflation.shared_label_does_not_preserve_meaning' does not depend on any axioms
MathlibDemo.lean:1333:0
"4.34.0-rc2"
MathlibDemo.lean:1334:0
"SEMANTIC_DEFLATION_AUDIT_COMPLETE"
MathlibDemo.lean:1473:0
'UnwitnessableVerdict.refutation_is_witnessed' does not depend on any axioms
MathlibDemo.lean:1474:0
'UnwitnessableVerdict.vacuous_pass' does not depend on any axioms
MathlibDemo.lean:1475:0
'UnwitnessableVerdict.misscoped_says_equal' does not depend on any axioms
MathlibDemo.lean:1476:0
'UnwitnessableVerdict.misscoped_says_not_equal' does not depend on any axioms
MathlibDemo.lean:1477:0
'UnwitnessableVerdict.check_outcome_settled' does not depend on any axioms
MathlibDemo.lean:1501:0
UnwitnessableVerdict.refutation_is_witnessed {α : Type} (P : α → Prop) (a : α) (h : ¬P a) : ¬∀ (x : α), P x
MathlibDemo.lean:1502:0
UnwitnessableVerdict.vacuous_pass {α : Type} (H G : α → Prop) (empty : ∀ (x : α), ¬H x) (x : α) : H x → G x
MathlibDemo.lean:1503:0
UnwitnessableVerdict.misscoped_says_equal (n : ℕ) : n < 0 → n = n
MathlibDemo.lean:1504:0
UnwitnessableVerdict.misscoped_says_not_equal (n : ℕ) : n < 0 → n ≠ n
MathlibDemo.lean:1505:0
UnwitnessableVerdict.check_outcome_settled (b : Bool) :
  UnwitnessableVerdict.checkPasses b = true ∨ UnwitnessableVerdict.checkPasses b = false
MathlibDemo.lean:1507:0
"4.34.0-rc2"
MathlibDemo.lean:1508:0
"UNWITNESSABLE_VERDICT_AUDIT_COMPLETE"
MathlibDemo.lean:1510:0
"4.34.0-rc2"
MathlibDemo.lean:1511:0
"LAMBDA_R4_COMPANION_END"
Restart File

Lean 4.34.0-rc2. Zero reported errors and warnings. Source SHA-256: 94b31d916921f678d5cc4e60a6a5a2904eef6dbfe47adf6200fd12c50280716c

Open this exact source in Lean

MathlibDemo.lean:1:0
No info found.
All Messages ( 76)
MathlibDemo.lean:309:0
LambdaConstitutive.role_positions_differ : LambdaConstitutive.Role.source ≠ LambdaConstitutive.Role.target
MathlibDemo.lean:310:0
'LambdaConstitutive.role_positions_differ' does not depend on any axioms
MathlibDemo.lean:311:0
LambdaConstitutive.one_carrier_can_fill_both_roles.{u_1} {X : Type u_1} (x : X) :
  ∃ placement, placement LambdaConstitutive.Role.source = placement LambdaConstitutive.Role.target
MathlibDemo.lean:312:0
'LambdaConstitutive.one_carrier_can_fill_both_roles' does not depend on any axioms
MathlibDemo.lean:313:0
LambdaConstitutive.translation_composes.{u_1, u_2, u_3} {X : Type u_1} {Y : Type u_2} {Z : Type u_3} (f : X → Y)
  (g : Y → Z) (p : X → Prop) (q : Y → Prop) (r : Z → Prop) (first : LambdaConstitutive.Preserves f p q)
  (second : LambdaConstitutive.Preserves g q r) : LambdaConstitutive.Preserves (g ∘ f) p r
MathlibDemo.lean:314:0
'LambdaConstitutive.translation_composes' does not depend on any axioms
MathlibDemo.lean:315:0
LambdaConstitutive.preserved_predicate_survives_roundtrip.{u_1, u_2} {X : Type u_1} {Y : Type u_2} (f : X → Y)
  (g : Y → X) (p : X → Prop) (q : Y → Prop) (forward : LambdaConstitutive.Preserves f p q)
  (backward : LambdaConstitutive.Preserves g q p) (x : X) : p x ↔ p (g (f x))
MathlibDemo.lean:316:0
'LambdaConstitutive.preserved_predicate_survives_roundtrip' does not depend on any axioms
MathlibDemo.lean:317:0
LambdaConstitutive.changed_middle_predicate_breaks_composition :
  ∃ f g p q₁ q₂ r,
    LambdaConstitutive.Preserves f p q₁ ∧
      LambdaConstitutive.Preserves g q₂ r ∧ ¬LambdaConstitutive.Preserves (g ∘ f) p r
MathlibDemo.lean:318:0
'LambdaConstitutive.changed_middle_predicate_breaks_composition' does not depend on any axioms
MathlibDemo.lean:319:0
LambdaConstitutive.conveyance_collision_blocks_target.{u_1, u_2, u_3} {X : Type u_1} {Y : Type u_2} {Z : Type u_3}
  (message : X → Y) (target : X → Z) {a b : X} (same : message a = message b) (split : target a ≠ target b) :
  ¬∃ interpret, ∀ (x : X), interpret (message x) = target x
MathlibDemo.lean:320:0
'LambdaConstitutive.conveyance_collision_blocks_target' does not depend on any axioms
MathlibDemo.lean:321:0
LambdaConstitutive.metadescription_cannot_split_equal_messages.{u_1, u_2, u_3} {X : Type u_1} {Y : Type u_2}
  {Z : Type u_3} (message : X → Y) (redescribe : Y → Z) {a b : X} (same : message a = message b) :
  redescribe (message a) = redescribe (message b)
MathlibDemo.lean:322:0
'LambdaConstitutive.metadescription_cannot_split_equal_messages' does not depend on any axioms
MathlibDemo.lean:323:0
LambdaConstitutive.erased_depth_has_no_decoder : ¬∃ decode, ∀ (n : ℕ), decode () = n
MathlibDemo.lean:324:0
'LambdaConstitutive.erased_depth_has_no_decoder' depends on axioms: [propext, Quot.sound]
MathlibDemo.lean:325:0
LambdaConstitutive.threaded_depth_has_decoder : ∃ decode, ∀ (n : ℕ), decode ((), n) = n
MathlibDemo.lean:326:0
'LambdaConstitutive.threaded_depth_has_decoder' does not depend on any axioms
MathlibDemo.lean:327:0
LambdaConstitutive.retained_argument_can_recover_depth : ∃ decode, ∀ (n : ℕ), decode n = n
MathlibDemo.lean:328:0
'LambdaConstitutive.retained_argument_can_recover_depth' does not depend on any axioms
MathlibDemo.lean:329:0
LambdaConstitutive.terminating_countdown_has_input_sized_trace (n : ℕ) : (LambdaConstitutive.countdown n).length = n
MathlibDemo.lean:330:0
'LambdaConstitutive.terminating_countdown_has_input_sized_trace' depends on axioms: [propext]
MathlibDemo.lean:331:0
LambdaConstitutive.no_uniform_trace_bound_for_terminating_countdown :
  ¬∃ B, ∀ (n : ℕ), (LambdaConstitutive.countdown n).length ≤ B
MathlibDemo.lean:332:0
'LambdaConstitutive.no_uniform_trace_bound_for_terminating_countdown' depends on axioms: [propext, Quot.sound]
MathlibDemo.lean:333:0
LambdaConstitutive.finite_state_can_continue_without_halting : ∃ step halt, ∀ (n : ℕ), ¬halt (step^[n] ())
MathlibDemo.lean:334:0
'LambdaConstitutive.finite_state_can_continue_without_halting' does not depend on any axioms
MathlibDemo.lean:335:0
LambdaConstitutive.exact_recovery_requires_enough_states.{u_1, u_2} {X : Type u_1} {S : Type u_2} [Fintype X]
  [Fintype S] (encode : X → S) (decode : S → X) (exactness : ∀ (x : X), decode (encode x) = x) :
  Fintype.card X ≤ Fintype.card S
MathlibDemo.lean:336:0
'LambdaConstitutive.exact_recovery_requires_enough_states' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:337:0
LambdaConstitutive.exact_subset_memory_requires_all_subsets.{u_1} (k : ℕ) {S : Type u_1} [Fintype S]
  (encode : (Fin k → Bool) → S) (decode : S → Fin k → Bool) (exactness : ∀ (x : Fin k → Bool), decode (encode x) = x) :
  2 ^ k ≤ Fintype.card S
MathlibDemo.lean:338:0
'LambdaConstitutive.exact_subset_memory_requires_all_subsets' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:339:0
LambdaConstitutive.exact_depth_through_N_requires_N_plus_one_states.{u_1} (N : ℕ) {S : Type u_1} [Fintype S]
  (encode : Fin (N + 1) → S) (decode : S → Fin (N + 1)) (exactness : ∀ (n : Fin (N + 1)), decode (encode n) = n) :
  N + 1 ≤ Fintype.card S
MathlibDemo.lean:340:0
'LambdaConstitutive.exact_depth_through_N_requires_N_plus_one_states' depends on axioms: [propext,
 Classical.choice,
 Quot.sound]
MathlibDemo.lean:341:0
LambdaConstitutive.no_fixed_finite_state_recovers_unbounded_depth.{u_1} {S : Type u_1} [Fintype S] (encode : ℕ → S) :
  ¬∃ decode, ∀ (n : ℕ), decode (encode n) = n
MathlibDemo.lean:342:0
'LambdaConstitutive.no_fixed_finite_state_recovers_unbounded_depth' depends on axioms: [propext,
 Classical.choice,
 Quot.sound]
MathlibDemo.lean:343:0
LambdaConstitutive.online_update_implies_append_compatibility.{u_1, u_2} {E : Type u_1} {S : Type u_2}
  (encode : List E → S) (update : S → E → S)
  (commutes : ∀ (h : List E) (e : E), update (encode h) e = encode (h ++ [e])) :
  LambdaConstitutive.AppendCompatible encode
MathlibDemo.lean:344:0
'LambdaConstitutive.online_update_implies_append_compatibility' does not depend on any axioms
MathlibDemo.lean:345:0
LambdaConstitutive.append_compatibility_supplies_online_update.{u_1, u_2} {E : Type u_1} {S : Type u_2} [Nonempty S]
  (encode : List E → S) (compatible : LambdaConstitutive.AppendCompatible encode) :
  ∃ update, ∀ (h : List E) (e : E), update (encode h) e = encode (h ++ [e])
MathlibDemo.lean:346:0
'LambdaConstitutive.append_compatibility_supplies_online_update' depends on axioms: [propext,
 Classical.choice,
 Quot.sound]
MathlibDemo.lean:347:0
LambdaConstitutive.run_preserves_history_encoding.{u_1, u_2} {E : Type u_1} {S : Type u_2} (encode : List E → S)
  (update : S → E → S) (commutes : ∀ (h : List E) (e : E), update (encode h) e = encode (h ++ [e])) (h : List E) :
  LambdaConstitutive.run update (encode []) h = encode h
MathlibDemo.lean:348:0
'LambdaConstitutive.run_preserves_history_encoding' depends on axioms: [propext, Quot.sound]
MathlibDemo.lean:349:0
LambdaConstitutive.online_target_recovery.{u_1, u_2, u_3} {E : Type u_1} {S : Type u_2} {Z : Type u_3}
  (encode : List E → S) (update : S → E → S) (decode : S → Z) (target : List E → Z)
  (commutes : ∀ (h : List E) (e : E), update (encode h) e = encode (h ++ [e]))
  (exactness : ∀ (h : List E), decode (encode h) = target h) (h : List E) :
  decode (LambdaConstitutive.run update (encode []) h) = target h
MathlibDemo.lean:350:0
'LambdaConstitutive.online_target_recovery' depends on axioms: [propext, Quot.sound]
MathlibDemo.lean:351:0
LambdaConstitutive.snapshot_target_can_fail_online_update :
  (∃ decode, ∀ (h : List Unit), decode (LambdaConstitutive.hasTwo h) = LambdaConstitutive.hasTwo h) ∧
    ¬LambdaConstitutive.AppendCompatible LambdaConstitutive.hasTwo
MathlibDemo.lean:352:0
'LambdaConstitutive.snapshot_target_can_fail_online_update' does not depend on any axioms
MathlibDemo.lean:353:0
LambdaConstitutive.cached_result_does_not_recover_return :
  ¬∃ d, ∀ (c : LambdaConstitutive.Cache), d c.result = c.returned
MathlibDemo.lean:354:0
'LambdaConstitutive.cached_result_does_not_recover_return' does not depend on any axioms
MathlibDemo.lean:355:0
LambdaConstitutive.return_mark_does_not_recover_cached_result :
  ¬∃ d, ∀ (c : LambdaConstitutive.Cache), d c.returned = c.result
MathlibDemo.lean:356:0
'LambdaConstitutive.return_mark_does_not_recover_cached_result' depends on axioms: [propext, Quot.sound]
MathlibDemo.lean:357:0
LambdaConstitutive.joint_record_recovers_both_cache_queries :
  ∃ d, ∀ (c : LambdaConstitutive.Cache), d c = (c.result, c.returned)
MathlibDemo.lean:358:0
'LambdaConstitutive.joint_record_recovers_both_cache_queries' does not depend on any axioms
MathlibDemo.lean:359:0
LambdaConstitutive.unchanged_reuse_preserves_entry {old new : LambdaConstitutive.Entry}
  (h : LambdaConstitutive.Reuse old new) : new = old
MathlibDemo.lean:360:0
'LambdaConstitutive.unchanged_reuse_preserves_entry' depends on axioms: [propext]
MathlibDemo.lean:361:0
LambdaConstitutive.unknown_origin_stays_unknown_under_reuse {old new : LambdaConstitutive.Entry}
  (h : LambdaConstitutive.Reuse old new) (unknown : old.origin = LambdaConstitutive.Origin.unknown) :
  new.origin = LambdaConstitutive.Origin.unknown
MathlibDemo.lean:362:0
'LambdaConstitutive.unknown_origin_stays_unknown_under_reuse' does not depend on any axioms
MathlibDemo.lean:363:0
LambdaConstitutive.changed_scope_is_not_unchanged_reuse {old new : LambdaConstitutive.Entry}
  (changed : new.scope ≠ old.scope) : ¬LambdaConstitutive.Reuse old new
MathlibDemo.lean:364:0
'LambdaConstitutive.changed_scope_is_not_unchanged_reuse' does not depend on any axioms
MathlibDemo.lean:365:0
LambdaConstitutive.result_label_cannot_recover_origin :
  ¬∃ decode, ∀ (e : LambdaConstitutive.Entry), decode e.claim = e.origin
MathlibDemo.lean:366:0
'LambdaConstitutive.result_label_cannot_recover_origin' does not depend on any axioms
MathlibDemo.lean:367:0
LambdaConstitutive.warranted_reuse_needs_scope_preservation.{u_1, u_2} {Scope : Type u_1} {Claim : Type u_2}
  {holds : Scope → Claim → Prop} (w : LambdaConstitutive.Warrant Scope Claim holds) (nextScope : Scope)
  (same : nextScope = w.scope) : holds nextScope w.claim
MathlibDemo.lean:368:0
'LambdaConstitutive.warranted_reuse_needs_scope_preservation' does not depend on any axioms
MathlibDemo.lean:369:0
LambdaConstitutive.warranted_translation_needs_a_bridge.{u_1, u_2, u_3, u_4} {S : Type u_1} {T : Type u_2}
  {C : Type u_3} {D : Type u_4} {holds : S → C → Prop} {nextHolds : T → D → Prop} (scopeMap : S → T) (claimMap : C → D)
  (bridge : ∀ (s : S) (c : C), holds s c → nextHolds (scopeMap s) (claimMap c))
  (w : LambdaConstitutive.Warrant S C holds) : nextHolds (scopeMap w.scope) (claimMap w.claim)
MathlibDemo.lean:370:0
'LambdaConstitutive.warranted_translation_needs_a_bridge' does not depend on any axioms
MathlibDemo.lean:371:0
LambdaConstitutive.declared_basis_allows_derived_conclusion (P Q : Prop) (adopted : P) (derivation : P → Q) : Q
MathlibDemo.lean:372:0
'LambdaConstitutive.declared_basis_allows_derived_conclusion' does not depend on any axioms
MathlibDemo.lean:373:0
LambdaConstitutive.derived_tag_alone_does_not_prove_claim :
  ¬∀ (P : Prop) (tag : LambdaConstitutive.Origin), tag = LambdaConstitutive.Origin.derived → P
MathlibDemo.lean:374:0
'LambdaConstitutive.derived_tag_alone_does_not_prove_claim' does not depend on any axioms
MathlibDemo.lean:375:0
LambdaConstitutive.append_record_preserves_prefix.{u_1} {R : Type u_1} (history : List R) (record : R) :
  List.take history.length (LambdaConstitutive.appendRecord history record) = history
MathlibDemo.lean:376:0
'LambdaConstitutive.append_record_preserves_prefix' depends on axioms: [propext]
MathlibDemo.lean:377:0
LambdaConstitutive.recording_protocol_has_a_holder.{u_1} {R : Type u_1} (e : LambdaConstitutive.ProtocolEntry R) :
  ∃ holder, holder = e.holder
MathlibDemo.lean:378:0
'LambdaConstitutive.recording_protocol_has_a_holder' does not depend on any axioms
MathlibDemo.lean:379:0
LambdaConstitutive.different_origin_rankings_need_no_absolute_comparator :
  ∃ first second, first false < first true ∧ second true < second false
MathlibDemo.lean:380:0
'LambdaConstitutive.different_origin_rankings_need_no_absolute_comparator' does not depend on any axioms
MathlibDemo.lean:381:0
"4.34.0-rc2"
MathlibDemo.lean:382:0
"LAMBDA_CONSTITUTIVE_R2_COMPLETE"
MathlibDemo.lean:384:0
"4.34.0-rc2"
MathlibDemo.lean:385:0
"LAMBDA_R4_CONSTITUTIVE_END"
Restart File

Lean 4.34.0-rc2. Zero reported errors and warnings. Source SHA-256: 56946d09136d0b0aeffd31daace360a74ab5acc3e11575620d60a123b5562afc

Open this exact source in Lean

MathlibDemo.lean:1:0
No info found.
All Messages (56)
MathlibDemo.lean:231:0
"4.34.0-rc2"
MathlibDemo.lean:233:0
@LambdaCarriedState.remark_preserves_condition : ∀ {C : Type u_1} {R : Type u_2} (f : R → R)
  (s : LambdaCarriedState.Carried C R), (LambdaCarriedState.remark f s).condition = s.condition
MathlibDemo.lean:234:0
'LambdaCarriedState.remark_preserves_condition' does not depend on any axioms
MathlibDemo.lean:235:0
@LambdaCarriedState.remark_preserves_origin : ∀ {C : Type u_1} {R : Type u_2} (f : R → R)
  (s : LambdaCarriedState.Carried C R), (LambdaCarriedState.remark f s).origin = s.origin
MathlibDemo.lean:236:0
'LambdaCarriedState.remark_preserves_origin' does not depend on any axioms
MathlibDemo.lean:237:0
@LambdaCarriedState.repeated_remarking_preserves_condition : ∀ {C : Type u_1} {R : Type u_2} (fs : List (R → R))
  (s : LambdaCarriedState.Carried C R),
  (List.foldl (fun st f => LambdaCarriedState.remark f st) s fs).condition = s.condition
MathlibDemo.lean:238:0
'LambdaCarriedState.repeated_remarking_preserves_condition' does not depend on any axioms
MathlibDemo.lean:239:0
@LambdaCarriedState.recording_inherited_state_does_not_rewrite_origin : ∀ {C : Type u_1} {R : Type u_2}
  (s : LambdaCarriedState.Carried C R),
  s.origin = LambdaCarriedState.Origin.inherited →
    ∀ (f : R → R), (LambdaCarriedState.remark f s).origin = LambdaCarriedState.Origin.inherited
MathlibDemo.lean:240:0
'LambdaCarriedState.recording_inherited_state_does_not_rewrite_origin' does not depend on any axioms
MathlibDemo.lean:241:0
@LambdaCarriedState.equal_observation_blocks_target : ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} (observe : X → Y)
  (target : X → Z) {a b : X}, observe a = observe b → target a ≠ target b → ¬LambdaCarriedState.Recovers observe target
MathlibDemo.lean:242:0
'LambdaCarriedState.equal_observation_blocks_target' does not depend on any axioms
MathlibDemo.lean:243:0
LambdaCarriedState.identical_descriptions_can_hide_distinct_conditions : ¬LambdaCarriedState.Recovers
    (fun s => s.record) fun s => s.condition
MathlibDemo.lean:244:0
'LambdaCarriedState.identical_descriptions_can_hide_distinct_conditions' does not depend on any axioms
MathlibDemo.lean:245:0
LambdaCarriedState.content_does_not_determine_origin : ¬LambdaCarriedState.Recovers (fun s => s.record) fun s =>
    s.origin
MathlibDemo.lean:246:0
'LambdaCarriedState.content_does_not_determine_origin' does not depend on any axioms
MathlibDemo.lean:247:0
@LambdaCarriedState.enlarged_observation_can_recover_condition : ∀ {C : Type u_1} {R : Type u_2},
  LambdaCarriedState.Recovers (fun s => (s.record, s.condition)) fun s => s.condition
MathlibDemo.lean:248:0
'LambdaCarriedState.enlarged_observation_can_recover_condition' does not depend on any axioms
MathlibDemo.lean:249:0
LambdaCarriedState.exact_access_does_not_supply_intervention : LambdaCarriedState.Recovers id id ∧
  ∀ (x : Bool), ¬LambdaCarriedState.CanChange (fun x s => s) x
MathlibDemo.lean:250:0
'LambdaCarriedState.exact_access_does_not_supply_intervention' does not depend on any axioms
MathlibDemo.lean:251:0
LambdaCarriedState.intervention_does_not_supply_exact_access : (∀ (x : Bool),
    LambdaCarriedState.CanChange (fun x s => !s) x) ∧
  ¬LambdaCarriedState.Recovers (fun x => ()) id
MathlibDemo.lean:252:0
'LambdaCarriedState.intervention_does_not_supply_exact_access' does not depend on any axioms
MathlibDemo.lean:253:0
@LambdaCarriedState.invariant_survives_available_interventions : ∀ {X : Type u_1} {A : Type u_2} (act : A → X → X)
  (p : X → Prop),
  (∀ (a : A) (x : X), p x → p (act a x)) →
    ∀ (x : X), p x → ∀ (as : List A), p (LambdaCarriedState.applyActions act x as)
MathlibDemo.lean:254:0
'LambdaCarriedState.invariant_survives_available_interventions' does not depend on any axioms
MathlibDemo.lean:255:0
@LambdaCarriedState.invariant_obstructs_revision_path : ∀ {X : Type u_1} {A : Type u_2} (act : A → X → X)
  (p : X → Prop),
  (∀ (a : A) (x : X), p x → p (act a x)) → ∀ (x y : X), p x → ¬p y → ¬∃ as, LambdaCarriedState.applyActions act x as = y
MathlibDemo.lean:256:0
'LambdaCarriedState.invariant_obstructs_revision_path' does not depend on any axioms
MathlibDemo.lean:257:0
@LambdaCarriedState.recovery_horizon_can_be_shortened : ∀ {X : Type u_1} {S : Type u_2} {Z : Type u_3}
  (encode : ℕ → X → S) (decode : ℕ → S → Z) (target : X → Z) {M N : ℕ},
  LambdaCarriedState.Through encode decode target N → M ≤ N → LambdaCarriedState.Through encode decode target M
MathlibDemo.lean:258:0
'LambdaCarriedState.recovery_horizon_can_be_shortened' does not depend on any axioms
MathlibDemo.lean:259:0
@LambdaCarriedState.target_preserving_transfer_gives_successor_recovery : ∀ {X : Type u_1} {S : Type u_2} {T : Type u_3}
  {Z : Type u_4} (old : X → S) (next : X → T) (transfer : S → T) (oldDecode : S → Z) (nextDecode : T → Z) (q : X → Z),
  (∀ (x : X), next x = transfer (old x)) →
    (∀ (x : X), nextDecode (transfer (old x)) = oldDecode (old x)) →
      (∀ (x : X), oldDecode (old x) = q x) → ∀ (x : X), nextDecode (next x) = q x
MathlibDemo.lean:260:0
'LambdaCarriedState.target_preserving_transfer_gives_successor_recovery' does not depend on any axioms
MathlibDemo.lean:261:0
@LambdaCarriedState.maintenance_contract_extends_recovery : ∀ {X : Type u_1} {S : Type u_2} {Z : Type u_3}
  (encode : ℕ → X → S) (decode : ℕ → S → Z) (target : X → Z),
  LambdaCarriedState.ExactAt encode decode target 0 →
    (∀ (t : ℕ),
        LambdaCarriedState.ExactAt encode decode target t → LambdaCarriedState.ExactAt encode decode target (t + 1)) →
      ∀ (t : ℕ), LambdaCarriedState.ExactAt encode decode target t
MathlibDemo.lean:262:0
'LambdaCarriedState.maintenance_contract_extends_recovery' does not depend on any axioms
MathlibDemo.lean:263:0
LambdaCarriedState.maintained_hypotheses_give_conditional_continuity : ∀ (sound maintained : ℕ → Prop),
  sound 0 → (∀ (t : ℕ), sound t → maintained t → sound (t + 1)) → (∀ (t : ℕ), maintained t) → ∀ (t : ℕ), sound t
MathlibDemo.lean:264:0
'LambdaCarriedState.maintained_hypotheses_give_conditional_continuity' does not depend on any axioms
MathlibDemo.lean:265:0
LambdaCarriedState.finite_successful_prefix : ∀ (N : ℕ),
  LambdaCarriedState.Through (LambdaCarriedState.expiresAfter N) (fun x => id) id N
MathlibDemo.lean:266:0
'LambdaCarriedState.finite_successful_prefix' depends on axioms: [propext]
MathlibDemo.lean:267:0
LambdaCarriedState.prefix_agreement_can_hide_later_divergence : ∀ (N : ℕ),
  (∀ t ≤ N, ∀ (x : Bool), LambdaCarriedState.expiresAfter N t x = x) ∧
    LambdaCarriedState.expiresAfter N (N + 1) true ≠ true
MathlibDemo.lean:268:0
'LambdaCarriedState.prefix_agreement_can_hide_later_divergence' depends on axioms: [propext,
 Classical.choice,
 Quot.sound]
MathlibDemo.lean:269:0
LambdaCarriedState.loss_after_horizon_has_no_replacement_decoder : ∀ (N : ℕ),
  ¬LambdaCarriedState.Recovers (LambdaCarriedState.expiresAfter N (N + 1)) id
MathlibDemo.lean:270:0
'LambdaCarriedState.loss_after_horizon_has_no_replacement_decoder' depends on axioms: [propext,
 Classical.choice,
 Quot.sound]
MathlibDemo.lean:271:0
LambdaCarriedState.no_finite_prefix_certificate_of_permanence : ∀ (N : ℕ),
  ¬∀ (encode : ℕ → Bool → Bool),
      LambdaCarriedState.Through encode (fun x => id) id N →
        ∀ (t : ℕ), LambdaCarriedState.ExactAt encode (fun x => id) id t
MathlibDemo.lean:272:0
'LambdaCarriedState.no_finite_prefix_certificate_of_permanence' depends on axioms: [propext,
 Classical.choice,
 Quot.sound]
MathlibDemo.lean:273:0
LambdaCarriedState.permanent_ideal_model_is_also_consistent_with_prefix : ∃ encode,
  ∀ (t : ℕ), LambdaCarriedState.ExactAt encode (fun x => id) id t
MathlibDemo.lean:274:0
'LambdaCarriedState.permanent_ideal_model_is_also_consistent_with_prefix' does not depend on any axioms
MathlibDemo.lean:275:0
@LambdaCarriedState.collision_survives_later_transfer : ∀ {X : Type u_1} {S : Type u_2} {T : Type u_3} {Z : Type u_4}
  (encode : X → S) (transfer : S → T) (target : X → Z) {a b : X},
  encode a = encode b → target a ≠ target b → ¬LambdaCarriedState.Recovers (transfer ∘ encode) target
MathlibDemo.lean:276:0
'LambdaCarriedState.collision_survives_later_transfer' does not depend on any axioms
MathlibDemo.lean:277:0
@LambdaCarriedState.budget_forces_an_omitted_commitment : ∀ {I : Type u_1} [DecidableEq I]
  (required retained : Finset I) (B : ℕ), retained.card ≤ B → B < required.card → ∃ i ∈ required, i ∉ retained
MathlibDemo.lean:278:0
'LambdaCarriedState.budget_forces_an_omitted_commitment' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:279:0
LambdaCarriedState.equal_budget_does_not_select_priority : ∃ a b, a.card ≤ 1 ∧ b.card ≤ 1 ∧ a ≠ b
MathlibDemo.lean:280:0
'LambdaCarriedState.equal_budget_does_not_select_priority' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:281:0
@LambdaCarriedState.exact_target_requires_sufficient_carrier_states : ∀ {X : Type u_1} {S : Type u_2} [inst : Fintype X]
  [inst_1 : Fintype S] (encode : X → S) (decode : S → X),
  (∀ (x : X), decode (encode x) = x) → Fintype.card X ≤ Fintype.card S
MathlibDemo.lean:282:0
'LambdaCarriedState.exact_target_requires_sufficient_carrier_states' depends on axioms: [propext,
 Classical.choice,
 Quot.sound]
MathlibDemo.lean:283:0
@LambdaCarriedState.finite_carrier_can_preserve_selected_target : ∀ {R : Type u_1},
  LambdaCarriedState.Recovers (fun h => h.1) fun h => h.1
MathlibDemo.lean:284:0
'LambdaCarriedState.finite_carrier_can_preserve_selected_target' does not depend on any axioms
MathlibDemo.lean:286:0
"LAMBDA_R3_END_OF_CHECK"
MathlibDemo.lean:288:0
"4.34.0-rc2"
MathlibDemo.lean:289:0
"LAMBDA_R4_CARRIEDSTATE_END"
Restart File

Lean 4.34.0-rc2. Zero reported errors and warnings. Source SHA-256: b8c6421fce2df48e774e993b2e85a5bf0646539f48064dbe38d3ab1462fe862b

Open this exact source in Lean

MathlibDemo.lean:1:0
No info found.
All Messages ( 10)
MathlibDemo.lean:65:0
LambdaInstitutionalSignals.signal_crosses_declared_threshold : ∀ (evidence signal threshold : ℕ),
  evidence < threshold →
    threshold ≤ evidence + signal →
      ¬LambdaInstitutionalSignals.thresholdAccepts evidence 0 threshold ∧
        LambdaInstitutionalSignals.thresholdAccepts evidence signal threshold
MathlibDemo.lean:66:0
'LambdaInstitutionalSignals.signal_crosses_declared_threshold' depends on axioms: [propext, Quot.sound]
MathlibDemo.lean:67:0
LambdaInstitutionalSignals.observed_acceptance_does_not_identify_dependence : ∃ f g,
  LambdaInstitutionalSignals.observedAcceptance f = LambdaInstitutionalSignals.observedAcceptance g ∧
    LambdaInstitutionalSignals.SignalDependent f ∧ ¬LambdaInstitutionalSignals.SignalDependent g
MathlibDemo.lean:68:0
'LambdaInstitutionalSignals.observed_acceptance_does_not_identify_dependence' depends on axioms: [propext]
MathlibDemo.lean:69:0
LambdaInstitutionalSignals.no_dependence_decoder_from_observed_acceptance : ¬∃ decode,
    ∀ (response : Bool → Bool),
      decode (LambdaInstitutionalSignals.observedAcceptance response) = decide (response true ≠ response false)
MathlibDemo.lean:70:0
'LambdaInstitutionalSignals.no_dependence_decoder_from_observed_acceptance' depends on axioms: [propext]
MathlibDemo.lean:71:0
LambdaInstitutionalSignals.recognition_does_not_determine_truth_or_eligibility : ∃ a b,
  a.publicRecognition = b.publicRecognition ∧ a.claimTruth ≠ b.claimTruth ∧ a.eligible ≠ b.eligible
MathlibDemo.lean:72:0
'LambdaInstitutionalSignals.recognition_does_not_determine_truth_or_eligibility' does not depend on any axioms
MathlibDemo.lean:73:0
"4.34.0-rc2"
MathlibDemo.lean:74:0
"LAMBDA_R4_INSTITUTIONALSIGNALS_END"
Restart File

These retain their original dates. They are preserved as history and are excluded from the five fresh R4 execution count.

MathlibDemo.lean:1:0
No info found.
All Messages (54)
MathlibDemo.lean:231:0
"4.34.0-rc2"
MathlibDemo.lean:233:0
@LambdaCarriedState.remark_preserves_condition : ∀ {C : Type u_1} {R : Type u_2} (f : R → R)
  (s : LambdaCarriedState.Carried C R), (LambdaCarriedState.remark f s).condition = s.condition
MathlibDemo.lean:234:0
'LambdaCarriedState.remark_preserves_condition' does not depend on any axioms
MathlibDemo.lean:235:0
@LambdaCarriedState.remark_preserves_origin : ∀ {C : Type u_1} {R : Type u_2} (f : R → R)
  (s : LambdaCarriedState.Carried C R), (LambdaCarriedState.remark f s).origin = s.origin
MathlibDemo.lean:236:0
'LambdaCarriedState.remark_preserves_origin' does not depend on any axioms
MathlibDemo.lean:237:0
@LambdaCarriedState.repeated_remarking_preserves_condition : ∀ {C : Type u_1} {R : Type u_2} (fs : List (R → R))
  (s : LambdaCarriedState.Carried C R),
  (List.foldl (fun st f => LambdaCarriedState.remark f st) s fs).condition = s.condition
MathlibDemo.lean:238:0
'LambdaCarriedState.repeated_remarking_preserves_condition' does not depend on any axioms
MathlibDemo.lean:239:0
@LambdaCarriedState.recording_inherited_state_does_not_rewrite_origin : ∀ {C : Type u_1} {R : Type u_2}
  (s : LambdaCarriedState.Carried C R),
  s.origin = LambdaCarriedState.Origin.inherited →
    ∀ (f : R → R), (LambdaCarriedState.remark f s).origin = LambdaCarriedState.Origin.inherited
MathlibDemo.lean:240:0
'LambdaCarriedState.recording_inherited_state_does_not_rewrite_origin' does not depend on any axioms
MathlibDemo.lean:241:0
@LambdaCarriedState.equal_observation_blocks_target : ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} (observe : X → Y)
  (target : X → Z) {a b : X}, observe a = observe b → target a ≠ target b → ¬LambdaCarriedState.Recovers observe target
MathlibDemo.lean:242:0
'LambdaCarriedState.equal_observation_blocks_target' does not depend on any axioms
MathlibDemo.lean:243:0
LambdaCarriedState.identical_descriptions_can_hide_distinct_conditions : ¬LambdaCarriedState.Recovers
    (fun s => s.record) fun s => s.condition
MathlibDemo.lean:244:0
'LambdaCarriedState.identical_descriptions_can_hide_distinct_conditions' does not depend on any axioms
MathlibDemo.lean:245:0
LambdaCarriedState.content_does_not_determine_origin : ¬LambdaCarriedState.Recovers (fun s => s.record) fun s =>
    s.origin
MathlibDemo.lean:246:0
'LambdaCarriedState.content_does_not_determine_origin' does not depend on any axioms
MathlibDemo.lean:247:0
@LambdaCarriedState.enlarged_observation_can_recover_condition : ∀ {C : Type u_1} {R : Type u_2},
  LambdaCarriedState.Recovers (fun s => (s.record, s.condition)) fun s => s.condition
MathlibDemo.lean:248:0
'LambdaCarriedState.enlarged_observation_can_recover_condition' does not depend on any axioms
MathlibDemo.lean:249:0
LambdaCarriedState.exact_access_does_not_supply_intervention : LambdaCarriedState.Recovers id id ∧
  ∀ (x : Bool), ¬LambdaCarriedState.CanChange (fun x s => s) x
MathlibDemo.lean:250:0
'LambdaCarriedState.exact_access_does_not_supply_intervention' does not depend on any axioms
MathlibDemo.lean:251:0
LambdaCarriedState.intervention_does_not_supply_exact_access : (∀ (x : Bool),
    LambdaCarriedState.CanChange (fun x s => !s) x) ∧
  ¬LambdaCarriedState.Recovers (fun x => ()) id
MathlibDemo.lean:252:0
'LambdaCarriedState.intervention_does_not_supply_exact_access' does not depend on any axioms
MathlibDemo.lean:253:0
@LambdaCarriedState.invariant_survives_available_interventions : ∀ {X : Type u_1} {A : Type u_2} (act : A → X → X)
  (p : X → Prop),
  (∀ (a : A) (x : X), p x → p (act a x)) →
    ∀ (x : X), p x → ∀ (as : List A), p (LambdaCarriedState.applyActions act x as)
MathlibDemo.lean:254:0
'LambdaCarriedState.invariant_survives_available_interventions' does not depend on any axioms
MathlibDemo.lean:255:0
@LambdaCarriedState.invariant_obstructs_revision_path : ∀ {X : Type u_1} {A : Type u_2} (act : A → X → X)
  (p : X → Prop),
  (∀ (a : A) (x : X), p x → p (act a x)) → ∀ (x y : X), p x → ¬p y → ¬∃ as, LambdaCarriedState.applyActions act x as = y
MathlibDemo.lean:256:0
'LambdaCarriedState.invariant_obstructs_revision_path' does not depend on any axioms
MathlibDemo.lean:257:0
@LambdaCarriedState.recovery_horizon_can_be_shortened : ∀ {X : Type u_1} {S : Type u_2} {Z : Type u_3}
  (encode : ℕ → X → S) (decode : ℕ → S → Z) (target : X → Z) {M N : ℕ},
  LambdaCarriedState.Through encode decode target N → M ≤ N → LambdaCarriedState.Through encode decode target M
MathlibDemo.lean:258:0
'LambdaCarriedState.recovery_horizon_can_be_shortened' does not depend on any axioms
MathlibDemo.lean:259:0
@LambdaCarriedState.target_preserving_transfer_gives_successor_recovery : ∀ {X : Type u_1} {S : Type u_2} {T : Type u_3}
  {Z : Type u_4} (old : X → S) (next : X → T) (transfer : S → T) (oldDecode : S → Z) (nextDecode : T → Z) (q : X → Z),
  (∀ (x : X), next x = transfer (old x)) →
    (∀ (x : X), nextDecode (transfer (old x)) = oldDecode (old x)) →
      (∀ (x : X), oldDecode (old x) = q x) → ∀ (x : X), nextDecode (next x) = q x
MathlibDemo.lean:260:0
'LambdaCarriedState.target_preserving_transfer_gives_successor_recovery' does not depend on any axioms
MathlibDemo.lean:261:0
@LambdaCarriedState.maintenance_contract_extends_recovery : ∀ {X : Type u_1} {S : Type u_2} {Z : Type u_3}
  (encode : ℕ → X → S) (decode : ℕ → S → Z) (target : X → Z),
  LambdaCarriedState.ExactAt encode decode target 0 →
    (∀ (t : ℕ),
        LambdaCarriedState.ExactAt encode decode target t → LambdaCarriedState.ExactAt encode decode target (t + 1)) →
      ∀ (t : ℕ), LambdaCarriedState.ExactAt encode decode target t
MathlibDemo.lean:262:0
'LambdaCarriedState.maintenance_contract_extends_recovery' does not depend on any axioms
MathlibDemo.lean:263:0
LambdaCarriedState.maintained_hypotheses_give_conditional_continuity : ∀ (sound maintained : ℕ → Prop),
  sound 0 → (∀ (t : ℕ), sound t → maintained t → sound (t + 1)) → (∀ (t : ℕ), maintained t) → ∀ (t : ℕ), sound t
MathlibDemo.lean:264:0
'LambdaCarriedState.maintained_hypotheses_give_conditional_continuity' does not depend on any axioms
MathlibDemo.lean:265:0
LambdaCarriedState.finite_successful_prefix : ∀ (N : ℕ),
  LambdaCarriedState.Through (LambdaCarriedState.expiresAfter N) (fun x => id) id N
MathlibDemo.lean:266:0
'LambdaCarriedState.finite_successful_prefix' depends on axioms: [propext]
MathlibDemo.lean:267:0
LambdaCarriedState.prefix_agreement_can_hide_later_divergence : ∀ (N : ℕ),
  (∀ t ≤ N, ∀ (x : Bool), LambdaCarriedState.expiresAfter N t x = x) ∧
    LambdaCarriedState.expiresAfter N (N + 1) true ≠ true
MathlibDemo.lean:268:0
'LambdaCarriedState.prefix_agreement_can_hide_later_divergence' depends on axioms: [propext,
 Classical.choice,
 Quot.sound]
MathlibDemo.lean:269:0
LambdaCarriedState.loss_after_horizon_has_no_replacement_decoder : ∀ (N : ℕ),
  ¬LambdaCarriedState.Recovers (LambdaCarriedState.expiresAfter N (N + 1)) id
MathlibDemo.lean:270:0
'LambdaCarriedState.loss_after_horizon_has_no_replacement_decoder' depends on axioms: [propext,
 Classical.choice,
 Quot.sound]
MathlibDemo.lean:271:0
LambdaCarriedState.no_finite_prefix_certificate_of_permanence : ∀ (N : ℕ),
  ¬∀ (encode : ℕ → Bool → Bool),
      LambdaCarriedState.Through encode (fun x => id) id N →
        ∀ (t : ℕ), LambdaCarriedState.ExactAt encode (fun x => id) id t
MathlibDemo.lean:272:0
'LambdaCarriedState.no_finite_prefix_certificate_of_permanence' depends on axioms: [propext,
 Classical.choice,
 Quot.sound]
MathlibDemo.lean:273:0
LambdaCarriedState.permanent_ideal_model_is_also_consistent_with_prefix : ∃ encode,
  ∀ (t : ℕ), LambdaCarriedState.ExactAt encode (fun x => id) id t
MathlibDemo.lean:274:0
'LambdaCarriedState.permanent_ideal_model_is_also_consistent_with_prefix' does not depend on any axioms
MathlibDemo.lean:275:0
@LambdaCarriedState.collision_survives_later_transfer : ∀ {X : Type u_1} {S : Type u_2} {T : Type u_3} {Z : Type u_4}
  (encode : X → S) (transfer : S → T) (target : X → Z) {a b : X},
  encode a = encode b → target a ≠ target b → ¬LambdaCarriedState.Recovers (transfer ∘ encode) target
MathlibDemo.lean:276:0
'LambdaCarriedState.collision_survives_later_transfer' does not depend on any axioms
MathlibDemo.lean:277:0
@LambdaCarriedState.budget_forces_an_omitted_commitment : ∀ {I : Type u_1} [DecidableEq I]
  (required retained : Finset I) (B : ℕ), retained.card ≤ B → B < required.card → ∃ i ∈ required, i ∉ retained
MathlibDemo.lean:278:0
'LambdaCarriedState.budget_forces_an_omitted_commitment' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:279:0
LambdaCarriedState.equal_budget_does_not_select_priority : ∃ a b, a.card ≤ 1 ∧ b.card ≤ 1 ∧ a ≠ b
MathlibDemo.lean:280:0
'LambdaCarriedState.equal_budget_does_not_select_priority' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:281:0
@LambdaCarriedState.exact_target_requires_sufficient_carrier_states : ∀ {X : Type u_1} {S : Type u_2} [inst : Fintype X]
  [inst_1 : Fintype S] (encode : X → S) (decode : S → X),
  (∀ (x : X), decode (encode x) = x) → Fintype.card X ≤ Fintype.card S
MathlibDemo.lean:282:0
'LambdaCarriedState.exact_target_requires_sufficient_carrier_states' depends on axioms: [propext,
 Classical.choice,
 Quot.sound]
MathlibDemo.lean:283:0
@LambdaCarriedState.finite_carrier_can_preserve_selected_target : ∀ {R : Type u_1},
  LambdaCarriedState.Recovers (fun h => h.1) fun h => h.1
MathlibDemo.lean:284:0
'LambdaCarriedState.finite_carrier_can_preserve_selected_target' does not depend on any axioms
MathlibDemo.lean:286:0
"LAMBDA_R3_END_OF_CHECK"
Restart File

MathlibDemo.lean:1:0
No info found.
All Messages ( 257)
MathlibDemo.lean:464:0
LambdaInstrument.recovery_iff_fibre_constancy.{u_1, u_2, u_3} {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [Nonempty Z]
  (read : X → Y) (target : X → Z) :
  LambdaInstrument.Recoverable read target ↔ ∀ (x y : X), read x = read y → target x = target y
MathlibDemo.lean:465:0
'LambdaInstrument.recovery_iff_fibre_constancy' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:466:0
LambdaInstrument.collision_blocks_recovery.{u_1, u_2, u_3} {X : Type u_1} {Y : Type u_2} {Z : Type u_3} (read : X → Y)
  (target : X → Z) {a b : X} (same : read a = read b) (split : target a ≠ target b) :
  ¬LambdaInstrument.Recoverable read target
MathlibDemo.lean:467:0
'LambdaInstrument.collision_blocks_recovery' does not depend on any axioms
MathlibDemo.lean:468:0
LambdaInstrument.postprocessing_preserves_collision.{u_1, u_2, u_3} {X : Type u_1} {Y : Type u_2} {Z : Type u_3}
  (read : X → Y) (post : Y → Z) {a b : X} (h : read a = read b) : post (read a) = post (read b)
MathlibDemo.lean:469:0
'LambdaInstrument.postprocessing_preserves_collision' does not depend on any axioms
MathlibDemo.lean:470:0
LambdaInstrument.enriched_readout_recovers_target.{u_1, u_2, u_3} {X : Type u_1} {Y : Type u_2} {Z : Type u_3}
  (read : X → Y) (target : X → Z) : LambdaInstrument.Recoverable (fun x ↦ (read x, target x)) target
MathlibDemo.lean:471:0
'LambdaInstrument.enriched_readout_recovers_target' does not depend on any axioms
MathlibDemo.lean:472:0
LambdaInstrument.one_sided_certificate_contract.{u_1, u_2} {X : Type u_1} {Y : Type u_2} (read : X → Y)
  (fires : Y → Prop) (target : X → Prop) :
  (∀ (x : X), fires (read x) → target x) ↔ {x | fires (read x)} ⊆ {x | target x}
MathlibDemo.lean:473:0
'LambdaInstrument.one_sided_certificate_contract' does not depend on any axioms
MathlibDemo.lean:474:0
LambdaInstrument.entailed_condition_preserves_acceptance.{u_1} {X : Type u_1} (accept condition : X → Prop)
  (h : ∀ (x : X), accept x → condition x) (x : X) : accept x ∧ condition x ↔ accept x
MathlibDemo.lean:475:0
'LambdaInstrument.entailed_condition_preserves_acceptance' does not depend on any axioms
MathlibDemo.lean:476:0
LambdaInstrument.new_condition_changes_acceptance.{u_1} {X : Type u_1} (accept condition : X → Prop) {x : X}
  (ha : accept x) (hc : ¬condition x) : ¬∀ (y : X), accept y ∧ condition y ↔ accept y
MathlibDemo.lean:477:0
'LambdaInstrument.new_condition_changes_acceptance' does not depend on any axioms
MathlibDemo.lean:478:0
LambdaInstrument.equal_declared_inputs_equal_outputs.{u_1, u_2, u_3} {X : Type u_1} {Y : Type u_2} {Z : Type u_3}
  (read : X → Y) (judge : X → Z) (h : LambdaInstrument.Recoverable read judge) {a b : X} (same : read a = read b) :
  judge a = judge b
MathlibDemo.lean:479:0
'LambdaInstrument.equal_declared_inputs_equal_outputs' does not depend on any axioms
MathlibDemo.lean:480:0
LambdaInstrument.different_outputs_require_distinction.{u_1, u_2, u_3} {X : Type u_1} {Y : Type u_2} {Z : Type u_3}
  (read : X → Y) (judge : X → Z) (h : LambdaInstrument.Recoverable read judge) {a b : X} (split : judge a ≠ judge b) :
  read a ≠ read b
MathlibDemo.lean:481:0
'LambdaInstrument.different_outputs_require_distinction' does not depend on any axioms
MathlibDemo.lean:482:0
LambdaInstrument.no_refutation_is_not_a_general_proof :
  ¬∀ (certified : Prop → Prop) (P : Prop), (∀ (Q : Prop), certified Q → Q) → ¬certified ¬P → P
MathlibDemo.lean:483:0
'LambdaInstrument.no_refutation_is_not_a_general_proof' does not depend on any axioms
MathlibDemo.lean:484:0
LambdaInstrument.completeness_licenses_reversal (certified : Prop → Prop) (P : Prop)
  (completeAtNegation : ¬P → certified ¬P) (noRefutation : ¬certified ¬P) : P
MathlibDemo.lean:485:0
'LambdaInstrument.completeness_licenses_reversal' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:486:0
LambdaInstrument.existential_claim_needs_no_closed_form.{u_1} {X : Type u_1} (P : X → Prop) (construction : ∃ x, P x) :
  ¬∀ (x : X), ¬P x
MathlibDemo.lean:487:0
'LambdaInstrument.existential_claim_needs_no_closed_form' does not depend on any axioms
MathlibDemo.lean:488:0
LambdaInstrument.residual_equation_has_witness.{u_1, u_2} {X : Type u_1} {F : Type u_2} (residual : X → F) (x : X) :
  ∃ f, f = residual x
MathlibDemo.lean:489:0
'LambdaInstrument.residual_equation_has_witness' does not depend on any axioms
MathlibDemo.lean:490:0
LambdaInstrument.residual_admissibility_is_the_obligation.{u_1, u_2} {X : Type u_1} {F : Type u_2} (residual : X → F)
  (admitted : F → Prop) (x : X) : (∃ f, f = residual x ∧ admitted f) ↔ admitted (residual x)
MathlibDemo.lean:491:0
'LambdaInstrument.residual_admissibility_is_the_obligation' does not depend on any axioms
MathlibDemo.lean:492:0
LambdaInstrument.finite_window_has_opposite_extensions (N : ℕ) :
  ∃ good bad,
    LambdaInstrument.Window N good ∧
      LambdaInstrument.Window N bad ∧ LambdaInstrument.AllStages good ∧ ¬LambdaInstrument.AllStages bad
MathlibDemo.lean:493:0
'LambdaInstrument.finite_window_has_opposite_extensions' does not depend on any axioms
MathlibDemo.lean:494:0
LambdaInstrument.no_fixed_window_decides_unrestricted_tail (N : ℕ) :
  ¬∀ (P : ℕ → Prop), LambdaInstrument.Window N P → LambdaInstrument.AllStages P
MathlibDemo.lean:495:0
'LambdaInstrument.no_fixed_window_decides_unrestricted_tail' does not depend on any axioms
MathlibDemo.lean:496:0
LambdaInstrument.universal_proof_closes_all_windows (P : ℕ → Prop) (h : LambdaInstrument.AllStages P) (N : ℕ) :
  LambdaInstrument.Window N P
MathlibDemo.lean:497:0
'LambdaInstrument.universal_proof_closes_all_windows' does not depend on any axioms
MathlibDemo.lean:498:0
LambdaInstrument.all_windows_iff_all_stages (P : ℕ → Prop) :
  (∀ (N : ℕ), LambdaInstrument.Window N P) ↔ LambdaInstrument.AllStages P
MathlibDemo.lean:499:0
'LambdaInstrument.all_windows_iff_all_stages' does not depend on any axioms
MathlibDemo.lean:500:0
LambdaInstrument.actual_failure_refutes_tail (P : ℕ → Prop) {n : ℕ} (failure : ¬P n) : ¬LambdaInstrument.AllStages P
MathlibDemo.lean:501:0
'LambdaInstrument.actual_failure_refutes_tail' does not depend on any axioms
MathlibDemo.lean:502:0
LambdaInstrument.tail_negation_has_failure (P : ℕ → Prop) : ¬LambdaInstrument.AllStages P ↔ ∃ n, ¬P n
MathlibDemo.lean:503:0
'LambdaInstrument.tail_negation_has_failure' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:504:0
LambdaInstrument.unforced_failure_is_admitted_forced_failure.{u_1, u_2} {D : Type u_1} {F : Type u_2} (admD : D → Prop)
  (admF : F → Prop) (global : D → F → Prop) (zeroForce : F) (zeroAdmitted : admF zeroForce)
  (failure : ¬LambdaInstrument.NSGlobal admD global zeroForce) : LambdaInstrument.NSForcedFailure admD admF global
MathlibDemo.lean:505:0
'LambdaInstrument.unforced_failure_is_admitted_forced_failure' depends on axioms: [propext,
 Classical.choice,
 Quot.sound]
MathlibDemo.lean:506:0
LambdaInstrument.forced_failure_can_coexist_with_unforced_global :
  ∃ global,
    LambdaInstrument.NSGlobal (fun x ↦ True) global false ∧
      LambdaInstrument.NSForcedFailure (fun x ↦ True) (fun x ↦ True) global
MathlibDemo.lean:507:0
'LambdaInstrument.forced_failure_can_coexist_with_unforced_global' does not depend on any axioms
MathlibDemo.lean:508:0
LambdaInstrument.ns_regularity_requires_each_window.{u_1} {D : Type u_1} (window : D → ℕ → Prop) (d : D) :
  LambdaInstrument.NSRegular window d ↔ ∀ (N : ℕ), LambdaInstrument.Window N (window d)
MathlibDemo.lean:509:0
'LambdaInstrument.ns_regularity_requires_each_window' does not depend on any axioms
MathlibDemo.lean:510:0
LambdaInstrument.ns_uniform_bound_excludes_encoded_blowup.{u_1, u_2} {D : Type u_1} {Time : Type u_2}
  (before : D → Time → Prop) (size : D → Time → ℝ) (d : D) (bound : ∃ K, ∀ (t : Time), before d t → size d t ≤ K) :
  ¬LambdaInstrument.NSBlowup before size d
MathlibDemo.lean:511:0
'LambdaInstrument.ns_uniform_bound_excludes_encoded_blowup' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:512:0
LambdaInstrument.invariant_exact_classifier.{u_1} {X : Type u_1} (move : X → X) (H B : X → Prop)
  (equiv : ∀ (x : X), H x ↔ B x) (inv : ∀ (x : X), B (move x) ↔ B x) (x : X) : H (move x) ↔ H x
MathlibDemo.lean:513:0
'LambdaInstrument.invariant_exact_classifier' does not depend on any axioms
MathlibDemo.lean:514:0
LambdaInstrument.sufficient_condition_need_not_be_invariant :
  ∃ H B, (∀ (x : Bool), H x → B x) ∧ (∀ (x : Bool), B !x ↔ B x) ∧ ¬(H !false ↔ H false)
MathlibDemo.lean:515:0
'LambdaInstrument.sufficient_condition_need_not_be_invariant' depends on axioms: [propext]
MathlibDemo.lean:516:0
LambdaInstrument.rh_counterexample_duality.{u_1} {Zero : Type u_1} (nontrivial onLine : Zero → Prop) :
  ¬LambdaInstrument.RHForm nontrivial onLine ↔ ∃ z, nontrivial z ∧ ¬onLine z
MathlibDemo.lean:517:0
'LambdaInstrument.rh_counterexample_duality' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:518:0
LambdaInstrument.rh_tail_transport.{u_1} {Zero : Type u_1} (nontrivial onLine : Zero → Prop) (test : ℕ → Prop)
  (bridge : LambdaInstrument.RHForm nontrivial onLine ↔ LambdaInstrument.AllStages test) (closure : ∀ (n : ℕ), test n) :
  LambdaInstrument.RHForm nontrivial onLine
MathlibDemo.lean:519:0
'LambdaInstrument.rh_tail_transport' does not depend on any axioms
MathlibDemo.lean:520:0
LambdaInstrument.uniform_gap_implies_pointwise_positive.{u_1} {State : Type u_1} (excited : State → Prop)
  (energy : State → ℝ) (h : LambdaInstrument.UniformGap excited energy) (s : State) : excited s → 0 < energy s
MathlibDemo.lean:521:0
'LambdaInstrument.uniform_gap_implies_pointwise_positive' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:522:0
LambdaInstrument.pointwise_positive_need_not_have_uniform_gap :
  (∀ (x : { r // 0 < r }), 0 < ↑x) ∧ ¬LambdaInstrument.UniformGap (fun x ↦ True) fun x ↦ ↑x
MathlibDemo.lean:523:0
'LambdaInstrument.pointwise_positive_need_not_have_uniform_gap' depends on axioms: [propext,
 Classical.choice,
 Quot.sound]
MathlibDemo.lean:524:0
LambdaInstrument.common_gap_survives_order_limit.{u_1} {State : Type u_1} (excited : State → Prop) (energy : State → ℝ)
  (approx : ℕ → State → ℝ) (δ : ℝ) (positive : 0 < δ) (bounds : ∀ (n : ℕ) (s : State), excited s → δ ≤ approx n s)
  (passToLimit : ∀ (s : State), (∀ (n : ℕ), δ ≤ approx n s) → δ ≤ energy s) : LambdaInstrument.UniformGap excited energy
MathlibDemo.lean:525:0
'LambdaInstrument.common_gap_survives_order_limit' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:526:0
LambdaInstrument.hodge_actual_cycle_closes_instance.{u_1, u_2} {Instance : Type u_1} {Cycle : Type u_2}
  (represents : Cycle → Instance → Prop) (i : Instance) (c : Cycle) (certificate : represents c i) : ∃ w, represents w i
MathlibDemo.lean:527:0
'LambdaInstrument.hodge_actual_cycle_closes_instance' does not depend on any axioms
MathlibDemo.lean:528:0
LambdaInstrument.hodge_nonmembership_requires_all_cycles.{u_1, u_2} {Instance : Type u_1} {Cycle : Type u_2}
  (represents : Cycle → Instance → Prop) (i : Instance) : (¬∃ c, represents c i) ↔ ∀ (c : Cycle), ¬represents c i
MathlibDemo.lean:529:0
'LambdaInstrument.hodge_nonmembership_requires_all_cycles' depends on axioms: [propext]
MathlibDemo.lean:530:0
LambdaInstrument.hodge_separating_invariant_closes_nonmembership.{u_1, u_2} {Instance : Type u_1} {Cycle : Type u_2}
  (represents : Cycle → Instance → Prop) (invariant : Instance → Prop)
  (sound : ∀ (c : Cycle) (i : Instance), represents c i → invariant i) {i : Instance} (separates : ¬invariant i) :
  ¬∃ c, represents c i
MathlibDemo.lean:531:0
'LambdaInstrument.hodge_separating_invariant_closes_nonmembership' does not depend on any axioms
MathlibDemo.lean:532:0
LambdaInstrument.hodge_finite_empty_search_not_universal (S : Finset ℕ) :
  ∃ witness, (∀ n ∈ S, ¬witness n) ∧ ∃ n, witness n
MathlibDemo.lean:533:0
'LambdaInstrument.hodge_finite_empty_search_not_universal' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:534:0
LambdaInstrument.pnp_quantifier_duality.{u_1, u_2} {Candidate : Type u_1} {Input : Type u_2}
  (correct : Candidate → Input → Prop) :
  ¬LambdaInstrument.PolyCandidateForm correct ↔ ∀ (c : Candidate), ∃ x, ¬correct c x
MathlibDemo.lean:535:0
'LambdaInstrument.pnp_quantifier_duality' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:536:0
LambdaInstrument.pnp_candidate_with_all_input_proof_closes.{u_1, u_2} {Candidate : Type u_1} {Input : Type u_2}
  (correct : Candidate → Input → Prop) (c : Candidate) (allInputs : ∀ (x : Input), correct c x) :
  LambdaInstrument.PolyCandidateForm correct
MathlibDemo.lean:537:0
'LambdaInstrument.pnp_candidate_with_all_input_proof_closes' does not depend on any axioms
MathlibDemo.lean:538:0
LambdaInstrument.bounded_tests_do_not_prove_candidate (N : ℕ) :
  ∃ correct, (∀ n < N, correct () n) ∧ ¬LambdaInstrument.PolyCandidateForm correct
MathlibDemo.lean:539:0
'LambdaInstrument.bounded_tests_do_not_prove_candidate' does not depend on any axioms
MathlibDemo.lean:540:0
LambdaInstrument.bsd_matching_bounds_close_rank (rank lower upper : ℕ) (hl : lower ≤ rank) (hu : rank ≤ upper)
  (meet : lower = upper) : rank = lower
MathlibDemo.lean:541:0
'LambdaInstrument.bsd_matching_bounds_close_rank' depends on axioms: [propext, Quot.sound]
MathlibDemo.lean:542:0
LambdaInstrument.bsd_matching_certificates_close_instance (alg an lower upper : ℕ) (hl : lower ≤ alg) (hu : alg ≤ upper)
  (meet : lower = upper) (analytic : an = lower) : alg = an
MathlibDemo.lean:543:0
'LambdaInstrument.bsd_matching_certificates_close_instance' depends on axioms: [propext, Quot.sound]
MathlibDemo.lean:544:0
LambdaInstrument.exact_order_unique (a : ℕ → ℝ) {r s : ℕ} (hr : LambdaInstrument.ExactOrder a r)
  (hs : LambdaInstrument.ExactOrder a s) : r = s
MathlibDemo.lean:545:0
'LambdaInstrument.exact_order_unique' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:546:0
LambdaInstrument.nonzero_term_alone_not_exact_order : ∃ a, a 1 ≠ 0 ∧ ¬LambdaInstrument.ExactOrder a 1
MathlibDemo.lean:547:0
'LambdaInstrument.nonzero_term_alone_not_exact_order' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:548:0
LambdaInstrument.product_readout_loses_factor : ¬LambdaInstrument.Recoverable (fun p ↦ p.1 * p.2) Prod.fst
MathlibDemo.lean:549:0
'LambdaInstrument.product_readout_loses_factor' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:550:0
LambdaInstrument.anchored_product_recovers_factor (a b c : ℝ) (ha : a ≠ 0) (h : a * b = a * c) : b = c
MathlibDemo.lean:551:0
'LambdaInstrument.anchored_product_recovers_factor' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:552:0
LambdaInstrument.pi_outside_rational_image : ¬∃ q, ↑q = Real.pi
MathlibDemo.lean:553:0
'LambdaInstrument.pi_outside_rational_image' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:554:0
LambdaInstrument.pi_no_finite_base_fraction (a : ℤ) (b n : ℕ) : Real.pi ≠ ↑a / ↑b ^ n
MathlibDemo.lean:555:0
'LambdaInstrument.pi_no_finite_base_fraction' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:556:0
LambdaInstrument.irrational_can_have_arbitrarily_close_rationals (x ε : ℝ) (hε : 0 < ε) : ∃ q, 0 < ↑q - x ∧ ↑q - x < ε
MathlibDemo.lean:557:0
'LambdaInstrument.irrational_can_have_arbitrarily_close_rationals' depends on axioms: [propext,
 Classical.choice,
 Quot.sound]
MathlibDemo.lean:558:0
LambdaInstrument.transcendental_excludes_algebraic_representation (x : ℝ) (hx : Transcendental ℚ x) :
  ¬∃ y, IsAlgebraic ℚ y ∧ y = x
MathlibDemo.lean:559:0
'LambdaInstrument.transcendental_excludes_algebraic_representation' depends on axioms: [propext,
 Classical.choice,
 Quot.sound]
MathlibDemo.lean:560:0
LambdaInstrument.enlarged_real_polynomials_have_exact_root (x : ℝ) : ∃ p, p ≠ 0 ∧ Polynomial.eval x p = 0
MathlibDemo.lean:561:0
'LambdaInstrument.enlarged_real_polynomials_have_exact_root' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:562:0
LambdaInstrument.e_exceeds_every_finite_factorial_sum (n : ℕ) : ∑ i ∈ Finset.range n, 1 / ↑i.factorial < Real.exp 1
MathlibDemo.lean:563:0
'LambdaInstrument.e_exceeds_every_finite_factorial_sum' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:564:0
LambdaInstrument.e_algebraic_class_closure_contract (h : Transcendental ℚ (Real.exp 1)) (p : Polynomial ℚ) :
  p ≠ 0 → (Polynomial.aeval (Real.exp 1)) p ≠ 0
MathlibDemo.lean:565:0
'LambdaInstrument.e_algebraic_class_closure_contract' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:566:0
LambdaInstrument.consideration_has_an_applied_rule.{u_1, u_2, u_3} {C : Type u_1} {S : Type u_2} {E : Type u_3}
  (a : LambdaInstrument.Assessment C S E) : ∃ rule, rule a.scope a.evidence = a.verdict
MathlibDemo.lean:567:0
'LambdaInstrument.consideration_has_an_applied_rule' does not depend on any axioms
MathlibDemo.lean:568:0
LambdaInstrument.challenge_is_an_instance.{u_1, u_2, u_3} {C : Type u_1} {S : Type u_2} {E : Type u_3}
  (a : LambdaInstrument.Assessment C S E) (rejects : a.verdict = LambdaInstrument.Status.rejected) :
  a.rule a.scope a.evidence = LambdaInstrument.Status.rejected
MathlibDemo.lean:569:0
'LambdaInstrument.challenge_is_an_instance' does not depend on any axioms
MathlibDemo.lean:570:0
LambdaInstrument.shared_rule_scope_evidence_force_shared_status.{u_1, u_2, u_3} {C : Type u_1} {S : Type u_2}
  {E : Type u_3} (a b : LambdaInstrument.Assessment C S E) (hr : a.rule = b.rule) (hs : a.scope = b.scope)
  (he : a.evidence = b.evidence) : a.verdict = b.verdict
MathlibDemo.lean:571:0
'LambdaInstrument.shared_rule_scope_evidence_force_shared_status' does not depend on any axioms
MathlibDemo.lean:572:0
LambdaInstrument.same_evidence_can_support_different_declared_rules :
  ∃ a b, a.claim = b.claim ∧ a.scope = b.scope ∧ a.evidence = b.evidence ∧ a.verdict ≠ b.verdict
MathlibDemo.lean:573:0
'LambdaInstrument.same_evidence_can_support_different_declared_rules' does not depend on any axioms
MathlibDemo.lean:574:0
LambdaInstrument.receipt_does_not_certify_rule_soundness :
  ∃ a, a.claim = False ∧ a.verdict = LambdaInstrument.Status.accepted
MathlibDemo.lean:575:0
'LambdaInstrument.receipt_does_not_certify_rule_soundness' does not depend on any axioms
MathlibDemo.lean:576:0
LambdaInstrument.a_sound_rejection_can_defeat_a_claim (P : Prop) (soundRejection : ¬P) : ¬P
MathlibDemo.lean:577:0
'LambdaInstrument.a_sound_rejection_can_defeat_a_claim' does not depend on any axioms
MathlibDemo.lean:578:0
LambdaInstrument.any_finite_comment_can_be_registered (s : String) : ∃ r, r.text = s
MathlibDemo.lean:579:0
'LambdaInstrument.any_finite_comment_can_be_registered' does not depend on any axioms
MathlibDemo.lean:580:0
LambdaInstrument.append_preserves_earlier_records (history : List LambdaInstrument.Record)
  (r old : LambdaInstrument.Record) (h : old ∈ history) : old ∈ LambdaInstrument.append history r
MathlibDemo.lean:581:0
'LambdaInstrument.append_preserves_earlier_records' depends on axioms: [propext]
MathlibDemo.lean:582:0
LambdaInstrument.finite_registry_has_no_fixed_capacity (history : List LambdaInstrument.Record)
  (r : LambdaInstrument.Record) : (LambdaInstrument.append history r).length = history.length + 1
MathlibDemo.lean:583:0
'LambdaInstrument.finite_registry_has_no_fixed_capacity' depends on axioms: [propext]
MathlibDemo.lean:584:0
LambdaInstrument.declared_statuses_exhaustive (s : LambdaInstrument.Status) :
  s = LambdaInstrument.Status.accepted ∨
    s = LambdaInstrument.Status.rejected ∨ s = LambdaInstrument.Status.open ∨ s = LambdaInstrument.Status.scopeChange
MathlibDemo.lean:585:0
'LambdaInstrument.declared_statuses_exhaustive' depends on axioms: [propext]
MathlibDemo.lean:586:0
LambdaInstrument.stop_mode_contract.{u_1} {Actor : Type u_1} (s : LambdaInstrument.StopMode Actor) :
  (∃ b, ∃ (h : b = true), s = LambdaInstrument.StopMode.effective b h) ∨
    ∃ actor, s = LambdaInstrument.StopMode.declared actor
MathlibDemo.lean:587:0
'LambdaInstrument.stop_mode_contract' does not depend on any axioms
MathlibDemo.lean:588:0
"4.34.0-rc2"
MathlibDemo.lean:589:0
"LAMBDA_INSTRUMENT_R1"
MathlibDemo.lean:793:0
EnumerativeEnergy.prime_iff_no_intermediate_divisor (n : ℕ) (hn : 2 ≤ n) : Nat.Prime n ↔ ¬∃ d, d ∣ n ∧ 2 ≤ d ∧ d < n
MathlibDemo.lean:794:0
EnumerativeEnergy.prime_step_gcd_one (p k : ℕ) (hp : Nat.Prime p) (hk : 0 < k) (hkp : k < p) : p.gcd k = 1
MathlibDemo.lean:795:0
EnumerativeEnergy.shared_divisibility (n m d : ℕ) : d ∣ n.gcd m ↔ d ∣ n ∧ d ∣ m
MathlibDemo.lean:796:0
EnumerativeEnergy.simultaneous_return (n m t : ℕ) : n.lcm m ∣ t ↔ n ∣ t ∧ m ∣ t
MathlibDemo.lean:797:0
EnumerativeEnergy.relabeling_preserves_orbit.{u_1, u_2} {A : Type u_1} {B : Type u_2} (e : A ≃ B) (f : A → A) (n : ℕ)
  (x : A) : EnumerativeEnergy.orbit (fun y ↦ e (f (e.symm y))) n (e x) = e (EnumerativeEnergy.orbit f n x)
MathlibDemo.lean:798:0
EnumerativeEnergy.relabeling_preserves_return.{u_1, u_2} {A : Type u_1} {B : Type u_2} (e : A ≃ B) (f : A → A) (n : ℕ)
  (x : A) : EnumerativeEnergy.orbit (fun y ↦ e (f (e.symm y))) n (e x) = e x ↔ EnumerativeEnergy.orbit f n x = x
MathlibDemo.lean:799:0
EnumerativeEnergy.inversion_preserves_spectral_read (z : ℂ) :
  EnumerativeEnergy.spectralRead z⁻¹ = EnumerativeEnergy.spectralRead z
MathlibDemo.lean:800:0
EnumerativeEnergy.spectral_collision_has_two_branches (z w : ℂ) (hz : z ≠ 0) (hw : w ≠ 0)
  (h : EnumerativeEnergy.spectralRead z = EnumerativeEnergy.spectralRead w) : z = w ∨ z * w = 1
MathlibDemo.lean:801:0
EnumerativeEnergy.spectral_read_cannot_recover_phase (z : ℂ) (hz : z ≠ 0) (hd : z ≠ z⁻¹) :
  ¬∃ f, ∀ (w : ℂ), w ≠ 0 → f (EnumerativeEnergy.spectralRead w) = w
MathlibDemo.lean:802:0
EnumerativeEnergy.ordered_count_from_union_data.{u_1} {A : Type u_1} [DecidableEq A] (s t : Finset A) (g f : ℕ)
  (hs : s.card = g) (ht : t.card = g) (hi : (s ∩ t).card = f) : (s ∪ t).card = 2 * g - f
MathlibDemo.lean:803:0
EnumerativeEnergy.common_energy_shift_preserves_gaps (a b offset : ℝ) : a + offset - (b + offset) = a - b
MathlibDemo.lean:804:0
EnumerativeEnergy.calibration_rescaling_preserves_phase (scale energy time : ℝ) (hs : scale ≠ 0) :
  scale * energy * (time / scale) = energy * time
MathlibDemo.lean:805:0
EnumerativeEnergy.residue_monotone.{u_1} {A : Type u_1} (S T : Set A) (cost : A → ENNReal) (h : S ⊆ T) :
  EnumerativeEnergy.indexedResidue T cost ≤ EnumerativeEnergy.indexedResidue S cost
MathlibDemo.lean:806:0
EnumerativeEnergy.conservative_representation_preserves_theorems.{u_1, u_2} {P : Type u_1} {T : Type u_2}
  (R0 R1 : Set P) (conclusion : P → T) (expand : P → P) (hin : R0 ⊆ R1)
  (hex : ∀ p ∈ R1, expand p ∈ R0 ∧ conclusion (expand p) = conclusion p) (target : T) :
  (∃ p ∈ R0, conclusion p = target) ↔ ∃ p ∈ R1, conclusion p = target
MathlibDemo.lean:807:0
EnumerativeEnergy.pointwise_positivity_not_uniform :
  (∀ (x : ℝ), 0 < x → 0 < x) ∧ ¬∃ epsilon, 0 < epsilon ∧ ∀ (x : ℝ), 0 < x → epsilon ≤ x
MathlibDemo.lean:808:0
LambdaPhysical.boosted_time_needs_space (g b : ℝ) (hg : g ≠ 0) (hb : b ≠ 0) :
  ¬∃ f, ∀ (T x : ℝ), f T = LambdaPhysical.boostTime g b T x
MathlibDemo.lean:809:0
LambdaPhysical.boosted_space_needs_time (g b : ℝ) (hg : g ≠ 0) (hb : b ≠ 0) :
  ¬∃ f, ∀ (T x : ℝ), f x = LambdaPhysical.boostSpace g b T x
MathlibDemo.lean:810:0
LambdaPhysical.lorentz_interval_preserved (g b T x : ℝ) (hn : g ^ 2 * (1 - b ^ 2) = 1) :
  LambdaPhysical.interval (LambdaPhysical.boostTime g b T x) (LambdaPhysical.boostSpace g b T x) =
    LambdaPhysical.interval T x
MathlibDemo.lean:811:0
LambdaPhysical.lorentz_null_preserved (g b T x : ℝ) (hn : g ^ 2 * (1 - b ^ 2) = 1) :
  LambdaPhysical.interval (LambdaPhysical.boostTime g b T x) (LambdaPhysical.boostSpace g b T x) = 0 ↔
    LambdaPhysical.interval T x = 0
MathlibDemo.lean:812:0
LambdaPhysical.timelike_not_time_only : ¬∃ P, ∀ (T x : ℝ), P T ↔ LambdaPhysical.interval T x < 0
MathlibDemo.lean:813:0
LambdaPhysical.timelike_not_space_only : ¬∃ P, ∀ (T x : ℝ), P x ↔ LambdaPhysical.interval T x < 0
MathlibDemo.lean:814:0
LambdaPhysical.fixed_c_couples_unit_rescaling (c L U : ℝ) (hc : c ≠ 0) (hL : L ≠ 0) (h : c * U / L = c) : L = U
MathlibDemo.lean:815:0
LambdaPhysical.calibrated_ratios_determine_values.{u_1} {I : Type u_1} (r E F : I → ℝ) (anchor : ℝ)
  (hE : ∀ (i : I), E i = r i * anchor) (hF : ∀ (i : I), F i = r i * anchor) : E = F
MathlibDemo.lean:816:0
'EnumerativeEnergy.prime_iff_no_intermediate_divisor' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:817:0
'EnumerativeEnergy.prime_step_gcd_one' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:818:0
'EnumerativeEnergy.shared_divisibility' depends on axioms: [propext, Quot.sound]
MathlibDemo.lean:819:0
'EnumerativeEnergy.simultaneous_return' depends on axioms: [propext, Quot.sound]
MathlibDemo.lean:820:0
'EnumerativeEnergy.relabeling_preserves_orbit' depends on axioms: [propext, Quot.sound]
MathlibDemo.lean:821:0
'EnumerativeEnergy.relabeling_preserves_return' depends on axioms: [propext, Quot.sound]
MathlibDemo.lean:822:0
'EnumerativeEnergy.inversion_preserves_spectral_read' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:823:0
'EnumerativeEnergy.spectral_collision_has_two_branches' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:824:0
'EnumerativeEnergy.spectral_read_cannot_recover_phase' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:825:0
'EnumerativeEnergy.ordered_count_from_union_data' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:826:0
'EnumerativeEnergy.common_energy_shift_preserves_gaps' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:827:0
'EnumerativeEnergy.calibration_rescaling_preserves_phase' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:828:0
'EnumerativeEnergy.residue_monotone' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:829:0
'EnumerativeEnergy.conservative_representation_preserves_theorems' does not depend on any axioms
MathlibDemo.lean:830:0
'EnumerativeEnergy.pointwise_positivity_not_uniform' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:831:0
'LambdaPhysical.boosted_time_needs_space' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:832:0
'LambdaPhysical.boosted_space_needs_time' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:833:0
'LambdaPhysical.lorentz_interval_preserved' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:834:0
'LambdaPhysical.lorentz_null_preserved' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:835:0
'LambdaPhysical.timelike_not_time_only' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:836:0
'LambdaPhysical.timelike_not_space_only' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:837:0
'LambdaPhysical.fixed_c_couples_unit_rescaling' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:838:0
'LambdaPhysical.calibrated_ratios_determine_values' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:839:0
"4.34.0-rc2"
MathlibDemo.lean:840:0
"LAMBDA_PART_II_AUDIT_COMPLETE"
MathlibDemo.lean:1140:0
LambdaSpatiotemporal.source_target_roles_distinct : RefRole.source ≠ RefRole.target
MathlibDemo.lean:1141:0
LambdaSpatiotemporal.reference_polarity {X : Type} (x y : X) : asSource x ≠ asTarget y
MathlibDemo.lean:1142:0
LambdaSpatiotemporal.reflexive_reference_preserves_role_distinction {X : Type} (x : X) : asSource x ≠ asTarget x
MathlibDemo.lean:1143:0
LambdaSpatiotemporal.iterated_reference_polarity {X : Type} (x : X) (n : ℕ) : (n, asSource x) ≠ (n, asTarget x)
MathlibDemo.lean:1144:0
LambdaSpatiotemporal.nontrivial_criterion_exhibits_poles {X : Type} (criterion : X → Bool)
  (h : NontrivialCriterion criterion) : ∃ x y, SelfSide criterion x ∧ OtherSide criterion y
MathlibDemo.lean:1145:0
LambdaSpatiotemporal.nontrivial_criterion_exhibits_distinct_states {X : Type} (criterion : X → Bool)
  (h : NontrivialCriterion criterion) : ∃ x y, x ≠ y
MathlibDemo.lean:1146:0
LambdaSpatiotemporal.exclusion_is_criterion_relative {X : Type} (criterion : X → Prop) (x : X) :
  ExcludedBy criterion x ↔ ¬criterion x
MathlibDemo.lean:1147:0
LambdaSpatiotemporal.postprocessing_cannot_split_fibre {X Y Z : Type} (projection : X → Y) (g : Y → Z) {x₁ x₂ : X}
  (h : projection x₁ = projection x₂) : g (projection x₁) = g (projection x₂)
MathlibDemo.lean:1148:0
LambdaSpatiotemporal.target_difference_blocks_factorization {X Y Z : Type} (projection : X → Y) (target : X → Z)
  {x₁ x₂ : X} (hproj : projection x₁ = projection x₂) (htarget : target x₁ ≠ target x₂) :
  ¬FactorsThrough projection target
MathlibDemo.lean:1149:0
LambdaSpatiotemporal.target_exact_compression_can_lose_other_distinctions :
  ∃ compress target, FactorsThrough compress target ∧ ¬InjectiveMap compress
MathlibDemo.lean:1150:0
LambdaSpatiotemporal.residual_selection {J S : Type} (Admissible : J → Prop) (outcome : J → S) {j₁ j₂ : J}
  (h₁ : Admissible j₁) (h₂ : Admissible j₂) (hdiff : outcome j₁ ≠ outcome j₂) : ¬UniqueOutcome Admissible outcome
MathlibDemo.lean:1151:0
LambdaSpatiotemporal.residual_will_from_competing_admissible_procedures {J S : Type} (Admissible : J → Prop)
  (outcome : J → S) {chosen j₂ : J} (hchosen : Admissible chosen) (h₂ : Admissible j₂)
  (hdiff : outcome chosen ≠ outcome j₂) : ResidualWill Admissible outcome chosen
MathlibDemo.lean:1152:0
LambdaSpatiotemporal.SelectedCriterion {J X : Type} (criterionOf : J → X → Bool) (chosen : J) : X → Bool
MathlibDemo.lean:1153:0
LambdaSpatiotemporal.competing_admissible_criteria_not_uniquely_forced {J X : Type} (Admissible : J → Prop)
  (criterionOf : J → X → Bool) {j₁ j₂ : J} (h₁ : Admissible j₁) (h₂ : Admissible j₂)
  (hdiff : criterionOf j₁ ≠ criterionOf j₂) : ¬UniqueOutcome Admissible criterionOf
MathlibDemo.lean:1154:0
LambdaSpatiotemporal.complement_requirement_blocks_absolute_priority {C : Type} (Priority UsesComplement : C → Prop)
  (hbridge : ∀ (c : C), Priority c → UsesComplement c) : ¬∃ c, AbsolutePriority Priority UsesComplement c
MathlibDemo.lean:1155:0
LambdaSpatiotemporal.no_first_position {Claim : Type} (B : SpatiotemporalBridge Claim) :
  (¬∃ c, AbsoluteSpaceFirst B c) ∧ ¬∃ c, AbsoluteTimeFirst B c
MathlibDemo.lean:1156:0
LambdaSpatiotemporal.local_warrant_not_universal_in_general :
  SampleWarrant TwoFrame.local ∧ ¬UniversalWarrant SampleWarrant
MathlibDemo.lean:1157:0
LambdaSpatiotemporal.absolute_label_does_not_self_license : ¬∀ (Absolute : Prop → Prop) (p : Prop), Absolute p → p
MathlibDemo.lean:1158:0
LambdaSpatiotemporal.same_public_label : publicLabel Usage.original = publicLabel Usage.extended
MathlibDemo.lean:1159:0
LambdaSpatiotemporal.same_label_can_hide_different_meanings :
  publicLabel Usage.original = publicLabel Usage.extended ∧
    tinyMeaning Usage.original TinyState.marked ≠ tinyMeaning Usage.extended TinyState.marked
MathlibDemo.lean:1160:0
LambdaSpatiotemporal.predicate_preservation_composes {A B C : Type} (f : A → B) (g : B → C) (P : A → Prop)
  (Q : B → Prop) (R : C → Prop) (hAB : PreservesPredicate f P Q) (hBC : PreservesPredicate g Q R) :
  PreservesPredicate (fun a ↦ g (f a)) P R
MathlibDemo.lean:1161:0
LambdaSpatiotemporal.translations_need_not_commute : ∃ AB BC AC x, AC x ≠ BC (AB x)
MathlibDemo.lean:1162:0
LambdaSpatiotemporal.finite_budget_forces_tradeoff (costA costB allocA allocB budget : ℕ)
  (hDemand : budget < costA + costB) (hBudget : allocA + allocB ≤ budget) (hA : costA ≤ allocA) (hB : costB ≤ allocB) :
  False
MathlibDemo.lean:1163:0
LambdaSpatiotemporal.same_input_can_receive_different_interpretations : ∃ I₀ I₁ r, I₀ r ≠ I₁ r
MathlibDemo.lean:1165:0
'LambdaSpatiotemporal.source_target_roles_distinct' does not depend on any axioms
MathlibDemo.lean:1166:0
'LambdaSpatiotemporal.reference_polarity' does not depend on any axioms
MathlibDemo.lean:1167:0
'LambdaSpatiotemporal.reflexive_reference_preserves_role_distinction' does not depend on any axioms
MathlibDemo.lean:1168:0
'LambdaSpatiotemporal.iterated_reference_polarity' does not depend on any axioms
MathlibDemo.lean:1169:0
'LambdaSpatiotemporal.nontrivial_criterion_exhibits_poles' does not depend on any axioms
MathlibDemo.lean:1170:0
'LambdaSpatiotemporal.nontrivial_criterion_exhibits_distinct_states' does not depend on any axioms
MathlibDemo.lean:1171:0
'LambdaSpatiotemporal.exclusion_is_criterion_relative' does not depend on any axioms
MathlibDemo.lean:1172:0
'LambdaSpatiotemporal.postprocessing_cannot_split_fibre' does not depend on any axioms
MathlibDemo.lean:1173:0
'LambdaSpatiotemporal.target_difference_blocks_factorization' does not depend on any axioms
MathlibDemo.lean:1174:0
'LambdaSpatiotemporal.target_exact_compression_can_lose_other_distinctions' does not depend on any axioms
MathlibDemo.lean:1175:0
'LambdaSpatiotemporal.residual_selection' does not depend on any axioms
MathlibDemo.lean:1176:0
'LambdaSpatiotemporal.residual_will_from_competing_admissible_procedures' does not depend on any axioms
MathlibDemo.lean:1177:0
'LambdaSpatiotemporal.competing_admissible_criteria_not_uniquely_forced' does not depend on any axioms
MathlibDemo.lean:1178:0
'LambdaSpatiotemporal.complement_requirement_blocks_absolute_priority' does not depend on any axioms
MathlibDemo.lean:1179:0
'LambdaSpatiotemporal.no_first_position' does not depend on any axioms
MathlibDemo.lean:1180:0
'LambdaSpatiotemporal.local_warrant_not_universal_in_general' does not depend on any axioms
MathlibDemo.lean:1181:0
'LambdaSpatiotemporal.absolute_label_does_not_self_license' does not depend on any axioms
MathlibDemo.lean:1182:0
'LambdaSpatiotemporal.same_public_label' does not depend on any axioms
MathlibDemo.lean:1183:0
'LambdaSpatiotemporal.same_label_can_hide_different_meanings' does not depend on any axioms
MathlibDemo.lean:1184:0
'LambdaSpatiotemporal.predicate_preservation_composes' does not depend on any axioms
MathlibDemo.lean:1185:0
'LambdaSpatiotemporal.translations_need_not_commute' does not depend on any axioms
MathlibDemo.lean:1186:0
'LambdaSpatiotemporal.finite_budget_forces_tradeoff' does not depend on any axioms
MathlibDemo.lean:1187:0
'LambdaSpatiotemporal.same_input_can_receive_different_interpretations' does not depend on any axioms
MathlibDemo.lean:1189:0
"4.34.0-rc2"
MathlibDemo.lean:1190:0
"LAMBDA_SPATIOTEMPORAL_TRANSLATION_AUDIT_COMPLETE"
MathlibDemo.lean:1303:0
SemanticDeflation.deflation {X : Type} (A B P : X → Prop) (hA : ∀ (x : X), A x → ¬P x) (hB : ∃ x, B x ∧ P x) :
  ¬∀ (x : X), B x → A x
MathlibDemo.lean:1304:0
'SemanticDeflation.deflation' does not depend on any axioms
MathlibDemo.lean:1306:0
SemanticDeflation.constraint_loss {X : Type} (A B P : X → Prop) (hA : ∀ (x : X), A x → ¬P x) (hB : ∃ x, B x ∧ P x) :
  ∃ x, B x ∧ P x ∧ ¬A x
MathlibDemo.lean:1307:0
'SemanticDeflation.constraint_loss' does not depend on any axioms
MathlibDemo.lean:1309:0
SemanticDeflation.no_shared_definition {X : Type} (A B P : X → Prop) (hA : ∀ (x : X), A x → ¬P x)
  (hB : ∃ x, B x ∧ P x) : ¬∃ S, (∀ (x : X), S x ↔ A x) ∧ ∀ (x : X), S x ↔ B x
MathlibDemo.lean:1310:0
'SemanticDeflation.no_shared_definition' does not depend on any axioms
MathlibDemo.lean:1312:0
SemanticDeflation.same_meaning_conflict {X : Type} (S P : X → Prop) (hNo : ∀ (x : X), S x → ¬P x)
  (hYes : ∃ x, S x ∧ P x) : False
MathlibDemo.lean:1313:0
'SemanticDeflation.same_meaning_conflict' does not depend on any axioms
MathlibDemo.lean:1315:0
SemanticDeflation.original_inhabited : ∃ x, SemanticDeflation.Original x
MathlibDemo.lean:1316:0
'SemanticDeflation.original_inhabited' does not depend on any axioms
MathlibDemo.lean:1318:0
SemanticDeflation.original_excludes_trait (x : SemanticDeflation.State) :
  SemanticDeflation.Original x → ¬SemanticDeflation.HasTrait x
MathlibDemo.lean:1319:0
'SemanticDeflation.original_excludes_trait' does not depend on any axioms
MathlibDemo.lean:1321:0
SemanticDeflation.extended_admits_trait : ∃ x, SemanticDeflation.Extended x ∧ SemanticDeflation.HasTrait x
MathlibDemo.lean:1322:0
'SemanticDeflation.extended_admits_trait' does not depend on any axioms
MathlibDemo.lean:1324:0
SemanticDeflation.original_is_extended (x : SemanticDeflation.State) :
  SemanticDeflation.Original x → SemanticDeflation.Extended x
MathlibDemo.lean:1325:0
'SemanticDeflation.original_is_extended' does not depend on any axioms
MathlibDemo.lean:1327:0
SemanticDeflation.two_checked_branches_one_label :
  (∃ x, SemanticDeflation.meaning SemanticDeflation.Usage.original x) ∧
    (∀ (x : SemanticDeflation.State),
        SemanticDeflation.meaning SemanticDeflation.Usage.original x → ¬SemanticDeflation.HasTrait x) ∧
      (∃ x, SemanticDeflation.meaning SemanticDeflation.Usage.extended x ∧ SemanticDeflation.HasTrait x) ∧
        SemanticDeflation.publicLabel SemanticDeflation.Usage.original =
          SemanticDeflation.publicLabel SemanticDeflation.Usage.extended
MathlibDemo.lean:1328:0
'SemanticDeflation.two_checked_branches_one_label' does not depend on any axioms
MathlibDemo.lean:1330:0
SemanticDeflation.shared_label_does_not_preserve_meaning :
  SemanticDeflation.publicLabel SemanticDeflation.Usage.original =
      SemanticDeflation.publicLabel SemanticDeflation.Usage.extended ∧
    ¬∀ (x : SemanticDeflation.State),
        SemanticDeflation.meaning SemanticDeflation.Usage.original x ↔
          SemanticDeflation.meaning SemanticDeflation.Usage.extended x
MathlibDemo.lean:1331:0
'SemanticDeflation.shared_label_does_not_preserve_meaning' does not depend on any axioms
MathlibDemo.lean:1333:0
"4.34.0-rc2"
MathlibDemo.lean:1334:0
"SEMANTIC_DEFLATION_AUDIT_COMPLETE"
MathlibDemo.lean:1473:0
'UnwitnessableVerdict.refutation_is_witnessed' does not depend on any axioms
MathlibDemo.lean:1474:0
'UnwitnessableVerdict.vacuous_pass' does not depend on any axioms
MathlibDemo.lean:1475:0
'UnwitnessableVerdict.misscoped_says_equal' does not depend on any axioms
MathlibDemo.lean:1476:0
'UnwitnessableVerdict.misscoped_says_not_equal' does not depend on any axioms
MathlibDemo.lean:1477:0
'UnwitnessableVerdict.check_outcome_settled' does not depend on any axioms
MathlibDemo.lean:1501:0
UnwitnessableVerdict.refutation_is_witnessed {α : Type} (P : α → Prop) (a : α) (h : ¬P a) : ¬∀ (x : α), P x
MathlibDemo.lean:1502:0
UnwitnessableVerdict.vacuous_pass {α : Type} (H G : α → Prop) (empty : ∀ (x : α), ¬H x) (x : α) : H x → G x
MathlibDemo.lean:1503:0
UnwitnessableVerdict.misscoped_says_equal (n : ℕ) : n < 0 → n = n
MathlibDemo.lean:1504:0
UnwitnessableVerdict.misscoped_says_not_equal (n : ℕ) : n < 0 → n ≠ n
MathlibDemo.lean:1505:0
UnwitnessableVerdict.check_outcome_settled (b : Bool) :
  UnwitnessableVerdict.checkPasses b = true ∨ UnwitnessableVerdict.checkPasses b = false
MathlibDemo.lean:1507:0
"4.34.0-rc2"
MathlibDemo.lean:1508:0
"UNWITNESSABLE_VERDICT_AUDIT_COMPLETE"
Restart File

MathlibDemo.lean:1:0
No info found.
All Messages ( 74)
MathlibDemo.lean:309:0
LambdaConstitutive.role_positions_differ : LambdaConstitutive.Role.source ≠ LambdaConstitutive.Role.target
MathlibDemo.lean:310:0
'LambdaConstitutive.role_positions_differ' does not depend on any axioms
MathlibDemo.lean:311:0
LambdaConstitutive.one_carrier_can_fill_both_roles.{u_1} {X : Type u_1} (x : X) :
  ∃ placement, placement LambdaConstitutive.Role.source = placement LambdaConstitutive.Role.target
MathlibDemo.lean:312:0
'LambdaConstitutive.one_carrier_can_fill_both_roles' does not depend on any axioms
MathlibDemo.lean:313:0
LambdaConstitutive.translation_composes.{u_1, u_2, u_3} {X : Type u_1} {Y : Type u_2} {Z : Type u_3} (f : X → Y)
  (g : Y → Z) (p : X → Prop) (q : Y → Prop) (r : Z → Prop) (first : LambdaConstitutive.Preserves f p q)
  (second : LambdaConstitutive.Preserves g q r) : LambdaConstitutive.Preserves (g ∘ f) p r
MathlibDemo.lean:314:0
'LambdaConstitutive.translation_composes' does not depend on any axioms
MathlibDemo.lean:315:0
LambdaConstitutive.preserved_predicate_survives_roundtrip.{u_1, u_2} {X : Type u_1} {Y : Type u_2} (f : X → Y)
  (g : Y → X) (p : X → Prop) (q : Y → Prop) (forward : LambdaConstitutive.Preserves f p q)
  (backward : LambdaConstitutive.Preserves g q p) (x : X) : p x ↔ p (g (f x))
MathlibDemo.lean:316:0
'LambdaConstitutive.preserved_predicate_survives_roundtrip' does not depend on any axioms
MathlibDemo.lean:317:0
LambdaConstitutive.changed_middle_predicate_breaks_composition :
  ∃ f g p q₁ q₂ r,
    LambdaConstitutive.Preserves f p q₁ ∧
      LambdaConstitutive.Preserves g q₂ r ∧ ¬LambdaConstitutive.Preserves (g ∘ f) p r
MathlibDemo.lean:318:0
'LambdaConstitutive.changed_middle_predicate_breaks_composition' does not depend on any axioms
MathlibDemo.lean:319:0
LambdaConstitutive.conveyance_collision_blocks_target.{u_1, u_2, u_3} {X : Type u_1} {Y : Type u_2} {Z : Type u_3}
  (message : X → Y) (target : X → Z) {a b : X} (same : message a = message b) (split : target a ≠ target b) :
  ¬∃ interpret, ∀ (x : X), interpret (message x) = target x
MathlibDemo.lean:320:0
'LambdaConstitutive.conveyance_collision_blocks_target' does not depend on any axioms
MathlibDemo.lean:321:0
LambdaConstitutive.metadescription_cannot_split_equal_messages.{u_1, u_2, u_3} {X : Type u_1} {Y : Type u_2}
  {Z : Type u_3} (message : X → Y) (redescribe : Y → Z) {a b : X} (same : message a = message b) :
  redescribe (message a) = redescribe (message b)
MathlibDemo.lean:322:0
'LambdaConstitutive.metadescription_cannot_split_equal_messages' does not depend on any axioms
MathlibDemo.lean:323:0
LambdaConstitutive.erased_depth_has_no_decoder : ¬∃ decode, ∀ (n : ℕ), decode () = n
MathlibDemo.lean:324:0
'LambdaConstitutive.erased_depth_has_no_decoder' depends on axioms: [propext, Quot.sound]
MathlibDemo.lean:325:0
LambdaConstitutive.threaded_depth_has_decoder : ∃ decode, ∀ (n : ℕ), decode ((), n) = n
MathlibDemo.lean:326:0
'LambdaConstitutive.threaded_depth_has_decoder' does not depend on any axioms
MathlibDemo.lean:327:0
LambdaConstitutive.retained_argument_can_recover_depth : ∃ decode, ∀ (n : ℕ), decode n = n
MathlibDemo.lean:328:0
'LambdaConstitutive.retained_argument_can_recover_depth' does not depend on any axioms
MathlibDemo.lean:329:0
LambdaConstitutive.terminating_countdown_has_input_sized_trace (n : ℕ) : (LambdaConstitutive.countdown n).length = n
MathlibDemo.lean:330:0
'LambdaConstitutive.terminating_countdown_has_input_sized_trace' depends on axioms: [propext]
MathlibDemo.lean:331:0
LambdaConstitutive.no_uniform_trace_bound_for_terminating_countdown :
  ¬∃ B, ∀ (n : ℕ), (LambdaConstitutive.countdown n).length ≤ B
MathlibDemo.lean:332:0
'LambdaConstitutive.no_uniform_trace_bound_for_terminating_countdown' depends on axioms: [propext, Quot.sound]
MathlibDemo.lean:333:0
LambdaConstitutive.finite_state_can_continue_without_halting : ∃ step halt, ∀ (n : ℕ), ¬halt (step^[n] ())
MathlibDemo.lean:334:0
'LambdaConstitutive.finite_state_can_continue_without_halting' does not depend on any axioms
MathlibDemo.lean:335:0
LambdaConstitutive.exact_recovery_requires_enough_states.{u_1, u_2} {X : Type u_1} {S : Type u_2} [Fintype X]
  [Fintype S] (encode : X → S) (decode : S → X) (exactness : ∀ (x : X), decode (encode x) = x) :
  Fintype.card X ≤ Fintype.card S
MathlibDemo.lean:336:0
'LambdaConstitutive.exact_recovery_requires_enough_states' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:337:0
LambdaConstitutive.exact_subset_memory_requires_all_subsets.{u_1} (k : ℕ) {S : Type u_1} [Fintype S]
  (encode : (Fin k → Bool) → S) (decode : S → Fin k → Bool) (exactness : ∀ (x : Fin k → Bool), decode (encode x) = x) :
  2 ^ k ≤ Fintype.card S
MathlibDemo.lean:338:0
'LambdaConstitutive.exact_subset_memory_requires_all_subsets' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:339:0
LambdaConstitutive.exact_depth_through_N_requires_N_plus_one_states.{u_1} (N : ℕ) {S : Type u_1} [Fintype S]
  (encode : Fin (N + 1) → S) (decode : S → Fin (N + 1)) (exactness : ∀ (n : Fin (N + 1)), decode (encode n) = n) :
  N + 1 ≤ Fintype.card S
MathlibDemo.lean:340:0
'LambdaConstitutive.exact_depth_through_N_requires_N_plus_one_states' depends on axioms: [propext,
 Classical.choice,
 Quot.sound]
MathlibDemo.lean:341:0
LambdaConstitutive.no_fixed_finite_state_recovers_unbounded_depth.{u_1} {S : Type u_1} [Fintype S] (encode : ℕ → S) :
  ¬∃ decode, ∀ (n : ℕ), decode (encode n) = n
MathlibDemo.lean:342:0
'LambdaConstitutive.no_fixed_finite_state_recovers_unbounded_depth' depends on axioms: [propext,
 Classical.choice,
 Quot.sound]
MathlibDemo.lean:343:0
LambdaConstitutive.online_update_implies_append_compatibility.{u_1, u_2} {E : Type u_1} {S : Type u_2}
  (encode : List E → S) (update : S → E → S)
  (commutes : ∀ (h : List E) (e : E), update (encode h) e = encode (h ++ [e])) :
  LambdaConstitutive.AppendCompatible encode
MathlibDemo.lean:344:0
'LambdaConstitutive.online_update_implies_append_compatibility' does not depend on any axioms
MathlibDemo.lean:345:0
LambdaConstitutive.append_compatibility_supplies_online_update.{u_1, u_2} {E : Type u_1} {S : Type u_2} [Nonempty S]
  (encode : List E → S) (compatible : LambdaConstitutive.AppendCompatible encode) :
  ∃ update, ∀ (h : List E) (e : E), update (encode h) e = encode (h ++ [e])
MathlibDemo.lean:346:0
'LambdaConstitutive.append_compatibility_supplies_online_update' depends on axioms: [propext,
 Classical.choice,
 Quot.sound]
MathlibDemo.lean:347:0
LambdaConstitutive.run_preserves_history_encoding.{u_1, u_2} {E : Type u_1} {S : Type u_2} (encode : List E → S)
  (update : S → E → S) (commutes : ∀ (h : List E) (e : E), update (encode h) e = encode (h ++ [e])) (h : List E) :
  LambdaConstitutive.run update (encode []) h = encode h
MathlibDemo.lean:348:0
'LambdaConstitutive.run_preserves_history_encoding' depends on axioms: [propext, Quot.sound]
MathlibDemo.lean:349:0
LambdaConstitutive.online_target_recovery.{u_1, u_2, u_3} {E : Type u_1} {S : Type u_2} {Z : Type u_3}
  (encode : List E → S) (update : S → E → S) (decode : S → Z) (target : List E → Z)
  (commutes : ∀ (h : List E) (e : E), update (encode h) e = encode (h ++ [e]))
  (exactness : ∀ (h : List E), decode (encode h) = target h) (h : List E) :
  decode (LambdaConstitutive.run update (encode []) h) = target h
MathlibDemo.lean:350:0
'LambdaConstitutive.online_target_recovery' depends on axioms: [propext, Quot.sound]
MathlibDemo.lean:351:0
LambdaConstitutive.snapshot_target_can_fail_online_update :
  (∃ decode, ∀ (h : List Unit), decode (LambdaConstitutive.hasTwo h) = LambdaConstitutive.hasTwo h) ∧
    ¬LambdaConstitutive.AppendCompatible LambdaConstitutive.hasTwo
MathlibDemo.lean:352:0
'LambdaConstitutive.snapshot_target_can_fail_online_update' does not depend on any axioms
MathlibDemo.lean:353:0
LambdaConstitutive.cached_result_does_not_recover_return :
  ¬∃ d, ∀ (c : LambdaConstitutive.Cache), d c.result = c.returned
MathlibDemo.lean:354:0
'LambdaConstitutive.cached_result_does_not_recover_return' does not depend on any axioms
MathlibDemo.lean:355:0
LambdaConstitutive.return_mark_does_not_recover_cached_result :
  ¬∃ d, ∀ (c : LambdaConstitutive.Cache), d c.returned = c.result
MathlibDemo.lean:356:0
'LambdaConstitutive.return_mark_does_not_recover_cached_result' depends on axioms: [propext, Quot.sound]
MathlibDemo.lean:357:0
LambdaConstitutive.joint_record_recovers_both_cache_queries :
  ∃ d, ∀ (c : LambdaConstitutive.Cache), d c = (c.result, c.returned)
MathlibDemo.lean:358:0
'LambdaConstitutive.joint_record_recovers_both_cache_queries' does not depend on any axioms
MathlibDemo.lean:359:0
LambdaConstitutive.unchanged_reuse_preserves_entry {old new : LambdaConstitutive.Entry}
  (h : LambdaConstitutive.Reuse old new) : new = old
MathlibDemo.lean:360:0
'LambdaConstitutive.unchanged_reuse_preserves_entry' depends on axioms: [propext]
MathlibDemo.lean:361:0
LambdaConstitutive.unknown_origin_stays_unknown_under_reuse {old new : LambdaConstitutive.Entry}
  (h : LambdaConstitutive.Reuse old new) (unknown : old.origin = LambdaConstitutive.Origin.unknown) :
  new.origin = LambdaConstitutive.Origin.unknown
MathlibDemo.lean:362:0
'LambdaConstitutive.unknown_origin_stays_unknown_under_reuse' does not depend on any axioms
MathlibDemo.lean:363:0
LambdaConstitutive.changed_scope_is_not_unchanged_reuse {old new : LambdaConstitutive.Entry}
  (changed : new.scope ≠ old.scope) : ¬LambdaConstitutive.Reuse old new
MathlibDemo.lean:364:0
'LambdaConstitutive.changed_scope_is_not_unchanged_reuse' does not depend on any axioms
MathlibDemo.lean:365:0
LambdaConstitutive.result_label_cannot_recover_origin :
  ¬∃ decode, ∀ (e : LambdaConstitutive.Entry), decode e.claim = e.origin
MathlibDemo.lean:366:0
'LambdaConstitutive.result_label_cannot_recover_origin' does not depend on any axioms
MathlibDemo.lean:367:0
LambdaConstitutive.warranted_reuse_needs_scope_preservation.{u_1, u_2} {Scope : Type u_1} {Claim : Type u_2}
  {holds : Scope → Claim → Prop} (w : LambdaConstitutive.Warrant Scope Claim holds) (nextScope : Scope)
  (same : nextScope = w.scope) : holds nextScope w.claim
MathlibDemo.lean:368:0
'LambdaConstitutive.warranted_reuse_needs_scope_preservation' does not depend on any axioms
MathlibDemo.lean:369:0
LambdaConstitutive.warranted_translation_needs_a_bridge.{u_1, u_2, u_3, u_4} {S : Type u_1} {T : Type u_2}
  {C : Type u_3} {D : Type u_4} {holds : S → C → Prop} {nextHolds : T → D → Prop} (scopeMap : S → T) (claimMap : C → D)
  (bridge : ∀ (s : S) (c : C), holds s c → nextHolds (scopeMap s) (claimMap c))
  (w : LambdaConstitutive.Warrant S C holds) : nextHolds (scopeMap w.scope) (claimMap w.claim)
MathlibDemo.lean:370:0
'LambdaConstitutive.warranted_translation_needs_a_bridge' does not depend on any axioms
MathlibDemo.lean:371:0
LambdaConstitutive.declared_basis_allows_derived_conclusion (P Q : Prop) (adopted : P) (derivation : P → Q) : Q
MathlibDemo.lean:372:0
'LambdaConstitutive.declared_basis_allows_derived_conclusion' does not depend on any axioms
MathlibDemo.lean:373:0
LambdaConstitutive.derived_tag_alone_does_not_prove_claim :
  ¬∀ (P : Prop) (tag : LambdaConstitutive.Origin), tag = LambdaConstitutive.Origin.derived → P
MathlibDemo.lean:374:0
'LambdaConstitutive.derived_tag_alone_does_not_prove_claim' does not depend on any axioms
MathlibDemo.lean:375:0
LambdaConstitutive.append_record_preserves_prefix.{u_1} {R : Type u_1} (history : List R) (record : R) :
  List.take history.length (LambdaConstitutive.appendRecord history record) = history
MathlibDemo.lean:376:0
'LambdaConstitutive.append_record_preserves_prefix' depends on axioms: [propext]
MathlibDemo.lean:377:0
LambdaConstitutive.recording_protocol_has_a_holder.{u_1} {R : Type u_1} (e : LambdaConstitutive.ProtocolEntry R) :
  ∃ holder, holder = e.holder
MathlibDemo.lean:378:0
'LambdaConstitutive.recording_protocol_has_a_holder' does not depend on any axioms
MathlibDemo.lean:379:0
LambdaConstitutive.different_origin_rankings_need_no_absolute_comparator :
  ∃ first second, first false < first true ∧ second true < second false
MathlibDemo.lean:380:0
'LambdaConstitutive.different_origin_rankings_need_no_absolute_comparator' does not depend on any axioms
MathlibDemo.lean:381:0
"4.34.0-rc2"
MathlibDemo.lean:382:0
"LAMBDA_CONSTITUTIVE_R2_COMPLETE"
Restart File

MathlibDemo.lean:1:0
No info found.
All Messages ( 180)
MathlibDemo.lean:1273:0
@collision_blocks_factorization : ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} (P : X → Y) (Q : X → Z) {x₁ x₂ : X},
  P x₁ = P x₂ → Q x₁ ≠ Q x₂ → ¬FactorsThrough P Q
MathlibDemo.lean:1274:0
@id_factors_implies_injective : ∀ {X : Type u_1} {Y : Type u_2} (P : X → Y), FactorsThrough P id → Function.Injective P
MathlibDemo.lean:1275:0
@injective_factors_all : ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [Nonempty X] (P : X → Y),
  Function.Injective P → ∀ (Q : X → Z), FactorsThrough P Q
MathlibDemo.lean:1276:0
@factorization_dichotomy : ∀ {X : Type u_1} {Y : Type u_2} [Nonempty X] (P : X → Y),
  Function.Injective P ↔ FactorsThrough P id
MathlibDemo.lean:1277:0
@not_injective_iff_collision : ∀ {X : Type u_1} {Y : Type u_2} (P : X → Y),
  ¬Function.Injective P ↔ ∃ x₁ x₂, P x₁ = P x₂ ∧ x₁ ≠ x₂
MathlibDemo.lean:1278:0
@scope_retained_is_recoverable : ∀ {P : Type u_1} {S : Type u_2},
  FactorsThrough (fun c ↦ (c.prop, c.scope)) fun c ↦ c.scope
MathlibDemo.lean:1279:0
@scope_forgotten_is_not_recoverable : ∀ {P : Type u_1} {S : Type u_2} (p : P) {s₁ s₂ : S},
  s₁ ≠ s₂ → ¬FactorsThrough (fun c ↦ c.prop) fun c ↦ c.scope
MathlibDemo.lean:1280:0
only_error_retracts : ∀ (k : SuccessorKind), RetractsFormalResult k = true ↔ k = SuccessorKind.error
MathlibDemo.lean:1281:0
warrant_lapse_does_not_retract : RetractsFormalResult SuccessorKind.warrantLapse = false
MathlibDemo.lean:1282:0
@criterion_sides_exhaustive : ∀ {X : Type u_1} (c : X → Bool) (x : X), SelfSide c x ∨ OtherSide c x
MathlibDemo.lean:1283:0
@criterion_sides_exclusive : ∀ {X : Type u_1} (c : X → Bool) (x : X), ¬(SelfSide c x ∧ OtherSide c x)
MathlibDemo.lean:1284:0
@double_exclusion_is_double_negation : ∀ {X : Type u_1} (P : X → Prop) (x : X), ExcludedBy (ExcludedBy P) x ↔ ¬¬P x
MathlibDemo.lean:1285:0
@double_exclusion_collapse : ∀ {X : Type u_1} (P : X → Prop) (x : X), ExcludedBy (ExcludedBy P) x ↔ P x
MathlibDemo.lean:1286:0
@binary_criterion_has_collision : ∀ {X : Type u_1} [inst : Fintype X] (c : X → Bool),
  2 < Fintype.card X → ∃ x₁ x₂, c x₁ = c x₂ ∧ x₁ ≠ x₂
MathlibDemo.lean:1287:0
@binary_criterion_not_faithful : ∀ {X : Type u_1} [inst : Fintype X] (c : X → Bool),
  2 < Fintype.card X → ¬FactorsThrough c id
MathlibDemo.lean:1288:0
absolute_with_both_rules_is_identity : ∀ (A : Prop → Prop), (∀ (p : Prop), p → A p) → (∀ (p : Prop), A p → p) → A = id
MathlibDemo.lean:1289:0
@complement_requirement_blocks_absolute_priority : ∀ {C : Type u_1} (Priority UsesComplement : C → Prop),
  (∀ (c : C), Priority c → UsesComplement c) → ¬∃ c, AbsolutePriority Priority UsesComplement c
MathlibDemo.lean:1290:0
@no_first_position_cyclic : ∀ {n : ℕ} [inst : NeZero n] {Claim : Type u_1} (R : ResourceChain n Claim) (i : Fin n),
  ¬∃ c, AbsolutePriorityAt R i c
MathlibDemo.lean:1291:0
@preserves_and : ∀ {A : Type u_1} {B : Type u_2} (f : A → B) (P₁ P₂ : A → Prop) (Q₁ Q₂ : B → Prop),
  PreservesPredicate f P₁ Q₁ →
    PreservesPredicate f P₂ Q₂ → PreservesPredicate f (fun a ↦ P₁ a ∧ P₂ a) fun b ↦ Q₁ b ∧ Q₂ b
MathlibDemo.lean:1292:0
@preserves_or : ∀ {A : Type u_1} {B : Type u_2} (f : A → B) (P₁ P₂ : A → Prop) (Q₁ Q₂ : B → Prop),
  PreservesPredicate f P₁ Q₁ →
    PreservesPredicate f P₂ Q₂ → PreservesPredicate f (fun a ↦ P₁ a ∨ P₂ a) fun b ↦ Q₁ b ∨ Q₂ b
MathlibDemo.lean:1293:0
@preserves_not : ∀ {A : Type u_1} {B : Type u_2} (f : A → B) (P : A → Prop) (Q : B → Prop),
  PreservesPredicate f P Q → PreservesPredicate f (fun a ↦ ¬P a) fun b ↦ ¬Q b
MathlibDemo.lean:1294:0
@preserves_imp : ∀ {A : Type u_1} {B : Type u_2} (f : A → B) (P₁ P₂ : A → Prop) (Q₁ Q₂ : B → Prop),
  PreservesPredicate f P₁ Q₁ →
    PreservesPredicate f P₂ Q₂ → PreservesPredicate f (fun a ↦ P₁ a → P₂ a) fun b ↦ Q₁ b → Q₂ b
MathlibDemo.lean:1295:0
@preserved_predicate_agrees_despite_noncommutation : ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} (AB : A → B)
  (BC : B → C) (AC : A → C) (P : A → Prop) (Q : B → Prop) (R : C → Prop),
  PreservesPredicate AB P Q →
    PreservesPredicate BC Q R → PreservesPredicate AC P R → ∀ (a : A), R (AC a) ↔ R (BC (AB a))
MathlibDemo.lean:1296:0
@finite_budget_forces_tradeoff_n : ∀ {ι : Type u_1} (s : Finset ι) (cost alloc : ι → ℕ),
  ∀ budget < ∑ i ∈ s, cost i, ∑ i ∈ s, alloc i ≤ budget → (∀ i ∈ s, cost i ≤ alloc i) → False
MathlibDemo.lean:1297:0
finite_metadata_leaves_freedom : ∀ (s : Finset ℕ), ∃ I₀ I₁, (∀ n ∈ s, I₀ n = I₁ n) ∧ I₀ ≠ I₁
MathlibDemo.lean:1298:0
nat_cost_registry_attains_minimum : ∀ (S : Set ℕ) (cost : ℕ → ℕ), (∃ x, x ∈ S) → ∃ x ∈ S, ∀ y ∈ S, cost x ≤ cost y
MathlibDemo.lean:1299:0
@gaps_determine_up_to_shift : ∀ {I : Type u_1} (E F : I → ℝ) (i₀ : I),
  (∀ (i j : I), E i - E j = F i - F j) → ∀ (i : I), F i = E i + (F i₀ - E i₀)
MathlibDemo.lean:1300:0
@affine_calibration_unique : ∀ {I : Type u_1} (E : I → ℝ) (a a' b b' : ℝ) (i j : I),
  E i ≠ E j → (∀ (k : I), a * E k + b = a' * E k + b') → a = a' ∧ b = b'
MathlibDemo.lean:1301:0
distinct_count_parity : ∀ (g : ℕ), (g + g.gcd 2) / 2 = g / 2 + 1
MathlibDemo.lean:1302:0
boost_preserves_time_orientation : ∀ (g b T x : ℝ),
  0 < g → -1 < b → b < 1 → x ^ 2 < T ^ 2 → 0 < T → 0 < boostTime g b T x
MathlibDemo.lean:1303:0
boost_normalization_composes : ∀ (b₁ b₂ b g₁ g₂ g : ℝ),
  g₁ ^ 2 * (1 - b₁ ^ 2) = 1 →
    g₂ ^ 2 * (1 - b₂ ^ 2) = 1 → b * (1 + b₁ * b₂) = b₁ + b₂ → g = g₁ * g₂ * (1 + b₁ * b₂) → g ^ 2 * (1 - b ^ 2) = 1
MathlibDemo.lean:1304:0
planck_rescaling_rigid : ∀ (c h G L U M : ℝ),
  c ≠ 0 →
    h ≠ 0 →
      G ≠ 0 →
        0 < L →
          0 < U → 0 < M → c * U = c * L → h * U = h * (L ^ 2 * M) → G * U ^ 2 * M = G * L ^ 3 → L = 1 ∧ U = 1 ∧ M = 1
MathlibDemo.lean:1305:0
no_first_position_premises_necessary : ∃ Priority UsesComplement c, AbsolutePriority Priority UsesComplement c
MathlibDemo.lean:1306:0
lorentz_normalization_necessary : ∃ g b T x, interval (boostTime g b T x) (boostSpace g b T x) ≠ interval T x
MathlibDemo.lean:1307:0
budget_demand_hypothesis_necessary : ∃ costA costB allocA allocB budget,
  ¬budget < costA + costB ∧ allocA + allocB ≤ budget ∧ costA ≤ allocA ∧ costB ≤ allocB
MathlibDemo.lean:1308:0
nontriviality_hypothesis_necessary : ∃ c, ¬∃ x, SelfSide c x
MathlibDemo.lean:1309:0
velocity_bound_necessary : ∃ g b T x, 0 < g ∧ 0 < T ∧ x ^ 2 < T ^ 2 ∧ boostTime g b T x < 0
MathlibDemo.lean:1310:0
E09_nonzero_hypothesis_redundant : ∀ (z : ℂ), z ≠ z⁻¹ → z ≠ 0
MathlibDemo.lean:1311:0
P07_length_hypothesis_redundant : ∀ (c L U : ℝ), c ≠ 0 → c * U / L = c → L ≠ 0
MathlibDemo.lean:1312:0
E15_first_conjunct_is_contentless : ∀ (x : ℝ), 0 < x → 0 < x
MathlibDemo.lean:1313:0
@priority_claim_uses_individuation : ∀ {R : Type u_1} (c : PriorityClaim R), UsesIndividuation c
MathlibDemo.lean:1314:0
@priority_claim_uses_directed_order : ∀ {R : Type u_1} (c : PriorityClaim R), UsesDirectedOrder c
MathlibDemo.lean:1315:0
assertion_bridge_nonvacuous : (∃ c, assertionBridge.SpaceFirst c) ∧ ∃ c, assertionBridge.TimeFirst c
MathlibDemo.lean:1316:0
no_first_position_assertion_reading : (¬∃ c,
      AbsolutePriority assertionBridge.SpaceFirst assertionBridge.UsesTemporalResource c) ∧
  ¬∃ c, AbsolutePriority assertionBridge.TimeFirst assertionBridge.UsesSpatialResource c
MathlibDemo.lean:1317:0
timelike_not_time_only : ¬∃ P, ∀ (T x : ℝ), P T ↔ interval T x < 0
MathlibDemo.lean:1318:0
timelike_not_space_only : ¬∃ P, ∀ (T x : ℝ), P x ↔ interval T x < 0
MathlibDemo.lean:1319:0
taxonomy_encoding_is_lossy : ¬FactorsThrough RetractsFormalResult id
MathlibDemo.lean:1320:0
planck_two_constants_insufficient : ∀ (c h : ℝ),
  ∃ L U M, 0 < L ∧ 0 < U ∧ 0 < M ∧ ¬(L = 1 ∧ U = 1 ∧ M = 1) ∧ c * U = c * L ∧ h * U = h * (L ^ 2 * M)
MathlibDemo.lean:1321:0
spectral_read_inversion_invariant : ∀ (z : ℂ), spectralRead z⁻¹ = spectralRead z
MathlibDemo.lean:1322:0
spectral_fibre_at_most_pair : ∀ (z w : ℂ), z ≠ 0 → w ≠ 0 → spectralRead z = spectralRead w → w = z ∨ w = z⁻¹
MathlibDemo.lean:1323:0
spectral_fibre_singleton_iff : ∀ (z : ℂ), z ≠ 0 → (z = z⁻¹ ↔ z ^ 2 = 1)
MathlibDemo.lean:1324:0
@cardinality_forces_collision : ∀ {X : Type u_1} {Y : Type u_2} [inst : Fintype X] [inst_1 : Fintype Y] (c : X → Y),
  Fintype.card Y < Fintype.card X → ∃ x₁ x₂, c x₁ = c x₂ ∧ x₁ ≠ x₂
MathlibDemo.lean:1325:0
@cardinality_forces_unfaithfulness : ∀ {X : Type u_1} {Y : Type u_2} [inst : Fintype X] [inst_1 : Fintype Y]
  (c : X → Y), Fintype.card Y < Fintype.card X → ¬FactorsThrough c id
MathlibDemo.lean:1326:0
@kary_criterion_has_collision : ∀ {X : Type u_1} [inst : Fintype X] {k : ℕ} (c : X → Fin k),
  k < Fintype.card X → ∃ x₁ x₂, c x₁ = c x₂ ∧ x₁ ≠ x₂
MathlibDemo.lean:1327:0
@kary_criterion_not_faithful : ∀ {X : Type u_1} [inst : Fintype X] {k : ℕ} (c : X → Fin k),
  k < Fintype.card X → ¬FactorsThrough c id
MathlibDemo.lean:1328:0
@residue_monotone : ∀ {A : Type u_1} (S T : Set A) (cost : A → ENNReal),
  S ⊆ T → indexedResidue T cost ≤ indexedResidue S cost
MathlibDemo.lean:1329:0
conservative_expansion_can_lower_cost_strictly : ∃ R0 R1 cost conclusion expand,
  R0 ⊆ R1 ∧
    (∀ p ∈ R1, expand p ∈ R0 ∧ conclusion (expand p) = conclusion p) ∧
      (∀ (target : Unit), (∃ p ∈ R0, conclusion p = target) ↔ ∃ p ∈ R1, conclusion p = target) ∧
        indexedResidue R1 cost < indexedResidue R0 cost
MathlibDemo.lean:1330:0
conservative_expansion_need_not_lower_cost : ∃ R0 R1 cost, R0 ⊆ R1 ∧ indexedResidue R1 cost = indexedResidue R0 cost
MathlibDemo.lean:1331:0
dichotomy_nonemptiness_necessary : ∃ P, Function.Injective P ∧ ¬FactorsThrough P id
MathlibDemo.lean:1332:0
@no_first_position_without_B03_is_trivial : ∀ {R : Type u_1},
  (¬∃ c, UsesDirectedOrder c ∧ ¬UsesDirectedOrder c) ∧ ¬∃ c, UsesIndividuation c ∧ ¬UsesIndividuation c
MathlibDemo.lean:1333:0
@gaps_determine_up_to_shift_ring : ∀ {K : Type u_1} [inst : CommRing K] {I : Type u_2} (E F : I → K) (i₀ : I),
  (∀ (i j : I), E i - E j = F i - F j) → ∀ (i : I), F i = E i + (F i₀ - E i₀)
MathlibDemo.lean:1334:0
@affine_calibration_unique_field : ∀ {K : Type u_1} [inst : Field K] {I : Type u_2} (E : I → K) (a a' b b' : K)
  (i j : I), E i ≠ E j → (∀ (k : I), a * E k + b = a' * E k + b') → a = a' ∧ b = b'
MathlibDemo.lean:1335:0
straw_man_leaves_claim_standing : ∃ c cPlus, (cPlus → c) ∧ ¬cPlus ∧ c
MathlibDemo.lean:1336:0
motte_bailey_does_not_establish_claim : ∃ c cMinus, (c → cMinus) ∧ cMinus ∧ ¬c
MathlibDemo.lean:1337:0
@critique_validity_does_not_recover_target : ∀ {Claim : Type u_1} {c₁ c₂ : Claim},
  c₁ ≠ c₂ → ¬FactorsThrough (fun k ↦ k.valid) fun k ↦ k.target
MathlibDemo.lean:1338:0
@critique_is_pharmakon : ∀ {Claim : Type u_1} {c₁ c₂ : Claim},
  c₁ ≠ c₂ → (FactorsThrough (fun k ↦ k.valid) fun k ↦ k.valid) ∧ ¬FactorsThrough (fun k ↦ k.valid) fun k ↦ k.target
MathlibDemo.lean:1339:0
@residual_selection : ∀ {J : Type u_1} {S : Type u_2} (Admissible : J → Prop) (outcome : J → S) {j₁ j₂ : J},
  Admissible j₁ → Admissible j₂ → outcome j₁ ≠ outcome j₂ → ¬UniqueOutcome Admissible outcome
MathlibDemo.lean:1340:0
@competing_verifiers_defeat_unique_outcome : ∀ {Basis : Type u_1} {Claim : Type u_2}
  (Admissible : Verifier Basis Claim → Prop) (c : Claim) {v₁ v₂ : Verifier Basis Claim},
  Admissible v₁ → Admissible v₂ → v₁.verdict c ≠ v₂.verdict c → ¬UniqueOutcome Admissible fun v ↦ v.verdict c
MathlibDemo.lean:1341:0
@delegation_preserves_residual_will : ∀ {Basis : Type u_1} {Claim : Type u_2} (Admissible : Verifier Basis Claim → Prop)
  (c : Claim) {chosen v₂ : Verifier Basis Claim},
  Admissible chosen →
    Admissible v₂ → chosen.verdict c ≠ v₂.verdict c → ResidualWill Admissible (fun v ↦ v.verdict c) chosen
MathlibDemo.lean:1342:0
@certificate_does_not_recover_basis : ∀ {Basis : Type u_1} {Claim : Type u_2} {b₁ b₂ : Basis},
  b₁ ≠ b₂ → ∀ (f : Claim → Bool), ¬FactorsThrough (fun v ↦ certificateLabel v) fun v ↦ v.basis
MathlibDemo.lean:1343:0
@discharge_does_not_reduce_adoptions : ∀ {α : Type u_1} [inst : DecidableEq α] (S : Finset α) (b p : α),
  b ∈ S → p ∉ S → (insert p (S.erase b)).card = S.card
MathlibDemo.lean:1344:0
@symmetry_blocks_recovery : ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} (P : X → Y) (Q : X → Z) (σ : X → X),
  (∀ (x : X), P (σ x) = P x) → ∀ {x₀ : X}, Q (σ x₀) ≠ Q x₀ → ¬FactorsThrough P Q
MathlibDemo.lean:1345:0
@exchange_invariant_readout_loses_priority : ∀ {R : Type u_1} {Y : Type u_2} (P : PriorityClaim R → Y),
  (∀ (c : PriorityClaim R), P (exchangeRelata c) = P c) → ∀ (c₀ : PriorityClaim R), ¬FactorsThrough P fun c ↦ c.prior
MathlibDemo.lean:1346:0
@equal_criteria_forces_equal_verdict : ∀ {C : Type u_1} (criteria : C → DeclaredCriteria) (verdict : C → Bool),
  FairStandard criteria verdict → ∀ {c₁ c₂ : C}, criteria c₁ = criteria c₂ → verdict c₁ = verdict c₂
MathlibDemo.lean:1347:0
@differing_verdicts_defeat_fairness : ∀ {C : Type u_1} (criteria : C → DeclaredCriteria) (verdict : C → Bool)
  {c₁ c₂ : C}, criteria c₁ = criteria c₂ → verdict c₁ ≠ verdict c₂ → ¬FairStandard criteria verdict
MathlibDemo.lean:1348:0
@equal_standard_trichotomy : ∀ {C : Type u_1} (criteria : C → DeclaredCriteria) (verdict : C → Bool) (c₁ c₂ : C),
  criteria c₁ = criteria c₂ →
    verdict c₁ = true ∧ verdict c₂ = true ∨ verdict c₁ = false ∧ verdict c₂ = false ∨ ¬FairStandard criteria verdict
MathlibDemo.lean:1349:0
singularity_term_shared : publicTerm SingularityReading.forcedAdmitted = publicTerm SingularityReading.forcingMustVanish
MathlibDemo.lean:1350:0
singularity_readings_incompatible : publicTerm SingularityReading.forcedAdmitted =
    publicTerm SingularityReading.forcingMustVanish ∧
  requiresZeroForcing SingularityReading.forcedAdmitted ≠ requiresZeroForcing SingularityReading.forcingMustVanish
MathlibDemo.lean:1351:0
singularity_term_does_not_recover_reading : ¬FactorsThrough publicTerm requiresZeroForcing
MathlibDemo.lean:1352:0
certification_does_not_separate_readings : ∀ (report : SingularityReading → String),
  (∀ (r : SingularityReading), report r = publicTerm r) → ¬FactorsThrough report requiresZeroForcing
MathlibDemo.lean:1353:0
same_structure_same_verdict : ∀ (structureOf : BlowupClaim → BlowupClaim) (verdict : BlowupClaim → Bool),
  FactorsThrough structureOf verdict →
    ∀ {c₁ c₂ : BlowupClaim}, structureOf c₁ = structureOf c₂ → verdict c₁ = verdict c₂
MathlibDemo.lean:1354:0
parity_on_shared_fields : ∀ (verdict : BlowupClaim → Bool),
  FactorsThrough (fun c ↦ (c.familyDeclared, c.witnessExhibited, c.estimatesClose)) verdict →
    ∀ {c₁ c₂ : BlowupClaim},
      c₁.familyDeclared = c₂.familyDeclared →
        c₁.witnessExhibited = c₂.witnessExhibited → c₁.estimatesClose = c₂.estimatesClose → verdict c₁ = verdict c₂
MathlibDemo.lean:1355:0
claims_agree_off_forcing : claimA.familyDeclared = claimB.familyDeclared ∧
  claimA.witnessExhibited = claimB.witnessExhibited ∧
    claimA.estimatesClose = claimB.estimatesClose ∧ claimA.forcingAdmitted ≠ claimB.forcingAdmitted
MathlibDemo.lean:1356:0
parity_forced : ∀ (verdict : BlowupClaim → Bool),
  FactorsThrough (fun c ↦ (c.familyDeclared, c.witnessExhibited, c.estimatesClose)) verdict →
    verdict claimA = verdict claimB
MathlibDemo.lean:1357:0
alternatives_distinct : ClayAlternative.AB_unforced ≠ ClayAlternative.CD_forced
MathlibDemo.lean:1358:0
forced_claim_establishes_only_CD : ∀ (c : BlowupClaim),
  c.forcingAdmitted = true → alternativeOf c = ClayAlternative.CD_forced ∧ alternativeOf c ≠ ClayAlternative.AB_unforced
MathlibDemo.lean:1359:0
headline_does_not_recover_alternative : ¬FactorsThrough headline fun a ↦ a
MathlibDemo.lean:1360:0
priority_of_public_claim : datedA.day < datedB.day
MathlibDemo.lean:1361:0
verdict_does_not_recover_priority : ∀ (verdict : DatedClaim → Bool),
  (∀ (d : DatedClaim), verdict d = true) → ¬FactorsThrough verdict fun d ↦ d.day
MathlibDemo.lean:1363:0
'LambdaIII.collision_blocks_factorization' does not depend on any axioms
MathlibDemo.lean:1364:0
'LambdaIII.id_factors_implies_injective' does not depend on any axioms
MathlibDemo.lean:1365:0
'LambdaIII.injective_factors_all' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1366:0
'LambdaIII.factorization_dichotomy' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1367:0
'LambdaIII.not_injective_iff_collision' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1368:0
'LambdaIII.scope_retained_is_recoverable' does not depend on any axioms
MathlibDemo.lean:1369:0
'LambdaIII.scope_forgotten_is_not_recoverable' does not depend on any axioms
MathlibDemo.lean:1370:0
'LambdaIII.only_error_retracts' depends on axioms: [propext]
MathlibDemo.lean:1371:0
'LambdaIII.warrant_lapse_does_not_retract' depends on axioms: [propext]
MathlibDemo.lean:1372:0
'LambdaIII.criterion_sides_exhaustive' does not depend on any axioms
MathlibDemo.lean:1373:0
'LambdaIII.criterion_sides_exclusive' does not depend on any axioms
MathlibDemo.lean:1374:0
'LambdaIII.double_exclusion_is_double_negation' does not depend on any axioms
MathlibDemo.lean:1375:0
'LambdaIII.double_exclusion_collapse' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1376:0
'LambdaIII.binary_criterion_has_collision' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1377:0
'LambdaIII.binary_criterion_not_faithful' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1378:0
'LambdaIII.absolute_with_both_rules_is_identity' depends on axioms: [propext, Quot.sound]
MathlibDemo.lean:1379:0
'LambdaIII.complement_requirement_blocks_absolute_priority' does not depend on any axioms
MathlibDemo.lean:1380:0
'LambdaIII.no_first_position_cyclic' depends on axioms: [propext]
MathlibDemo.lean:1381:0
'LambdaIII.preserves_and' does not depend on any axioms
MathlibDemo.lean:1382:0
'LambdaIII.preserves_or' does not depend on any axioms
MathlibDemo.lean:1383:0
'LambdaIII.preserves_not' does not depend on any axioms
MathlibDemo.lean:1384:0
'LambdaIII.preserves_imp' does not depend on any axioms
MathlibDemo.lean:1385:0
'LambdaIII.preserved_predicate_agrees_despite_noncommutation' does not depend on any axioms
MathlibDemo.lean:1386:0
'LambdaIII.finite_budget_forces_tradeoff_n' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1387:0
'LambdaIII.finite_metadata_leaves_freedom' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1388:0
'LambdaIII.nat_cost_registry_attains_minimum' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1389:0
'LambdaIII.gaps_determine_up_to_shift' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1390:0
'LambdaIII.affine_calibration_unique' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1391:0
'LambdaIII.distinct_count_parity' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1392:0
'LambdaIII.boost_preserves_time_orientation' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1393:0
'LambdaIII.boost_normalization_composes' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1394:0
'LambdaIII.planck_rescaling_rigid' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1395:0
'LambdaIII.no_first_position_premises_necessary' does not depend on any axioms
MathlibDemo.lean:1396:0
'LambdaIII.lorentz_normalization_necessary' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1397:0
'LambdaIII.budget_demand_hypothesis_necessary' depends on axioms: [propext, Quot.sound]
MathlibDemo.lean:1398:0
'LambdaIII.nontriviality_hypothesis_necessary' depends on axioms: [propext]
MathlibDemo.lean:1399:0
'LambdaIII.velocity_bound_necessary' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1400:0
'LambdaIII.E09_nonzero_hypothesis_redundant' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1401:0
'LambdaIII.P07_length_hypothesis_redundant' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1402:0
'LambdaIII.E15_first_conjunct_is_contentless' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1403:0
'LambdaIII.priority_claim_uses_individuation' does not depend on any axioms
MathlibDemo.lean:1404:0
'LambdaIII.priority_claim_uses_directed_order' does not depend on any axioms
MathlibDemo.lean:1405:0
'LambdaIII.assertion_bridge_nonvacuous' does not depend on any axioms
MathlibDemo.lean:1406:0
'LambdaIII.no_first_position_assertion_reading' does not depend on any axioms
MathlibDemo.lean:1407:0
'LambdaIII.timelike_not_time_only' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1408:0
'LambdaIII.timelike_not_space_only' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1409:0
'LambdaIII.taxonomy_encoding_is_lossy' depends on axioms: [propext]
MathlibDemo.lean:1410:0
'LambdaIII.planck_two_constants_insufficient' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1411:0
'LambdaIII.spectral_read_inversion_invariant' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1412:0
'LambdaIII.spectral_fibre_at_most_pair' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1413:0
'LambdaIII.spectral_fibre_singleton_iff' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1414:0
'LambdaIII.cardinality_forces_collision' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1415:0
'LambdaIII.cardinality_forces_unfaithfulness' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1416:0
'LambdaIII.kary_criterion_has_collision' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1417:0
'LambdaIII.kary_criterion_not_faithful' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1418:0
'LambdaIII.residue_monotone' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1419:0
'LambdaIII.conservative_expansion_can_lower_cost_strictly' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1420:0
'LambdaIII.conservative_expansion_need_not_lower_cost' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1421:0
'LambdaIII.dichotomy_nonemptiness_necessary' does not depend on any axioms
MathlibDemo.lean:1422:0
'LambdaIII.no_first_position_without_B03_is_trivial' does not depend on any axioms
MathlibDemo.lean:1423:0
'LambdaIII.gaps_determine_up_to_shift_ring' depends on axioms: [propext]
MathlibDemo.lean:1424:0
'LambdaIII.affine_calibration_unique_field' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1425:0
'LambdaIII.straw_man_leaves_claim_standing' does not depend on any axioms
MathlibDemo.lean:1426:0
'LambdaIII.motte_bailey_does_not_establish_claim' does not depend on any axioms
MathlibDemo.lean:1427:0
'LambdaIII.critique_validity_does_not_recover_target' does not depend on any axioms
MathlibDemo.lean:1428:0
'LambdaIII.critique_is_pharmakon' does not depend on any axioms
MathlibDemo.lean:1429:0
'LambdaIII.residual_selection' does not depend on any axioms
MathlibDemo.lean:1430:0
'LambdaIII.competing_verifiers_defeat_unique_outcome' does not depend on any axioms
MathlibDemo.lean:1431:0
'LambdaIII.delegation_preserves_residual_will' does not depend on any axioms
MathlibDemo.lean:1432:0
'LambdaIII.certificate_does_not_recover_basis' does not depend on any axioms
MathlibDemo.lean:1433:0
'LambdaIII.discharge_does_not_reduce_adoptions' depends on axioms: [propext, Classical.choice, Quot.sound]
MathlibDemo.lean:1434:0
'LambdaIII.symmetry_blocks_recovery' does not depend on any axioms
MathlibDemo.lean:1435:0
'LambdaIII.exchange_invariant_readout_loses_priority' does not depend on any axioms
MathlibDemo.lean:1436:0
'LambdaIII.equal_criteria_forces_equal_verdict' does not depend on any axioms
MathlibDemo.lean:1437:0
'LambdaIII.differing_verdicts_defeat_fairness' does not depend on any axioms
MathlibDemo.lean:1438:0
'LambdaIII.equal_standard_trichotomy' does not depend on any axioms
MathlibDemo.lean:1439:0
'LambdaIII.singularity_term_shared' does not depend on any axioms
MathlibDemo.lean:1440:0
'LambdaIII.singularity_readings_incompatible' does not depend on any axioms
MathlibDemo.lean:1441:0
'LambdaIII.singularity_term_does_not_recover_reading' does not depend on any axioms
MathlibDemo.lean:1442:0
'LambdaIII.certification_does_not_separate_readings' depends on axioms: [Quot.sound]
MathlibDemo.lean:1443:0
'LambdaIII.same_structure_same_verdict' does not depend on any axioms
MathlibDemo.lean:1444:0
'LambdaIII.parity_on_shared_fields' does not depend on any axioms
MathlibDemo.lean:1445:0
'LambdaIII.claims_agree_off_forcing' does not depend on any axioms
MathlibDemo.lean:1446:0
'LambdaIII.parity_forced' does not depend on any axioms
MathlibDemo.lean:1447:0
'LambdaIII.alternatives_distinct' does not depend on any axioms
MathlibDemo.lean:1448:0
'LambdaIII.forced_claim_establishes_only_CD' depends on axioms: [propext]
MathlibDemo.lean:1449:0
'LambdaIII.headline_does_not_recover_alternative' does not depend on any axioms
MathlibDemo.lean:1450:0
'LambdaIII.priority_of_public_claim' does not depend on any axioms
MathlibDemo.lean:1451:0
'LambdaIII.verdict_does_not_recover_priority' does not depend on any axioms
MathlibDemo.lean:1453:0
"4.34.0-rc2"
MathlibDemo.lean:1454:0
"LAMBDA_PART_III_SUCCESSOR_R1"
Restart File