| 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 |
|
|
