@lapxo/obligations 0.4.4 → 0.4.6

package/proofs/m1-046-bridge/Obligations045/M0Limit.lean

@@ -0,0 +1,134 @@
+import Mathlib.Topology.Instances.Real.Lemmas
+import Mathlib.Data.Real.Archimedean
+import Mathlib.Topology.Algebra.Order.Field
+import Mathlib.Algebra.Order.Floor.Ring
+import Mathlib.Tactic.Linarith
+import Mathlib.Tactic.Ring
+import Mathlib.Tactic.NormNum
+import Mathlib.Tactic.Positivity
+
+open scoped BigOperators
+open Filter Topology
+noncomputable section
+open Classical
+namespace Obligations045.M0
+
+/-- Declared binary M0 domain. This structure contains no limiting-probability axiom. -/
+structure Domain where
+  K : ℕ
+  K_pos : 0 < K
+  p : ℝ
+  c : ℝ
+  p_half : (1:ℝ)/2 < p
+  p_lt_one : p < 1
+  c_nonneg : 0 ≤ c
+  c_lt_one : c < 1
+  w : ℕ → ℝ
+  w_nonneg : ∀ i, 0 ≤ w i
+  weights_sum : ∑ i ∈ Finset.range K, w i = 1
+
+def cumulative (w : ℕ → ℝ) (i : ℕ) : ℝ := ∑ j ∈ Finset.range i, w j
+
+def allocation (w : ℕ → ℝ) (N i : ℕ) : ℕ :=
+  ⌊(N:ℝ) * cumulative w (i+1)⌋₊ - ⌊(N:ℝ) * cumulative w i⌋₊
+
+theorem prefix_succ (w : ℕ → ℝ) (i : ℕ) :
+    cumulative w (i+1) = cumulative w i + w i := by simp [cumulative, Finset.sum_range_succ]
+
+theorem prefix_monotone (w : ℕ → ℝ) (hw : ∀ i, 0 ≤ w i) : Monotone (cumulative w) := by
+  apply monotone_nat_of_le_succ
+  intro i
+  rw [prefix_succ]
+  exact le_add_of_nonneg_right (hw i)
+
+theorem allocation_sum (M : Domain) (N : ℕ) :
+    ∑ i ∈ Finset.range M.K, allocation M.w N i = N := by
+  let f : ℕ → ℕ := fun i => ⌊(N:ℝ) * cumulative M.w i⌋₊
+  have hf : Monotone f := fun i j hij =>
+    Nat.floor_mono (mul_le_mul_of_nonneg_left (prefix_monotone M.w M.w_nonneg hij) (by positivity))
+  change ∑ i ∈ Finset.range M.K, (f (i+1) - f i) = N
+  rw [Finset.sum_range_tsub hf]
+  simp [f, cumulative, M.weights_sum]
+
+theorem allocation_discrepancy (M : Domain) (N i : ℕ) :
+    -1 < (allocation M.w N i : ℝ) - (N:ℝ)*M.w i ∧
+    (allocation M.w N i : ℝ) - (N:ℝ)*M.w i < 1 := by
+  have hpre : 0 ≤ cumulative M.w i := Finset.sum_nonneg (fun j _ => M.w_nonneg j)
+  have hnext : 0 ≤ cumulative M.w (i+1) := Finset.sum_nonneg (fun j _ => M.w_nonneg j)
+  have hm : ⌊(N:ℝ)*cumulative M.w i⌋₊ ≤ ⌊(N:ℝ)*cumulative M.w (i+1)⌋₊ :=
+    Nat.floor_mono (mul_le_mul_of_nonneg_left (prefix_monotone M.w M.w_nonneg (Nat.le_succ i)) (by positivity))
+  have a := Nat.floor_le (mul_nonneg (Nat.cast_nonneg N) hpre)
+  have b := Nat.lt_floor_add_one ((N:ℝ)*cumulative M.w i)
+  have c := Nat.floor_le (mul_nonneg (Nat.cast_nonneg N) hnext)
+  have d := Nat.lt_floor_add_one ((N:ℝ)*cumulative M.w (i+1))
+  have hs := prefix_succ M.w i
+  simp only [allocation, Nat.cast_sub hm]
+  constructor <;> nlinarith
+
+def q (M : Domain) (a : Bool) : ℝ := (1-M.c)*M.p + if a then M.c else 0
+
+theorem q_pos (M : Domain) (a : Bool) : 0 < q M a := by
+  have hp : 0 < M.p := by linarith [M.p_half]
+  cases a <;> simp only [q, Bool.false_eq_true, ite_false, add_zero, ite_true] <;>
+    nlinarith [M.c_nonneg, M.c_lt_one]
+
+theorem q_lt_one (M : Domain) (a : Bool) : q M a < 1 := by
+  have hp : 0 < M.p := by linarith [M.p_half]
+  cases a <;> simp only [q, Bool.false_eq_true, ite_false, add_zero, ite_true] <;>
+    nlinarith [M.c_nonneg, M.c_lt_one, M.p_lt_one]
+
+def score (M : Domain) (a : Fin M.K → Bool) : ℝ :=
+  ∑ i : Fin M.K, M.w i * q M (a i)
+
+def latentMass (M : Domain) (a : Fin M.K → Bool) : ℝ :=
+  ∏ i : Fin M.K, if a i then M.p else 1-M.p
+
+def fairLoss (correct total : ℕ) : ℝ :=
+  if 2*correct < total then 1 else if 2*correct = total then 1/2 else 0
+
+/-- The exact finite conditional error, using independent binomial counts in each lineage. -/
+noncomputable def conditionalError (M : Domain) (N : ℕ) (a : Fin M.K → Bool) : ℝ :=
+  ∑ x : (i : Fin M.K) → Fin (allocation M.w N i + 1),
+    (∏ i : Fin M.K,
+      (Nat.choose (allocation M.w N i) (x i) : ℝ) *
+      q M (a i) ^ (x i : ℕ) *
+      (1-q M (a i)) ^ (allocation M.w N i - (x i : ℕ))) *
+    fairLoss (∑ i : Fin M.K, (x i : ℕ)) N
+
+noncomputable def error (M : Domain) (N : ℕ) : ℝ :=
+  ∑ a : Fin M.K → Bool, latentMass M a * conditionalError M N a
+
+noncomputable def limitingLoss (s : ℝ) : ℝ :=
+  if s < 1/2 then 1 else if s = 1/2 then 1/2 else 0
+
+noncomputable def floor (M : Domain) : ℝ :=
+  ∑ a : Fin M.K → Bool, latentMass M a * limitingLoss (score M a)
+
+/-- Explicit proof obligations, NOT assumptions hidden inside the generative model.
+    The strict branches require concentration. The equality branch requires a CLT.
+    This certificate has no constructed instance in this project. -/
+def ConditionalTailLimits (M : Domain) : Prop :=
+  (∀ a, score M a < 1/2 → Tendsto (fun N => conditionalError M N a) atTop (𝓝 1)) ∧
+  (∀ a, 1/2 < score M a → Tendsto (fun N => conditionalError M N a) atTop (𝓝 0)) ∧
+  (∀ a, score M a = 1/2 → Tendsto (fun N => conditionalError M N a) atTop (𝓝 (1/2)))
+
+/-- Kernel checked finite-mixture transfer. This is intentionally conditional;
+    it does not claim that ConditionalTailLimits follows from Domain. -/
+theorem limit_of_conditional_tail_limits (M : Domain) (h : ConditionalTailLimits M) :
+    Tendsto (error M) atTop (𝓝 (floor M)) := by
+  have hcase : ∀ a, Tendsto (fun N => conditionalError M N a) atTop
+      (𝓝 (limitingLoss (score M a))) := by
+    intro a
+    by_cases hl : score M a < 1/2
+    · rw [limitingLoss, if_pos hl]
+      exact h.1 a hl
+    · by_cases he : score M a = 1/2
+      · rw [limitingLoss, if_neg hl, if_pos he]
+        exact h.2.2 a he
+      · have hg : 1/2 < score M a := lt_of_le_of_ne (le_of_not_gt hl) (Ne.symm he)
+        rw [limitingLoss, if_neg hl, if_neg he]
+        exact h.2.1 a hg
+  unfold error floor
+  exact tendsto_finset_sum _ (fun a _ => tendsto_const_nhds.mul (hcase a))
+
+end Obligations045.M0

