Download data/lean/OAI/Combinatorics/GraphThreshold/CapacityIteration.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 17.1 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/GraphThreshold/CapacityIteration.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Combinatorics/GraphThreshold/CapacityIteration.lean
-
curl -L -o CapacityIteration.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/GraphThreshold/CapacityIteration.lean
17.1 kB
| import Mathlib.Analysis.SpecialFunctions.Log.Base | |
| import Mathlib.Algebra.Order.Field.GeomSum | |
| import Mathlib.Algebra.Order.Floor.Semifield | |
| import Mathlib.Order.Interval.Set.Monotone | |
| import Mathlib.Tactic.Linarith | |
| import Mathlib.Tactic.NormNum | |
| import Mathlib.Tactic.Positivity | |
| import Mathlib.Tactic.Ring | |
| namespace OAI | |
| /-! | |
| # Capacities and finite inflation products | |
| The capacity after `t` successful reductions is natural-number division by | |
| `2^t`. All product estimates below are finite; no infinite product is used. | |
| -/ | |
| noncomputable section | |
| open Finset Set | |
| namespace LeanBlast.SecondKahnKalai | |
| def reducedCapacity (l t : β) : β := l / 2 ^ t | |
| def successesNeeded (l : β) : β := Nat.log2 l + 1 | |
| @[simp] theorem reducedCapacity_zero (l : β) : reducedCapacity l 0 = l := by | |
| simp [reducedCapacity] | |
| theorem reducedCapacity_succ (l t : β) : | |
| reducedCapacity l (t + 1) = reducedCapacity l t / 2 := by | |
| simp only [reducedCapacity, pow_succ, Nat.div_div_eq_div_mul] | |
| theorem reducedCapacity_add (l t u : β) : | |
| reducedCapacity l (t + u) = reducedCapacity (reducedCapacity l t) u := by | |
| simp only [reducedCapacity, pow_add, Nat.div_div_eq_div_mul] | |
| theorem reducedCapacity_eq_floor (l t : β) : | |
| reducedCapacity l t = β(l : β) / (2 : β) ^ tββ := by | |
| simpa only [reducedCapacity, Nat.cast_pow, Nat.cast_ofNat] using | |
| (Nat.floor_div_eq_div (K := β) l (2 ^ t)).symm | |
| theorem antitone_reducedCapacity (l : β) : Antitone (reducedCapacity l) := by | |
| apply antitone_nat_of_succ_le | |
| intro t | |
| rw [reducedCapacity_succ] | |
| exact Nat.div_le_self _ _ | |
| theorem monotone_reducedCapacity_left (t : β) : Monotone (fun l => reducedCapacity l t) := by | |
| intro a b hab | |
| exact Nat.div_le_div_right hab | |
| theorem reducedCapacity_zero_prefix {a b t : β} (hab : a β€ b) | |
| (hb : reducedCapacity b t = 0) : reducedCapacity a t = 0 := by | |
| have h := monotone_reducedCapacity_left t hab | |
| change reducedCapacity a t β€ reducedCapacity b t at h | |
| rw [hb] at h | |
| exact Nat.eq_zero_of_le_zero h | |
| theorem reducedCapacity_growth {a b : β} (hab : 16 * a β€ b) (t : β) : | |
| 16 * reducedCapacity a t β€ reducedCapacity b t := by | |
| unfold reducedCapacity | |
| apply (Nat.le_div_iff_mul_le (by positivity : 0 < 2 ^ t)).mpr | |
| calc | |
| 16 * (a / 2 ^ t) * 2 ^ t = 16 * (a / 2 ^ t * 2 ^ t) := by ring | |
| _ β€ 16 * a := Nat.mul_le_mul_left 16 (Nat.div_mul_le_self a (2 ^ t)) | |
| _ β€ b := hab | |
| theorem strictAntiOn_reducedCapacity {l t : β} (hpos : 0 < reducedCapacity l t) : | |
| StrictAntiOn (reducedCapacity l) (Set.Iic t) := by | |
| apply strictAntiOn_Iic_of_succ_lt | |
| intro u hu | |
| change reducedCapacity l (u + 1) < reducedCapacity l u | |
| rw [reducedCapacity_succ] | |
| exact Nat.div_lt_self (lt_of_lt_of_le hpos (antitone_reducedCapacity l hu.le)) (by decide) | |
| theorem reducedCapacity_successesNeeded (l : β) : | |
| reducedCapacity l (successesNeeded l) = 0 := by | |
| exact Nat.div_eq_of_lt Nat.lt_log2_self | |
| theorem reducedCapacity_eq_zero_of_le {a l : β} (hal : a β€ l) : | |
| reducedCapacity a (successesNeeded l) = 0 := by | |
| exact Nat.div_eq_of_lt (lt_of_le_of_lt hal Nat.lt_log2_self) | |
| theorem successesNeeded_pos (l : β) : 0 < successesNeeded l := by | |
| exact Nat.succ_pos _ | |
| theorem monotone_successesNeeded : Monotone successesNeeded := by | |
| intro a b hab | |
| simp only [successesNeeded, Nat.log2_eq_log_two, Nat.add_le_add_iff_right] | |
| exact Nat.log_mono_right hab | |
| theorem successesNeeded_half_lt {m : β} (hhalf : 0 < m / 2) : | |
| successesNeeded (m / 2) < successesNeeded m := by | |
| have hm : 2 β€ m := by omega | |
| have hl : Nat.log2 m = Nat.log2 (m / 2) + 1 := by | |
| rw [Nat.log2_def m, ite_eq_left hm] | |
| simp only [successesNeeded] | |
| omega | |
| theorem successesNeeded_eq_floor_logb (l : β) : | |
| successesNeeded l = βReal.logb 2 (l : β)ββ + 1 := by | |
| simpa only [successesNeeded, Nat.log2_eq_log_two, Nat.cast_ofNat] using | |
| congrArg (fun n : β => n + 1) (Real.natFloor_logb_natCast 2 l).symm | |
| theorem successesNeeded_le_logb (l : β) : | |
| (successesNeeded l : β) β€ 1 + Real.logb 2 (l : β) := by | |
| have h := Real.log2_le_logb l | |
| simp only [successesNeeded, Nat.cast_add, Nat.cast_one] | |
| linarith | |
| theorem capacity_logb_nonneg {l : β} (hl : 1 β€ l) : | |
| 0 β€ Real.logb 2 (l : β) := | |
| Real.logb_nonneg (by norm_num) (by exact_mod_cast hl) | |
| theorem label_empty_after_successes {X : Type*} (A : Finset X) {l L : β} | |
| (hl : l β€ L) (hA : A.card β€ reducedCapacity l (successesNeeded L)) : A = β := by | |
| rw [reducedCapacity_eq_zero_of_le hl] at hA | |
| exact Finset.card_eq_zero.mp (Nat.eq_zero_of_le_zero hA) | |
| /-- Geometric growth bounds every earlier prefix by one fifteenth of the | |
| current capacity. The natural form avoids premature division. -/ | |
| theorem capacity_prefix_sum_le (m : β β β) (k : β) | |
| (hgrowth : β j, j + 1 < k β 16 * m j β€ m (j + 1)) : | |
| β j, j < k β 15 * (β h β range j, m h) β€ m j := by | |
| intro j | |
| induction j with | |
| | zero => simp | |
| | succ j ih => | |
| intro hj | |
| have hp := ih (by omega) | |
| have hn := hgrowth j hj | |
| rw [sum_range_succ] | |
| omega | |
| theorem capacity_prefix_sum_real_le (m : β β β) (k : β) | |
| (hgrowth : β j, j + 1 < k β 16 * m j β€ m (j + 1)) | |
| {j : β} (hj : j < k) : | |
| (β h β range j, (m h : β)) β€ (m j : β) / 15 := by | |
| have h : (15 : β) * (β h β range j, (m h : β)) β€ (m j : β) := by | |
| exact_mod_cast capacity_prefix_sum_le m k hgrowth j hj | |
| linarith | |
| theorem strictMonoOn_capacities (m : β β β) (k : β) | |
| (hpos : β j, j < k β 1 β€ m j) | |
| (hgrowth : β j, j + 1 < k β 16 * m j β€ m (j + 1)) : | |
| StrictMonoOn m (Set.Iio k) := by | |
| intro i hi j hj hij | |
| change i < k at hi | |
| change j < k at hj | |
| have hmono : StrictMonoOn m (Set.Iic j) := by | |
| apply strictMonoOn_Iic_of_lt_succ | |
| intro a ha | |
| have hp := hpos a (by omega) | |
| have hg := hgrowth a (by omega) | |
| change m a < m (a + 1) | |
| omega | |
| exact hmono (show i β€ j from hij.le) (show j β€ j from Nat.le_refl j) hij | |
| /-- Index monotonicity also holds before an initial zero-capacity segment is | |
| removed. No positivity assumption is needed here. -/ | |
| theorem monotoneOn_capacities (m : β β β) (k : β) | |
| (hgrowth : β j, j + 1 < k β 16 * m j β€ m (j + 1)) : | |
| MonotoneOn m (Set.Iio k) := by | |
| apply monotoneOn_of_le_succ Set.ordConnected_Iio | |
| intro j _ _ hj | |
| have hg := hgrowth j hj | |
| change m j β€ m (j + 1) | |
| omega | |
| /-- A finite sum of distinct positive geometric powers. -/ | |
| theorem sum_positive_geometric_le (s : Finset β) {q : β} | |
| (hq : 0 β€ q) (hq1 : q < 1) (hpos : β m β s, 1 β€ m) : | |
| (β m β s, q ^ m) β€ q / (1 - q) := by | |
| obtain β¨N, hNβ© := s.exists_nat_subset_range | |
| calc | |
| (β m β s, q ^ m) β€ β m β Finset.Ico 1 N, q ^ m := by | |
| apply sum_le_sum_of_subset_of_nonneg | |
| Β· intro m hm | |
| exact Finset.mem_Ico.mpr β¨hpos m hm, mem_range.mp (hN hm)β© | |
| Β· intro m _ _ | |
| exact pow_nonneg hq _ | |
| _ β€ q / (1 - q) := by | |
| simpa only [pow_one] using geom_sum_Ico_le_of_lt_one (m := 1) (n := N) hq hq1 | |
| /-- Elementary finite product bound, applied below to the retention factors. -/ | |
| theorem one_sub_sum_le_prod_one_sub {ΞΉ : Type*} (s : Finset ΞΉ) (f : ΞΉ β β) | |
| (h0 : β i β s, 0 β€ f i) (h1 : β i β s, f i β€ 1) : | |
| 1 - (β i β s, f i) β€ β i β s, (1 - f i) := by | |
| classical | |
| induction s using Finset.induction_on with | |
| | empty => simp | |
| | @insert i s hi ih => | |
| have h0i := h0 i (mem_insert_self _ _) | |
| have h1i := h1 i (mem_insert_self _ _) | |
| have h0s : β j β s, 0 β€ f j := fun j hj => h0 j (mem_insert_of_mem hj) | |
| have h1s : β j β s, f j β€ 1 := fun j hj => h1 j (mem_insert_of_mem hj) | |
| have hp := mul_le_mul_of_nonneg_left (ih h0s h1s) (sub_nonneg.mpr h1i) | |
| have hs := sum_nonneg h0s | |
| rw [sum_insert hi, prod_insert hi] | |
| nlinarith [mul_nonneg h0i hs] | |
| theorem exp_neg_one_le_two_fifths : Real.exp (-1) β€ (2 / 5 : β) := by | |
| have he : (5 / 2 : β) β€ Real.exp 1 := by | |
| have h := Real.quadratic_le_exp_of_nonneg (show (0 : β) β€ 1 by norm_num) | |
| norm_num at h | |
| exact h | |
| rw [Real.exp_neg] | |
| apply (inv_le_iff_one_le_mulβ (Real.exp_pos 1)).mpr | |
| nlinarith | |
| theorem sum_exp_neg_capacities_le_two_thirds (s : Finset β) | |
| (hpos : β m β s, 1 β€ m) : | |
| (β m β s, Real.exp (-(m : β))) β€ (2 / 3 : β) := by | |
| have hq0 := (Real.exp_pos (-1)).le | |
| have hq1 : Real.exp (-1) < 1 := lt_of_le_of_lt exp_neg_one_le_two_fifths (by norm_num) | |
| have heq (m : β) : Real.exp (-(m : β)) = Real.exp (-1) ^ m := by | |
| simpa only [mul_neg_one] using Real.exp_nat_mul (-1) m | |
| simp_rw [heq] | |
| apply (sum_positive_geometric_le s hq0 hq1 hpos).trans | |
| apply (div_le_iffβ (sub_pos.mpr hq1)).mpr | |
| nlinarith [exp_neg_one_le_two_fifths] | |
| theorem finite_retentionProduct_ge_one_third (s : Finset β) | |
| (hpos : β m β s, 1 β€ m) : | |
| (1 / 3 : β) β€ β m β s, (1 - Real.exp (-(m : β))) := by | |
| have h0 (m : β) (_ : m β s) : 0 β€ Real.exp (-(m : β)) := (Real.exp_pos _).le | |
| have h1 (m : β) (_ : m β s) : Real.exp (-(m : β)) β€ 1 := by | |
| rw [Real.exp_le_one_iff] | |
| exact neg_nonpos.mpr (Nat.cast_nonneg m) | |
| have hb := one_sub_sum_le_prod_one_sub s (fun m => Real.exp (-(m : β))) h0 h1 | |
| have hs := sum_exp_neg_capacities_le_two_thirds s hpos | |
| linarith | |
| theorem finite_spreadInflation_lt_four (s : Finset β) | |
| (hpos : β m β s, 1 β€ m) : | |
| (β m β s, (1 - Real.exp (-(m : β)))β»ΒΉ) < 4 := by | |
| have hp := finite_retentionProduct_ge_one_third s hpos | |
| have hp0 : 0 < β m β s, (1 - Real.exp (-(m : β))) := lt_of_lt_of_le (by norm_num) hp | |
| rw [Finset.prod_inv_distrib] | |
| apply (inv_lt_iff_one_lt_mulβ hp0).mpr | |
| nlinarith | |
| theorem spreadInflation_lt_four {ΞΉ : Type*} [DecidableEq ΞΉ] | |
| (s : Finset ΞΉ) (m : ΞΉ β β) (hpos : β i β s, 1 β€ m i) | |
| (hinj : Set.InjOn m (βs : Set ΞΉ)) : | |
| (β i β s, (1 - Real.exp (-(m i : β)))β»ΒΉ) < 4 := by | |
| have heq : (β i β s, (1 - Real.exp (-(m i : β)))β»ΒΉ) = | |
| β n β s.image m, (1 - Real.exp (-(n : β)))β»ΒΉ := by | |
| symm | |
| exact Finset.prod_image hinj | |
| rw [heq] | |
| apply finite_spreadInflation_lt_four | |
| intro n hn | |
| obtain β¨i, hi, rflβ© := Finset.mem_image.mp hn | |
| exact hpos i hi | |
| def iteratedSpread (Ο : β) (l t : β) : β := | |
| Ο * β u β range t, (1 - Real.exp (-(reducedCapacity l u : β)))β»ΒΉ | |
| @[simp] theorem iteratedSpread_zero (Ο : β) (l : β) : iteratedSpread Ο l 0 = Ο := by | |
| simp [iteratedSpread] | |
| theorem iteratedSpread_succ (Ο : β) (l t : β) : | |
| iteratedSpread Ο l (t + 1) = | |
| iteratedSpread Ο l t / (1 - Real.exp (-(reducedCapacity l t : β))) := by | |
| simp only [iteratedSpread, prod_range_succ, div_eq_mul_inv, mul_assoc] | |
| theorem halving_spreadInflation_lt_four {l t : β} (hpos : 0 < reducedCapacity l t) : | |
| (β u β range t, (1 - Real.exp (-(reducedCapacity l u : β)))β»ΒΉ) < 4 := by | |
| apply spreadInflation_lt_four (range t) (reducedCapacity l) | |
| Β· intro u hu | |
| exact le_trans hpos (antitone_reducedCapacity l (le_of_lt (mem_range.mp hu))) | |
| Β· intro u hu v hv huv | |
| exact (strictAntiOn_reducedCapacity hpos).injOn | |
| (le_of_lt (mem_range.mp hu)) (le_of_lt (mem_range.mp hv)) huv | |
| theorem iteratedSpread_pos {Ο : β} (hΟ : 0 < Ο) {l t : β} | |
| (hpos : 0 < reducedCapacity l t) : 0 < iteratedSpread Ο l t := by | |
| apply mul_pos hΟ | |
| apply Finset.prod_pos | |
| intro u hu | |
| apply inv_pos.mpr | |
| apply sub_pos.mpr | |
| rw [Real.exp_lt_one_iff] | |
| have hp : 0 < reducedCapacity l u := | |
| lt_of_lt_of_le hpos (antitone_reducedCapacity l (mem_range.mp hu).le) | |
| exact neg_neg_of_pos (by exact_mod_cast hp) | |
| theorem iteratedSpread_le_four_mul {Ο : β} (hΟ : 0 < Ο) {l t : β} | |
| (hpos : 0 < reducedCapacity l t) : iteratedSpread Ο l t β€ 4 * Ο := by | |
| have h := mul_lt_mul_of_pos_left (halving_spreadInflation_lt_four hpos) hΟ | |
| simpa only [iteratedSpread, mul_comm Ο 4] using h.le | |
| theorem exp_neg_seven_le_one_eighth : Real.exp (-7) β€ (1 / 8 : β) := by | |
| have he : (8 : β) β€ Real.exp 7 := by | |
| have h := Real.add_one_le_exp (7 : β) | |
| norm_num at h | |
| exact h | |
| rw [Real.exp_neg] | |
| apply (inv_le_iff_one_le_mulβ (Real.exp_pos 7)).mpr | |
| nlinarith | |
| theorem sum_exp_neg_seven_capacities_lt_one_quarter (s : Finset β) | |
| (hpos : β m β s, 1 β€ m) : | |
| (β m β s, Real.exp (-7 * (m : β))) < (1 / 4 : β) := by | |
| have hq0 := (Real.exp_pos (-7)).le | |
| have hq1 : Real.exp (-7) < 1 := lt_of_le_of_lt exp_neg_seven_le_one_eighth (by norm_num) | |
| have heq (m : β) : Real.exp (-7 * (m : β)) = Real.exp (-7) ^ m := by | |
| simpa only [mul_comm] using Real.exp_nat_mul (-7) m | |
| simp_rw [heq] | |
| have hsum := sum_positive_geometric_le s hq0 hq1 hpos | |
| have hfrac : Real.exp (-7) / (1 - Real.exp (-7)) β€ (1 / 7 : β) := by | |
| apply (div_le_iffβ (sub_pos.mpr hq1)).mpr | |
| nlinarith [exp_neg_seven_le_one_eighth] | |
| exact lt_of_le_of_lt (hsum.trans hfrac) (by norm_num) | |
| theorem capacity_failure_sum_lt_one_quarter (m : β β β) (k : β) | |
| (hpos : β j, j < k β 1 β€ m j) | |
| (hgrowth : β j, j + 1 < k β 16 * m j β€ m (j + 1)) : | |
| (β j β range k, | |
| Real.exp (12 * (β h β range j, (m h : β)) - 8 * (m j : β))) < (1 / 4 : β) := by | |
| have hmono := strictMonoOn_capacities m k hpos hgrowth | |
| have hinj : Set.InjOn m (β(range k) : Set β) := by | |
| intro i hi j hj hij | |
| exact hmono.injOn (mem_range.mp hi) (mem_range.mp hj) hij | |
| calc | |
| (β j β range k, | |
| Real.exp (12 * (β h β range j, (m h : β)) - 8 * (m j : β))) | |
| β€ β j β range k, Real.exp (-7 * (m j : β)) := by | |
| apply Finset.sum_le_sum | |
| intro j hj | |
| apply Real.exp_le_exp.mpr | |
| have hs := capacity_prefix_sum_real_le m k hgrowth (mem_range.mp hj) | |
| have hm : 0 β€ (m j : β) := Nat.cast_nonneg _ | |
| nlinarith | |
| _ = β n β (range k).image m, Real.exp (-7 * (n : β)) := by | |
| symm | |
| exact Finset.sum_image hinj | |
| _ < 1 / 4 := by | |
| apply sum_exp_neg_seven_capacities_lt_one_quarter | |
| intro n hn | |
| obtain β¨j, hj, rflβ© := mem_image.mp hn | |
| exact hpos j (mem_range.mp hj) | |
| /-- A history-free allowance for the spread parameter at capacity `m`. -/ | |
| def capacityReserve (Ο : β) (m : β) : β := | |
| 4 * Ο * β j β Finset.Icc 1 m, (1 - Real.exp (-(j : β))) | |
| theorem retentionFactor_pos {m : β} (hm : 0 < m) : | |
| 0 < 1 - Real.exp (-(m : β)) := by | |
| apply sub_pos.mpr | |
| rw [Real.exp_lt_one_iff] | |
| exact neg_neg_of_pos (by exact_mod_cast hm) | |
| theorem retentionFactor_le_one (m : β) : | |
| 1 - Real.exp (-(m : β)) β€ 1 := sub_le_self _ (Real.exp_pos _).le | |
| @[simp] theorem capacityReserve_zero (Ο : β) : capacityReserve Ο 0 = 4 * Ο := by | |
| simp [capacityReserve] | |
| theorem capacityReserve_pos {Ο : β} (hΟ : 0 < Ο) (m : β) : | |
| 0 < capacityReserve Ο m := by | |
| apply mul_pos (mul_pos (by norm_num) hΟ) | |
| apply Finset.prod_pos | |
| intro j hj | |
| exact retentionFactor_pos (Finset.mem_Icc.mp hj).1 | |
| theorem capacityReserve_lower {Ο : β} (hΟ : 0 β€ Ο) (m : β) : | |
| Ο β€ capacityReserve Ο m := by | |
| have hp := finite_retentionProduct_ge_one_third (Finset.Icc 1 m) | |
| (fun j hj => (Finset.mem_Icc.mp hj).1) | |
| have hm := mul_le_mul_of_nonneg_left hp (mul_nonneg (by norm_num : (0 : β) β€ 4) hΟ) | |
| unfold capacityReserve | |
| nlinarith | |
| theorem capacityReserve_upper {Ο : β} (hΟ : 0 β€ Ο) (m : β) : | |
| capacityReserve Ο m β€ 4 * Ο := by | |
| have hp : (β j β Finset.Icc 1 m, (1 - Real.exp (-(j : β)))) β€ 1 := by | |
| apply Finset.prod_le_oneβ | |
| Β· intro j hj | |
| exact (retentionFactor_pos (Finset.mem_Icc.mp hj).1).le | |
| Β· intro j _ | |
| exact retentionFactor_le_one j | |
| have hm := mul_le_mul_of_nonneg_left hp (mul_nonneg (by norm_num : (0 : β) β€ 4) hΟ) | |
| simpa only [capacityReserve, mul_one] using hm | |
| theorem antitone_capacityReserve {Ο : β} (hΟ : 0 β€ Ο) : | |
| Antitone (capacityReserve Ο) := by | |
| intro a b hab | |
| apply mul_le_mul_of_nonneg_left _ (mul_nonneg (by norm_num : (0 : β) β€ 4) hΟ) | |
| apply Finset.prod_le_prod_of_subset_of_le_oneβ | |
| Β· intro j hj | |
| obtain β¨hj1, hjaβ© := Finset.mem_Icc.mp hj | |
| exact Finset.mem_Icc.mpr β¨hj1, hja.trans habβ© | |
| Β· intro j hj | |
| exact (retentionFactor_pos (Finset.mem_Icc.mp hj).1).le | |
| Β· intro j _ _ | |
| exact retentionFactor_le_one j | |
| theorem capacityReserve_succ (Ο : β) (m : β) : | |
| capacityReserve Ο (m + 1) = capacityReserve Ο m * | |
| (1 - Real.exp (-((m + 1 : β) : β))) := by | |
| simp only [capacityReserve, Finset.prod_Icc_succ_top (show 1 β€ m + 1 by omega), mul_assoc] | |
| theorem capacityReserve_div_le_half {Ο : β} (hΟ : 0 β€ Ο) {m : β} (hm : 0 < m) : | |
| capacityReserve Ο m / (1 - Real.exp (-(m : β))) β€ capacityReserve Ο (m / 2) := by | |
| obtain β¨m, rflβ© := Nat.exists_eq_succ_of_ne_zero (Nat.ne_of_gt hm) | |
| rw [capacityReserve_succ, mul_div_cancel_rightβ _ (retentionFactor_pos (Nat.succ_pos m)).ne'] | |
| exact antitone_capacityReserve hΟ (show (m + 1) / 2 β€ m by omega) | |
| end LeanBlast.SecondKahnKalai | |
| end | |
| end OAI | |