Download data/lean/OAI/Probability/SATVariance/MarkovReplacement.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 18.9 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/SATVariance/MarkovReplacement.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/SATVariance/MarkovReplacement.lean
-
curl -L -o MarkovReplacement.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/SATVariance/MarkovReplacement.lean
18.9 kB
| import OAI.Probability.SATVariance.BlockKilling | |
| namespace OAI | |
| noncomputable section | |
| open MeasureTheory ProbabilityTheory | |
| namespace RandomKSAT | |
| open scoped Classical ENNReal | |
| def favg.{u_1} {Ξ± : Type u_1} [Fintype Ξ±] (f : Ξ± β β) : β := | |
| (β a, f a) / Fintype.card Ξ± | |
| lemma favg_mono.{u_1} {Ξ± : Type u_1} [Fintype Ξ±] {f g : Ξ± β β} (h : β a, f a β€ g a) : | |
| favg f β€ favg g := by | |
| exact div_le_div_of_nonneg_right (Finset.sum_le_sum fun a _ => h a) (by positivity) | |
| lemma favg_const.{u_1} {Ξ± : Type u_1} [Fintype Ξ±] [Nonempty Ξ±] (c : β) : | |
| favg (fun _ : Ξ± => c) = c := by | |
| simp [favg, Fintype.card_ne_zero] | |
| lemma favg_add.{u_1} {Ξ± : Type u_1} [Fintype Ξ±] (f g : Ξ± β β) : | |
| favg (fun a => f a + g a) = favg f + favg g := by | |
| simp only [favg, Finset.sum_add_distrib, add_div] | |
| lemma favg_sub.{u_1} {Ξ± : Type u_1} [Fintype Ξ±] (f g : Ξ± β β) : | |
| favg (fun a => f a - g a) = favg f - favg g := by | |
| simp only [favg, Finset.sum_sub_distrib, sub_div] | |
| lemma favg_equiv.{u_1, u_2} {Ξ± : Type u_1} {Ξ² : Type u_2} [Fintype Ξ±] [Fintype Ξ²] (e : Ξ± β Ξ²) (f : Ξ² β β) : | |
| favg (fun a => f (e a)) = favg f := by | |
| rw [favg, favg, e.sum_comp f, Fintype.card_congr e] | |
| lemma favg_comm.{u_1, u_2} {Ξ± : Type u_1} {Ξ² : Type u_2} [Fintype Ξ±] [Fintype Ξ²] (f : Ξ± β Ξ² β β) : | |
| favg (fun a => favg (f a)) = favg (fun b => favg (fun a => f a b)) := by | |
| simp only [favg, β Finset.sum_div] | |
| rw [Finset.sum_comm] | |
| ring | |
| lemma favg_prod.{u_1, u_2} {Ξ± : Type u_1} {Ξ² : Type u_2} [Fintype Ξ±] [Fintype Ξ²] (f : Ξ± Γ Ξ² β β) : | |
| favg f = favg (fun a => favg fun b => f (a,b)) := by | |
| simp only [favg, Fintype.sum_prod_type, Fintype.card_prod, Nat.cast_mul, | |
| β Finset.sum_div] | |
| ring | |
| lemma uniformOn_real.{u_1} {Ξ± : Type u_1} [Fintype Ξ±] [MeasurableSpace Ξ±] | |
| [MeasurableSingletonClass Ξ±] (s : Set Ξ±) : | |
| (uniformOn Set.univ s).toReal = favg (fun a => if a β s then 1 else 0) := by | |
| rw [uniformOn_univ, count_set_fintype] | |
| simp only [ENNReal.toReal_div, ENNReal.toReal_natCast, favg] | |
| congr 1 | |
| simp [Fintype.card_subtype] | |
| lemma prefixLaw {u s : β} (hsu : s β€ u) (m : β) : | |
| (streamLaw u s).map (fun Ο (i : Fin m) => Ο i) = | |
| uniformOn (Set.univ : Set (Fin m β Clause u s)) := by | |
| let := clauseLaw_probability u s hsu | |
| rw [streamLaw, Measure.map_infinitePi_infinitePi_of_inj Fin.val_injective, | |
| Measure.infinitePi_eq_pi] | |
| simpa only [Set.pi_univ, clauseLaw] using | |
| (uniformOn_pi (f := fun _ : Fin m => (Set.univ : Set (Clause u s)))).symm | |
| def residual.{u_1} {u s : β} {ΞΉ : Type u_1} [Fintype ΞΉ] | |
| (S : Finset (Assignment u)) (cs : ΞΉ β Clause u s) : Finset (Assignment u) := | |
| S.filter fun a => β i, Satisfies (cs i) a | |
| lemma residual_comm.{u_1, u_2} {u r s : β} {ΞΉ : Type u_1} {ΞΊ : Type u_2} [Fintype ΞΉ] [Fintype ΞΊ] | |
| (S : Finset (Assignment u)) (cs : ΞΉ β Clause u r) (ds : ΞΊ β Clause u s) : | |
| residual (residual S cs) ds = residual (residual S ds) cs := by | |
| ext a | |
| simp only [residual, Finset.mem_filter] | |
| tauto | |
| lemma residual_cons {u s m : β} (S : Finset (Assignment u)) (c : Clause u s) | |
| (cs : Fin m β Clause u s) : | |
| residual S (Fin.cons c cs) = residual (S.filter (Satisfies c)) cs := by | |
| ext a | |
| simp [residual, Fin.forall_fin_succ, and_assoc] | |
| def clauseStep (u s : β) (f : Finset (Assignment u) β β) | |
| (S : Finset (Assignment u)) : β := | |
| favg fun c : Clause u s => f (S.filter (Satisfies c)) | |
| def alive (u : β) (S : Finset (Assignment u)) : β := if S.Nonempty then 1 else 0 | |
| lemma clauseStep_mono (u s : β) : Monotone (clauseStep u s) := by | |
| intro f g h S | |
| exact favg_mono fun c => h _ | |
| lemma clauseStep_const {u s : β} (hsu : s β€ u) (c : β) : | |
| clauseStep u s (fun _ => c) = fun _ => c := by | |
| let := clause_nonempty u s hsu | |
| funext S | |
| exact favg_const c | |
| lemma clauseStep_add (u s : β) (f g : Finset (Assignment u) β β) : | |
| clauseStep u s (f+g) = clauseStep u s f + clauseStep u s g := by | |
| funext S | |
| exact favg_add _ _ | |
| lemma clauseStep_comm (u r s : β) : Function.Commute (clauseStep u r) (clauseStep u s) := by | |
| intro f | |
| funext S | |
| unfold clauseStep | |
| rw [favg_comm] | |
| congr 1 | |
| funext d | |
| congr 1 | |
| funext c | |
| congr 1 | |
| ext a | |
| simp only [Finset.mem_filter] | |
| tauto | |
| lemma clauseStep_iterate_avg (u s m : β) (f : Finset (Assignment u) β β) | |
| (S : Finset (Assignment u)) : | |
| (clauseStep u s)^[m] f S = favg (fun cs : Fin m β Clause u s => f (residual S cs)) := by | |
| induction m generalizing S with | |
| | zero => simp [residual, favg] | |
| | succ m ih => | |
| rw [Function.iterate_succ_apply', clauseStep] | |
| simp_rw [ih] | |
| rw [β favg_prod (fun p : Clause u s Γ (Fin m β Clause u s) => | |
| f (residual (S.filter (Satisfies p.1)) p.2)), | |
| β favg_equiv (Fin.consEquiv (fun _ : Fin (m+1) => Clause u s))] | |
| congr 1 | |
| funext p | |
| simp only [Fin.consEquiv, Equiv.coe_fn_mk, residual_cons] | |
| lemma blockKill_iterate {u s : β} (hsu : s β€ u) (S : Finset (Assignment u)) (m : β) : | |
| blockKill u s S m = 1 - (clauseStep u s)^[m] (alive u) S := by | |
| rw [blockKill_compl hsu, clauseStep_iterate_avg] | |
| congr 1 | |
| have he : {Ο : Stream u s | SetSAT S Ο m} = | |
| (fun Ο (i : Fin m) => Ο i) β»ΒΉ' {cs | (residual S cs).Nonempty} := by | |
| ext Ο | |
| simp only [Set.mem_ofPred_eq, Set.mem_preimage, SetSAT, residual, | |
| Finset.Nonempty, Finset.mem_filter] | |
| exact exists_congr fun a => and_congr_right fun _ => (Fin.forall_iff (p := fun i : Fin m => Satisfies (Ο i) a)).symm | |
| rw [he, β Measure.map_apply (by fun_prop) (Set.toFinite _).measurableSet, prefixLaw hsu, | |
| uniformOn_real] | |
| simp only [alive, Set.mem_ofPred_eq] | |
| congr 1 | |
| funext cs | |
| split_ifs <;> rfl | |
| lemma iterate_add_const.{u_1} {Ξ± : Type u_1} (A : (Ξ± β β) β (Ξ± β β)) | |
| (hA : β f c, A (f + fun _ => c) = A f + fun _ => c) | |
| (m : β) (f : Ξ± β β) (c : β) : | |
| A^[m] (f + fun _ => c) = A^[m] f + fun _ => c := by | |
| induction m with | |
| | zero => rfl | |
| | succ m ih => rw [Function.iterate_succ_apply', ih, hA, Function.iterate_succ_apply'] | |
| lemma markov_telescoping.{u_1} {Ξ± : Type u_1} (A B : (Ξ± β β) β (Ξ± β β)) | |
| (hA : Monotone A) (hB : Monotone B) | |
| (hAc : β f c, A (f + fun _ => c) = A f + fun _ => c) | |
| (hBc : β f c, B (f + fun _ => c) = B f + fun _ => c) | |
| (hcomm : Function.Commute A B) (f : Ξ± β β) (Ξ΄ : β) | |
| (hone : A f β€ B f + fun _ => Ξ΄) (d : β) : | |
| A^[d] f β€ B^[d] f + fun _ => (d : β)*Ξ΄ := by | |
| induction d with | |
| | zero => intro x; simp | |
| | succ d ih => | |
| have hβ := hA.iterate d hone | |
| rw [iterate_add_const A hAc, hcomm.iterate_left d f] at hβ | |
| have hβ := hB ih | |
| rw [hBc, β Function.iterate_succ_apply' B d f] at hβ | |
| intro x | |
| have hβx := hβ x | |
| have hβx := hβ x | |
| simp only [Pi.add_apply] at hβx hβx | |
| rw [Function.iterate_succ_apply] | |
| change A^[d] (A f) x β€ B^[d+1] f x + ((d+1 : β) : β)*Ξ΄ | |
| push_cast | |
| linarith | |
| lemma clauseStep_add_const {u s : β} (hsu : s β€ u) | |
| (f : Finset (Assignment u) β β) (c : β) : | |
| clauseStep u s (f + fun _ => c) = clauseStep u s f + fun _ => c := by | |
| rw [clauseStep_add, clauseStep_const hsu] | |
| lemma sequential_replacement {u r g : β} (hr : 2 β€ r) (hru : r+1 β€ u) (hg : 1 β€ g) | |
| (S : Finset (Assignment u)) (d : β) : | |
| blockKill u r S d - (d : β)*replacementK (r+1)/(g : β)^r β€ | |
| blockKill u (r+1) S (d*g) := by | |
| have hru' : r β€ u := by omega | |
| have hone : (clauseStep u (r+1))^[g] (alive u) β€ | |
| clauseStep u r (alive u) + fun _ => replacementK (r+1)/(g : β)^r := by | |
| intro S' | |
| have h := one_replacement hr hru hg S' | |
| rw [blockKill_iterate hru', blockKill_iterate hru, Function.iterate_one] at h | |
| change _ β€ clauseStep u r (alive u) S' + replacementK (r+1)/(g : β)^r | |
| linarith | |
| have hh := markov_telescoping (clauseStep u (r+1))^[g] (clauseStep u r) | |
| ((clauseStep_mono u (r+1)).iterate g) (clauseStep_mono u r) | |
| (iterate_add_const _ (clauseStep_add_const hru) g) | |
| (clauseStep_add_const hru') ((clauseStep_comm u (r+1) r).iterate_left g) | |
| (alive u) (replacementK (r+1)/(g : β)^r) hone d S | |
| rw [β Function.iterate_mul, Nat.mul_comm g d] at hh | |
| rw [blockKill_iterate hru', blockKill_iterate hru] | |
| change _ β€ _ | |
| simp only [Pi.add_apply, β mul_div_assoc] at hh | |
| linarith | |
| lemma favg_mul.{u_1} {Ξ± : Type u_1} [Fintype Ξ±] (c : β) (f : Ξ± β β) : | |
| favg (fun a => c*f a) = c*favg f := by | |
| simp only [favg, β Finset.mul_sum] | |
| ring | |
| lemma favg_nonneg.{u_1} {Ξ± : Type u_1} [Fintype Ξ±] {f : Ξ± β β} (h : β a, 0 β€ f a) : | |
| 0 β€ favg f := by | |
| exact div_nonneg (Finset.sum_nonneg fun a _ => h a) (by positivity) | |
| lemma residual_subset.{u_1} {u s : β} {ΞΉ : Type u_1} [Fintype ΞΉ] | |
| (S : Finset (Assignment u)) (cs : ΞΉ β Clause u s) : residual S cs β S := | |
| Finset.filter_subset _ _ | |
| lemma residual_mono.{u_1} {u s : β} {ΞΉ : Type u_1} [Fintype ΞΉ] | |
| {S T : Finset (Assignment u)} (h : S β T) (cs : ΞΉ β Clause u s) : | |
| residual S cs β residual T cs := Finset.filter_subset_filter _ h | |
| lemma alive_nonneg (u : β) (S : Finset (Assignment u)) : 0 β€ alive u S := by | |
| unfold alive | |
| split_ifs <;> norm_num | |
| lemma alive_le_one (u : β) (S : Finset (Assignment u)) : alive u S β€ 1 := by | |
| unfold alive | |
| split_ifs <;> norm_num | |
| lemma alive_mono {u : β} {S T : Finset (Assignment u)} (h : S β T) : | |
| alive u S β€ alive u T := by | |
| unfold alive | |
| by_cases hS : S.Nonempty | |
| Β· simp [hS, hS.mono h] | |
| Β· simp only [hS, ite_false] | |
| split_ifs <;> norm_num | |
| def survival (u s : β) (S : Finset (Assignment u)) (m : β) : β := | |
| (clauseStep u s)^[m] (alive u) S | |
| lemma survival_avg (u s : β) (S : Finset (Assignment u)) (m : β) : | |
| survival u s S m = favg fun cs : Fin m β Clause u s => alive u (residual S cs) := | |
| clauseStep_iterate_avg _ _ _ _ _ | |
| lemma survival_zero (u s : β) (S : Finset (Assignment u)) : survival u s S 0 = alive u S := rfl | |
| lemma survival_empty (u s m : β) : survival u s β m = 0 := by | |
| simp [survival_avg, residual, alive, favg] | |
| lemma survival_nonneg (u s : β) (S : Finset (Assignment u)) (m : β) : | |
| 0 β€ survival u s S m := by | |
| rw [survival_avg] | |
| exact favg_nonneg fun _ => alive_nonneg _ _ | |
| lemma survival_le_one {u s : β} (hsu : s β€ u) (S : Finset (Assignment u)) (m : β) : | |
| survival u s S m β€ 1 := by | |
| let := clause_nonempty u s hsu | |
| rw [survival_avg, β favg_const (Ξ± := Fin m β Clause u s) (1 : β)] | |
| exact favg_mono fun _ => alive_le_one _ _ | |
| lemma survival_mono {u s : β} {S T : Finset (Assignment u)} (h : S β T) (m : β) : | |
| survival u s S m β€ survival u s T m := by | |
| rw [survival_avg, survival_avg] | |
| exact favg_mono fun _ => alive_mono (residual_mono h _) | |
| lemma survival_eq_prob {u s : β} (hsu : s β€ u) (S : Finset (Assignment u)) (m : β) : | |
| survival u s S m = (streamLaw u s {Ο | SetSAT S Ο m}).toReal := by | |
| have h := blockKill_iterate hsu S m | |
| rw [blockKill_compl hsu] at h | |
| change _ = 1 - survival u s S m at h | |
| linarith | |
| lemma survival_summable {u s : β} (hsu : s β€ u) (S : Finset (Assignment u)) : | |
| Summable (survival u s S) := by | |
| have hr : 1-((2 : β)^s)β»ΒΉ < 1 := by | |
| have h : 0 < ((2 : β)^s)β»ΒΉ := by positivity | |
| linarith | |
| apply Summable.of_nonneg_of_le (survival_nonneg u s S) _ | |
| ((summable_geometric_of_lt_one (real_rate_nonneg s) hr).mul_left (S.card : β)) | |
| intro m | |
| rw [survival_eq_prob hsu] | |
| have h := ENNReal.toReal_mono (by finiteness) (set_survival_le hsu S m) | |
| simpa only [ENNReal.toReal_mul, ENNReal.toReal_natCast, ENNReal.toReal_pow, rate_toReal] using h | |
| lemma survival_add (u s : β) (S : Finset (Assignment u)) (m j : β) : | |
| survival u s S (m+j) = | |
| favg fun cs : Fin m β Clause u s => survival u s (residual S cs) j := by | |
| unfold survival | |
| rw [Function.iterate_add_apply, clauseStep_iterate_avg] | |
| lemma survival_submultiplicative (u s : β) (S : Finset (Assignment u)) (m j : β) : | |
| survival u s S (m+j) β€ survival u s S m * survival u s S j := by | |
| rw [survival_add] | |
| calc | |
| _ β€ favg (fun cs : Fin m β Clause u s => | |
| survival u s S j * alive u (residual S cs)) := by | |
| apply favg_mono | |
| intro cs | |
| by_cases he : (residual S cs).Nonempty | |
| Β· simpa [alive, he] using survival_mono (residual_subset S cs) j | |
| Β· have he' := Finset.not_nonempty_iff_eq_empty.mp he | |
| simp [he', alive, survival_empty] | |
| _ = _ := by rw [favg_mul, β survival_avg]; ring | |
| def lifetime (u s : β) (S : Finset (Assignment u)) : β := β' m, survival u s S m | |
| lemma lifetime_nonneg (u s : β) (S : Finset (Assignment u)) : 0 β€ lifetime u s S := | |
| tsum_nonneg (survival_nonneg u s S) | |
| lemma lifetime_empty (u s : β) : lifetime u s β = 0 := by simp [lifetime, survival_empty] | |
| lemma lifetime_block {u s : β} (hsu : s β€ u) (S : Finset (Assignment u)) (m : β) | |
| (hR : 0 < blockKill u s S m) : | |
| lifetime u s S β€ (m : β) / blockKill u s S m := by | |
| have hsum := survival_summable hsu S | |
| have hsplit := hsum.sum_add_tsum_nat_add m | |
| have hhead : β i β Finset.range m, survival u s S i β€ (m : β) := by | |
| calc | |
| _ β€ β _i β Finset.range m, (1 : β) := Finset.sum_le_sum fun i _ => survival_le_one hsu S i | |
| _ = _ := by simp | |
| have htail : (β' j, survival u s S (j+m)) β€ survival u s S m * lifetime u s S := by | |
| rw [lifetime, β tsum_mul_left] | |
| apply Summable.tsum_le_tsum _ (hsum.comp_injective (fun _ _ h => Nat.add_right_cancel h)) | |
| (hsum.mul_left _) | |
| intro j | |
| change survival u s S (j+m) β€ _ | |
| rw [Nat.add_comm j m] | |
| exact survival_submultiplicative u s S m j | |
| apply (le_div_iffβ hR).2 | |
| rw [blockKill_iterate hsu] | |
| change lifetime u s S * (1 - survival u s S m) β€ (m : β) | |
| change _ + _ = lifetime u s S at hsplit | |
| nlinarith | |
| def lifetimeBeta (k : β) : β := (k : β) / ((k-1 : β) : β) | |
| def lifetimeC (k : β) : β := 4 * (2*replacementK k)^(((k-1 : β) : β)β»ΒΉ) | |
| lemma replacementK_one_le {r : β} (hr : 1 β€ r) : 1 β€ replacementK (r+1) := by | |
| rw [replacementK_succ] | |
| apply one_le_powβ | |
| exact one_le_mul_of_one_le_of_one_le (one_le_powβ (by norm_num)) (by exact_mod_cast hr) | |
| lemma lifetimeBeta_succ {r : β} (hr : 0 < r) : lifetimeBeta (r+1) = 1+(r : β)β»ΒΉ := by | |
| simp only [lifetimeBeta, Nat.add_sub_cancel, Nat.cast_add, Nat.cast_one] | |
| have hrβ : (r : β) β 0 := by exact_mod_cast (Nat.ne_of_gt hr) | |
| field_simp | |
| lemma lifetimeC_pos {r : β} (hr : 1 β€ r) : 0 < lifetimeC (r+1) := by | |
| have hK := replacementK_one_le hr | |
| unfold lifetimeC | |
| exact mul_pos (by norm_num) (Real.rpow_pos_of_pos (by linarith) _) | |
| lemma replacement_block_choice {r d : β} (hr : 1 β€ r) (hd : 1 β€ d) | |
| {q : β} (hq : 0 < q) (hqβ : q β€ 1) : | |
| β g : β, 1 β€ g β§ | |
| (d : β)*replacementK (r+1)/(g : β)^r β€ q/2 β§ | |
| (g : β) β€ 2*(2*replacementK (r+1)*d/q)^((r : β)β»ΒΉ) := by | |
| let x : β := (2*replacementK (r+1)*d/q)^((r : β)β»ΒΉ) | |
| have hK := replacementK_one_le hr | |
| have hdβ : (1 : β) β€ d := by exact_mod_cast hd | |
| have hz : (1 : β) β€ 2*replacementK (r+1)*d/q := by | |
| apply (le_div_iffβ hq).2 | |
| nlinarith | |
| have hx : 1 β€ x := Real.one_le_rpow hz (by positivity) | |
| have hg : 1 β€ βxββ := Nat.one_le_ceil_iff.mpr (by linarith) | |
| have hgβ : (0 : β) < βxββ := by exact_mod_cast (by omega : 0 < βxββ) | |
| refine β¨βxββ, hg, ?_, ?_β© | |
| Β· have hp : 2*replacementK (r+1)*d/q β€ (βxββ : β)^r := by | |
| calc | |
| _ = x^r := (Real.rpow_inv_natCast_pow (by positivity) (by omega : r β 0)).symm | |
| _ β€ _ := pow_le_pow_leftβ (by linarith : 0 β€ x) (Nat.le_ceil x) r | |
| apply (div_le_iffβ (pow_pos hgβ r)).2 | |
| have hh := (div_le_iffβ hq).mp hp | |
| nlinarith | |
| Β· exact (Nat.ceil_lt_add_one (by linarith : 0 β€ x)).le.trans (by linarith) | |
| lemma lifetime_product {u r d : β} (hr : 2 β€ r) (hru : r+1 β€ u) (hd : 1 β€ d) | |
| (S : Finset (Assignment u)) : | |
| lifetime u (r+1) S * (blockKill u r S d)^(lifetimeBeta (r+1)) β€ | |
| lifetimeC (r+1) * (d : β)^(lifetimeBeta (r+1)) := by | |
| let q := blockKill u r S d | |
| have hqβ : 0 β€ q := blockKill_nonneg _ _ _ _ | |
| have hqβ : q β€ 1 := blockKill_le_one (by omega) _ _ | |
| have hΞ² : 0 < lifetimeBeta (r+1) := by | |
| rw [lifetimeBeta_succ (by omega)] | |
| positivity | |
| have hK := replacementK_one_le (by omega : 1 β€ r) | |
| have hC := lifetimeC_pos (by omega : 1 β€ r) | |
| have hdβ : (0 : β) < d := by exact_mod_cast hd | |
| by_cases hq : q = 0 | |
| Β· change lifetime u (r+1) S * q^_ β€ _ | |
| rw [hq, Real.zero_rpow (ne_of_gt hΞ²), mul_zero] | |
| exact mul_nonneg hC.le (Real.rpow_nonneg hdβ.le _) | |
| Β· have hq : 0 < q := lt_of_le_of_ne hqβ (Ne.symm hq) | |
| obtain β¨g, hg, herr, hgubβ© := replacement_block_choice (by omega : 1 β€ r) hd hq hqβ | |
| have hR : q/2 β€ blockKill u (r+1) S (d*g) := by | |
| have hh := sequential_replacement hr hru hg S d | |
| change q - _ β€ _ at hh | |
| linarith | |
| have hRβ : 0 < blockKill u (r+1) S (d*g) := lt_of_lt_of_le (by linarith) hR | |
| have hΟ : lifetime u (r+1) S β€ 4 * (2*replacementK (r+1))^((r : β)β»ΒΉ) * | |
| ((d : β)/q)^(1+(r : β)β»ΒΉ) := by | |
| calc | |
| _ β€ (d*g : β)/blockKill u (r+1) S (d*g) := lifetime_block hru S (d*g) hRβ | |
| _ β€ (d*g : β)/(q/2) := div_le_div_of_nonneg_left (by positivity) (by linarith) hR | |
| _ β€ (d : β)*(2*(2*replacementK (r+1)*d/q)^((r : β)β»ΒΉ))/(q/2) := by | |
| push_cast | |
| exact div_le_div_of_nonneg_right (mul_le_mul_of_nonneg_left hgub hdβ.le) (by positivity) | |
| _ = _ := by | |
| rw [show 2*replacementK (r+1)*(d : β)/q = | |
| (2*replacementK (r+1))*((d : β)/q) by ring, | |
| Real.mul_rpow (by linarith) (by positivity), Real.rpow_add (by positivity), | |
| Real.rpow_one] | |
| ring | |
| have hCeq : lifetimeC (r+1) = 4 * (2*replacementK (r+1))^((r : β)β»ΒΉ) := by | |
| simp [lifetimeC] | |
| rw [β lifetimeBeta_succ (by omega), β hCeq] at hΟ | |
| rw [Real.div_rpow hdβ.le hq.le] at hΟ | |
| change lifetime u (r+1) S * q^_ β€ _ | |
| apply (le_div_iffβ (Real.rpow_pos_of_pos hq _)).mp | |
| simpa only [mul_div_assoc] using hΟ | |
| lemma lifetime_level {u r d : β} (hr : 2 β€ r) (hru : r+1 β€ u) (hd : 1 β€ d) | |
| (S : Finset (Assignment u)) {a : β} (ha : 0 < a) (haq : a β€ blockKill u r S d) : | |
| lifetime u (r+1) S β€ lifetimeC (r+1) * (d : β)^(lifetimeBeta (r+1)) * | |
| a^(-lifetimeBeta (r+1)) := by | |
| have hΞ² : 0 β€ lifetimeBeta (r+1) := by | |
| rw [lifetimeBeta_succ (by omega)] | |
| positivity | |
| have hh := lifetime_product hr hru hd S | |
| have hh' := mul_le_mul_of_nonneg_left (Real.rpow_le_rpow ha.le haq hΞ²) | |
| (lifetime_nonneg u (r+1) S) | |
| rw [Real.rpow_neg ha.le, β div_eq_mul_inv] | |
| apply (le_div_iffβ (Real.rpow_pos_of_pos ha _)).2 | |
| exact hh'.trans hh | |
| end RandomKSAT | |
| end | |
| end OAI | |