package/proofs/m1-046-bridge/Obligations045/M0Offdiag.lean

@@ -0,0 +1,171 @@
+import Obligations045.M0Limit
+import Mathlib.Probability.StrongLaw
+import Mathlib.MeasureTheory.Integral.DominatedConvergence
+open scoped BigOperators
+open Filter Topology MeasureTheory ProbabilityTheory
+noncomputable section
+namespace Obligations045.M0
+
+theorem floor_quota_bounds (M : Domain) (N i : ℕ) :
+    (∑ j ∈ Finset.range M.K, allocation M.w N j = N) ∧
+    (-1 < (allocation M.w N i : ℝ)-(N:ℝ)*M.w i ∧
+      (allocation M.w N i : ℝ)-(N:ℝ)*M.w i < 1) :=
+  ⟨allocation_sum M N, allocation_discrepancy M N i⟩
+
+theorem allocation_ratio (M : Domain) (i : ℕ) :
+    Tendsto (fun N : ℕ => (allocation M.w N i : ℝ)/(N:ℝ)) atTop (𝓝 (M.w i)) := by
+  have hInv : Tendsto (fun N : ℕ => (1:ℝ)/(N:ℝ)) atTop (𝓝 0) :=
+    tendsto_const_nhds.div_atTop tendsto_natCast_atTop_atTop
+  apply tendsto_of_tendsto_of_tendsto_of_le_of_le'
+    (by simpa using tendsto_const_nhds.sub hInv)
+    (by simpa using tendsto_const_nhds.add hInv)
+  · filter_upwards [eventually_ge_atTop 1] with N hN
+    have hp : 0 < (N:ℝ) := by exact_mod_cast (lt_of_lt_of_le Nat.zero_lt_one hN)
+    rw [le_div_iff₀ hp, sub_mul, inv_mul_cancel₀ hp.ne']
+    linarith [(allocation_discrepancy M N i).1]
+  · filter_upwards [eventually_ge_atTop 1] with N hN
+    have hp : 0 < (N:ℝ) := by exact_mod_cast (lt_of_lt_of_le Nat.zero_lt_one hN)
+    rw [div_le_iff₀ hp, add_mul, inv_mul_cancel₀ hp.ne']
+    linarith [(allocation_discrepancy M N i).2]
+
+theorem allocation_zero (M : Domain) (i : ℕ) (hw : M.w i = 0) (N : ℕ) :
+    allocation M.w N i = 0 := by
+  simp [allocation, prefix_succ, hw]
+
+theorem allocation_atTop (M : Domain) (i : ℕ) (hw : 0 < M.w i) :
+    Tendsto (fun N => allocation M.w N i) atTop atTop := by
+  apply (tendsto_natCast_atTop_iff (R := ℝ)).mp
+  apply tendsto_atTop.2
+  intro r
+  have he : ∀ᶠ N : ℕ in atTop, (r+1)/M.w i ≤ (N:ℝ) :=
+    tendsto_natCast_atTop_atTop.eventually (eventually_ge_atTop _)
+  filter_upwards [he] with N hN
+  have hmul := (div_le_iff₀ hw).mp hN
+  linarith [(allocation_discrepancy M N i).1]
+
+theorem lineage_quota_limit (M : Domain) (i : ℕ) (z : ℕ → ℝ) (q : ℝ)
+    (hz0 : z 0 = 0)
+    (hz : Tendsto (fun n : ℕ => z n/(n:ℝ)) atTop (𝓝 q)) :
+    Tendsto (fun N : ℕ => z (allocation M.w N i)/(N:ℝ)) atTop (𝓝 (M.w i*q)) := by
+  by_cases hw : M.w i = 0
+  · simp [allocation_zero M i hw, hz0, hw]
+  · have hp : 0 < M.w i := lt_of_le_of_ne (M.w_nonneg i) (Ne.symm hw)
+    have h := (allocation_ratio M i).mul (hz.comp (allocation_atTop M i hp))
+    convert h using 1
+    funext N
+    by_cases hn : allocation M.w N i = 0
+    · simp [hn, hz0]
+    · dsimp
+      rw [div_mul_div_comm, mul_comm (allocation M.w N i : ℝ), mul_div_mul_right _ _ (by exact_mod_cast hn : (allocation M.w N i : ℝ) ≠ 0)]
+
+/-- The imported strong law is applied to actual lineage variables; no convergence certificate. -/
+theorem lineage_lgn {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω)
+    (X : ℕ → Ω → ℝ) (q : ℝ)
+    (hint : Integrable (X 0) μ)
+    (hindep : Pairwise (fun i j : ℕ => IndepFun (X i) (X j) μ))
+    (hident : ∀ i, IdentDistrib (X i) (X 0) μ μ)
+    (hmean : ∫ ω, X 0 ω ∂μ = q) :
+    ∀ᵐ ω ∂μ, Tendsto (fun n : ℕ => (∑ j ∈ Finset.range n, X j ω)/(n:ℝ))
+      atTop (𝓝 q) := by
+  simpa only [hmean] using strong_law_ae_real X hint hindep hident
+
+def memberAverage {Ω : Type*} (M : Domain) (X : Fin M.K → ℕ → Ω → ℝ)
+    (N : ℕ) (ω : Ω) : ℝ :=
+  ∑ i : Fin M.K, (∑ j ∈ Finset.range (allocation M.w N i), X i j ω)/(N:ℝ)
+
+theorem member_average_lgn {Ω : Type*} [MeasurableSpace Ω]
+    (M : Domain) (a : Fin M.K → Bool) (μ : Measure Ω)
+    (X : Fin M.K → ℕ → Ω → ℝ)
+    (hint : ∀ i, Integrable (X i 0) μ)
+    (hindep : ∀ i, Pairwise (fun j k : ℕ => IndepFun (X i j) (X i k) μ))
+    (hident : ∀ i j, IdentDistrib (X i j) (X i 0) μ μ)
+    (hmean : ∀ i, ∫ ω, X i 0 ω ∂μ = q M (a i)) :
+    ∀ᵐ ω ∂μ, Tendsto (fun N => memberAverage M X N ω) atTop (𝓝 (score M a)) := by
+  have hall : ∀ᵐ ω ∂μ, ∀ i : Fin M.K,
+      Tendsto (fun n : ℕ => (∑ j ∈ Finset.range n, X i j ω)/(n:ℝ))
+        atTop (𝓝 (q M (a i))) := by
+    rw [ae_all_iff]
+    intro i
+    exact lineage_lgn μ (X i) (q M (a i)) (hint i) (hindep i) (hident i) (hmean i)
+  filter_upwards [hall] with ω hω
+  unfold memberAverage score
+  apply tendsto_finset_sum
+  intro i _
+  exact lineage_quota_limit M i (fun n => ∑ j ∈ Finset.range n, X i j ω)
+    (q M (a i)) (by simp) (hω i)
+
+theorem floor_limit_offdiag_scalar {f : ℕ → ℝ} {s : ℝ}
+    (hf : Tendsto f atTop (𝓝 s)) (hne : s ≠ (1:ℝ)/2) :
+    Tendsto (fun N => limitingLoss (f N)) atTop (𝓝 (limitingLoss s)) := by
+  by_cases hs : s < (1:ℝ)/2
+  · have he : ∀ᶠ N in atTop, f N < (1:ℝ)/2 := hf.eventually (Iio_mem_nhds hs)
+    have hEq : (fun N => limitingLoss (f N)) =ᶠ[atTop] (fun _ => (1:ℝ)) :=
+      he.mono (fun N hN => by change limitingLoss (f N) = 1; rw [limitingLoss, if_pos hN])
+    rw [limitingLoss, if_pos hs]
+    exact tendsto_const_nhds.congr' hEq.symm
+  · have hg : (1:ℝ)/2 < s := lt_of_le_of_ne (le_of_not_gt hs) (Ne.symm hne)
+    have he : ∀ᶠ N in atTop, (1:ℝ)/2 < f N := hf.eventually (Ioi_mem_nhds hg)
+    have hEq : (fun N => limitingLoss (f N)) =ᶠ[atTop] (fun _ => (0:ℝ)) :=
+      he.mono (fun N hN => by
+        change limitingLoss (f N) = 0
+        rw [limitingLoss, if_neg (not_lt.mpr hN.le), if_neg (Ne.symm hN.ne)])
+    rw [limitingLoss, if_neg hs, if_neg hne]
+    exact tendsto_const_nhds.congr' hEq.symm
+
+/-- Off-diagonal passage from actual sample averages to error probabilities.
+    Unlike the diagonal, no CLT is needed. The lineage strong laws and quota
+    composition must supply haverage for the chosen M0 array. -/
+theorem floor_limit_offdiag {Ω : Type*} [MeasurableSpace Ω]
+    (μ : Measure Ω) [IsProbabilityMeasure μ]
+    (average : ℕ → Ω → ℝ) (s : ℝ)
+    (hmeas : ∀ N, AEStronglyMeasurable (fun ω => limitingLoss (average N ω)) μ)
+    (haverage : ∀ᵐ ω ∂μ, Tendsto (fun N => average N ω) atTop (𝓝 s))
+    (hne : s ≠ (1:ℝ)/2) :
+    Tendsto (fun N => ∫ ω, limitingLoss (average N ω) ∂μ)
+      atTop (𝓝 (limitingLoss s)) := by
+  have hbound : ∀ N, ∀ᵐ ω ∂μ, ‖limitingLoss (average N ω)‖ ≤ (1:ℝ) := by
+    intro N
+    filter_upwards [] with ω
+    unfold limitingLoss
+    split_ifs <;> norm_num
+  have hlim : ∀ᵐ ω ∂μ, Tendsto (fun N => limitingLoss (average N ω))
+      atTop (𝓝 (limitingLoss s)) := haverage.mono (fun ω hω => floor_limit_offdiag_scalar hω hne)
+  simpa using tendsto_integral_of_dominated_convergence (fun _ => (1:ℝ)) hmeas
+    (integrable_const (1:ℝ)) hbound hlim
+
+/-- M0 off-diagonal probability limit from declared lineage laws and the proved quotas.
+    The only extra technical input is measurability of the loss; no asymptotic
+    convergence hypothesis and no CLT certificate is assumed. -/
+theorem floor_limit_offdiag_M0 {Ω : Type*} [MeasurableSpace Ω]
+    (M : Domain) (a : Fin M.K → Bool) (μ : Measure Ω) [IsProbabilityMeasure μ]
+    (X : Fin M.K → ℕ → Ω → ℝ)
+    (hint : ∀ i, Integrable (X i 0) μ)
+    (hindep : ∀ i, Pairwise (fun j k : ℕ => IndepFun (X i j) (X i k) μ))
+    (hident : ∀ i j, IdentDistrib (X i j) (X i 0) μ μ)
+    (hmean : ∀ i, ∫ ω, X i 0 ω ∂μ = q M (a i))
+    (hmeas : ∀ N, AEStronglyMeasurable (fun ω => limitingLoss (memberAverage M X N ω)) μ)
+    (hoff : score M a ≠ (1:ℝ)/2) :
+    Tendsto (fun N => ∫ ω, limitingLoss (memberAverage M X N ω) ∂μ)
+      atTop (𝓝 (limitingLoss (score M a))) := by
+  exact floor_limit_offdiag μ (memberAverage M X) (score M a) hmeas
+    (member_average_lgn M a μ X hint hindep hident hmean) hoff
+
+theorem floor_limit_offdiag_mixture {Ω : Type*} [MeasurableSpace Ω]
+    (M : Domain) (μ : Measure Ω) [IsProbabilityMeasure μ]
+    (X : (Fin M.K → Bool) → Fin M.K → ℕ → Ω → ℝ)
+    (hint : ∀ a i, Integrable (X a i 0) μ)
+    (hindep : ∀ a i, Pairwise (fun j k : ℕ => IndepFun (X a i j) (X a i k) μ))
+    (hident : ∀ a i j, IdentDistrib (X a i j) (X a i 0) μ μ)
+    (hmean : ∀ a i, ∫ ω, X a i 0 ω ∂μ = q M (a i))
+    (hmeas : ∀ a N, AEStronglyMeasurable (fun ω => limitingLoss (memberAverage M (X a) N ω)) μ)
+    (hoff : ∀ a, score M a ≠ (1:ℝ)/2) :
+    Tendsto (fun N => ∑ a : Fin M.K → Bool, latentMass M a *
+      ∫ ω, limitingLoss (memberAverage M (X a) N ω) ∂μ)
+      atTop (𝓝 (floor M)) := by
+  unfold floor
+  apply tendsto_finset_sum
+  intro a _
+  exact tendsto_const_nhds.mul (floor_limit_offdiag_M0 M a μ (X a)
+    (hint a) (hindep a) (hident a) (hmean a) (hmeas a) (hoff a))
+
+end Obligations045.M0

package/proofs/m1-046-bridge/lake-manifest.json

@@ -0,0 +1,116 @@
+{
+  "version": "1.1.0",
+  "packagesDir": ".lake/packages",
+  "packages": [
+    {
+      "url": "https://github.com/leanprover-community/plausible",
+      "type": "git",
+      "subDir": null,
+      "scope": "leanprover-community",
+      "rev": "77e08eddc486491d7b9e470926b3dbe50319451a",
+      "name": "plausible",
+      "manifestFile": "lake-manifest.json",
+      "inputRev": "main",
+      "inherited": true,
+      "configFile": "lakefile.toml"
+    },
+    {
+      "url": "https://github.com/leanprover-community/LeanSearchClient",
+      "type": "git",
+      "subDir": null,
+      "scope": "leanprover-community",
+      "rev": "25078369972d295301f5a1e53c3e5850cf6d9d4c",
+      "name": "LeanSearchClient",
+      "manifestFile": "lake-manifest.json",
+      "inputRev": "main",
+      "inherited": true,
+      "configFile": "lakefile.toml"
+    },
+    {
+      "url": "https://github.com/leanprover-community/import-graph",
+      "type": "git",
+      "subDir": null,
+      "scope": "leanprover-community",
+      "rev": "e6a9f0f5ee3ccf7443a0070f92b62f8db12ae82b",
+      "name": "importGraph",
+      "manifestFile": "lake-manifest.json",
+      "inputRev": "main",
+      "inherited": true,
+      "configFile": "lakefile.toml"
+    },
+    {
+      "url": "https://github.com/leanprover-community/ProofWidgets4",
+      "type": "git",
+      "subDir": null,
+      "scope": "leanprover-community",
+      "rev": "c4919189477c3221e6a204008998b0d724f49904",
+      "name": "proofwidgets",
+      "manifestFile": "lake-manifest.json",
+      "inputRev": "v0.0.57",
+      "inherited": true,
+      "configFile": "lakefile.lean"
+    },
+    {
+      "url": "https://github.com/leanprover-community/aesop",
+      "type": "git",
+      "subDir": null,
+      "scope": "leanprover-community",
+      "rev": "5d50b08dedd7d69b3d9b3176e0d58a23af228884",
+      "name": "aesop",
+      "manifestFile": "lake-manifest.json",
+      "inputRev": "master",
+      "inherited": true,
+      "configFile": "lakefile.toml"
+    },
+    {
+      "url": "https://github.com/leanprover-community/quote4",
+      "type": "git",
+      "subDir": null,
+      "scope": "leanprover-community",
+      "rev": "fa4f7f15d97591a9cf3aa7724ba371c7fc6dda02",
+      "name": "Qq",
+      "manifestFile": "lake-manifest.json",
+      "inputRev": "master",
+      "inherited": true,
+      "configFile": "lakefile.toml"
+    },
+    {
+      "url": "https://github.com/leanprover-community/batteries",
+      "type": "git",
+      "subDir": null,
+      "scope": "leanprover-community",
+      "rev": "f5d04a9c4973d401c8c92500711518f7c656f034",
+      "name": "batteries",
+      "manifestFile": "lake-manifest.json",
+      "inputRev": "main",
+      "inherited": true,
+      "configFile": "lakefile.toml"
+    },
+    {
+      "url": "https://github.com/leanprover/lean4-cli",
+      "type": "git",
+      "subDir": null,
+      "scope": "leanprover",
+      "rev": "02dbd02bc00ec4916e99b04b2245b30200e200d0",
+      "name": "Cli",
+      "manifestFile": "lake-manifest.json",
+      "inputRev": "main",
+      "inherited": true,
+      "configFile": "lakefile.toml"
+    },
+    {
+      "url": "https://github.com/leanprover-community/mathlib4.git",
+      "type": "git",
+      "subDir": null,
+      "scope": "",
+      "rev": "c44e0c8ee63ca166450922a373c7409c5d26b00b",
+      "name": "mathlib",
+      "manifestFile": "lake-manifest.json",
+      "inputRev": "c44e0c8ee63ca166450922a373c7409c5d26b00b",
+      "inherited": false,
+      "configFile": "lakefile.lean"
+    }
+  ],
+  "name": "obligations_lineage",
+  "lakeDir": ".lake"
+}

package/proofs/m1-046-bridge/lakefile.toml

@@ -0,0 +1,29 @@
+name = "obligations_lineage"
+version = "0.0.0"
+defaultTargets = ["Obligations045"]
+[[require]]
+name = "mathlib"
+git = "https://github.com/leanprover-community/mathlib4.git"
+rev = "c44e0c8ee63ca166450922a373c7409c5d26b00b"
+[[lean_lib]]
+name = "Obligations045"
+
+[[lean_lib]]
+name = "M0Bridge"
+[[lean_lib]]
+name = "BridgeNegatives"
+
+[[lean_lib]]
+name = "M0Diagonal046"
+
+[[lean_lib]]
+name = "M0Moments046"
+
+[[lean_lib]]
+name = "M0Lindeberg046"
+
+[[lean_lib]]
+name = "M0Threshold046"
+
+[[lean_lib]]
+name = "M1Bridge046"

package/proofs/m1-046-bridge/lean-toolchain

@@ -0,0 +1 @@
+leanprover/lean4:v4.19.0