| import OAI.Probability.RandomSAT.CenterComparison |
|
|
| namespace OAI |
|
|
| /-! |
| A balanced-block geometric potential proves convergence from boundedness and |
| summable-min comparisons, including block counts that are not powers of two. |
| -/ |
|
|
| namespace FixedClauseThreshold |
|
|
| open Finset |
|
|
| noncomputable section |
|
|
| attribute [local instance] Classical.propDecidable |
|
|
| def balanceConstant (β : ℝ) : ℝ := (3 : ℝ)^β / ((3 / 2 : ℝ)^β - 1) |
|
|
| theorem balanceConstant_pos {β : ℝ} (hβ : 0 < β) : 0 < balanceConstant β := |
| div_pos (Real.rpow_pos_of_pos (by norm_num) _) (sub_pos.mpr (Real.one_lt_rpow (by norm_num) hβ)) |
|
|
| theorem balanced_power_potential {β a b q : ℝ} (hβ : 0 < β) (hb : 0 < b) |
| (hq : 0 < q) (haq : q / 3 ≤ a) (hbq : b ≤ q / (3 / 2)) : |
| a^(-β) ≤ balanceConstant β * (b^(-β) - q^(-β)) := by |
| have hA := Real.rpow_le_rpow_of_nonpos (div_pos hq (by norm_num)) haq (neg_nonpos.mpr hβ.le) |
| rw [Real.div_rpow hq.le (by norm_num : (0 : ℝ) ≤ 3), Real.rpow_neg (by norm_num : (0 : ℝ) ≤ 3), |
| div_inv_eq_mul] at hA |
| have hB := Real.rpow_le_rpow_of_nonpos hb hbq (neg_nonpos.mpr hβ.le) |
| rw [Real.div_rpow hq.le (by norm_num : (0 : ℝ) ≤ 3 / 2), |
| Real.rpow_neg (by norm_num : (0 : ℝ) ≤ 3 / 2), div_inv_eq_mul] at hB |
| have hd : (3 / 2 : ℝ)^β - 1 ≠ 0 := ne_of_gt (sub_pos.mpr (Real.one_lt_rpow (by norm_num) hβ)) |
| have hf : balanceConstant β * ((3 / 2 : ℝ)^β - 1) = (3 : ℝ)^β := by |
| exact div_mul_cancel₀ _ hd |
| calc |
| a^(-β) ≤ q^(-β) * (3 : ℝ)^β := hA |
| _ = balanceConstant β * (q^(-β) * ((3 / 2 : ℝ)^β - 1)) := by rw [← hf]; ring |
| _ ≤ balanceConstant β * (b^(-β) - q^(-β)) := |
| mul_le_mul_of_nonneg_left (by nlinarith [hB]) (balanceConstant_pos hβ).le |
|
|
| theorem balanced_blocks_bound (u : ℕ → ℝ) {A β : ℝ} (hA : 0 ≤ A) (hβ : 0 < β) |
| {N s : ℕ} (hsN : N ≤ s) (hs : 0 < s) |
| (hadd : ∀ r ≥ N, ∀ t ≥ N, |
| min (u r) (u t) - A * (min r t : ℝ)^(-β) ≤ u (r + t)) |
| (hnext : u s - A * (s : ℝ)^(-β) ≤ u (s + 1)) : |
| ∀ q : ℕ, 1 ≤ q → ∀ r : ℕ, r ≤ q → |
| u s - A * (s : ℝ)^(-β) - |
| A * balanceConstant β * (s : ℝ)^(-β) * (1 - (q : ℝ)^(-β)) ≤ u (q * s + r) := by |
| intro q |
| induction q using Nat.strong_induction_on with |
| | h q ih => |
| intro hq r hr |
| have hs' : (0 : ℝ) < s := by exact_mod_cast hs |
| have hpow : 0 ≤ (s : ℝ)^(-β) := (Real.rpow_pos_of_pos hs' _).le |
| have hcoef : 0 ≤ A * balanceConstant β * (s : ℝ)^(-β) := |
| mul_nonneg (mul_nonneg hA (balanceConstant_pos hβ).le) hpow |
| by_cases hq1 : q = 1 |
| · subst q |
| have hr' : r = 0 ∨ r = 1 := by omega |
| rcases hr' with hr0 | hr1 |
| · subst r |
| simp only [Nat.cast_one, Real.one_rpow, sub_self, mul_zero, sub_zero, one_mul, add_zero] |
| exact sub_le_self _ (mul_nonneg hA hpow) |
| · subst r |
| simpa only [Nat.cast_one, Real.one_rpow, sub_self, mul_zero, sub_zero, one_mul] using hnext |
| · have hq2 : 2 ≤ q := by omega |
| let a := q / 2 |
| let b := q - a |
| let r₁ := min r a |
| let r₂ := r - r₁ |
| have ha : 1 ≤ a := by dsimp [a]; omega |
| have hb : 1 ≤ b := by dsimp [b, a]; omega |
| have haq : a < q := by dsimp [a]; omega |
| have hbq : b < q := by dsimp [b, a]; omega |
| have hab : a ≤ b := by dsimp [a, b]; omega |
| have habq : a + b = q := by dsimp [b, a]; omega |
| have hqa : q ≤ 3 * a := by dsimp [a]; omega |
| have hbq' : 3 * b ≤ 2 * q := by dsimp [b, a]; omega |
| have hr₁ : r₁ ≤ a := min_le_right r a |
| have hr₂ : r₂ ≤ b := by dsimp [r₂, r₁, b]; omega |
| have hrr : r₁ + r₂ = r := by dsimp [r₂, r₁]; omega |
| have hiA := ih a haq ha r₁ hr₁ |
| have hiB := ih b hbq hb r₂ hr₂ |
| have ha' : (0 : ℝ) < a := by exact_mod_cast ha |
| have hb' : (0 : ℝ) < b := by exact_mod_cast hb |
| have hq' : (0 : ℝ) < q := by exact_mod_cast hq |
| have habpow : (b : ℝ)^(-β) ≤ (a : ℝ)^(-β) := |
| Real.rpow_le_rpow_of_nonpos ha' (by exact_mod_cast hab) (neg_nonpos.mpr hβ.le) |
| have hchild : u s - A * (s : ℝ)^(-β) - |
| A * balanceConstant β * (s : ℝ)^(-β) * (1 - (b : ℝ)^(-β)) ≤ |
| min (u (a * s + r₁)) (u (b * s + r₂)) := by |
| apply le_min |
| · have hh := mul_le_mul_of_nonneg_left habpow hcoef |
| nlinarith |
| · exact hiB |
| have hsizeA : N ≤ a * s + r₁ := by nlinarith |
| have hsizeB : N ≤ b * s + r₂ := by nlinarith |
| have hsize : a * s ≤ min (a * s + r₁) (b * s + r₂) := by |
| apply le_min <;> nlinarith |
| have hminpos : (0 : ℝ) < (a : ℝ) * s := mul_pos ha' hs' |
| have hminpow := Real.rpow_le_rpow_of_nonpos hminpos |
| (show (a : ℝ) * s ≤ (min (a * s + r₁) (b * s + r₂) : ℝ) by exact_mod_cast hsize) |
| (neg_nonpos.mpr hβ.le) |
| rw [Real.mul_rpow ha'.le hs'.le] at hminpow |
| have herr := mul_le_mul_of_nonneg_left hminpow hA |
| have hpotential := balanced_power_potential hβ hb' hq' |
| (show (q : ℝ) / 3 ≤ a by |
| have hh : (q : ℝ) ≤ 3 * a := by exact_mod_cast hqa |
| linarith) |
| (show (b : ℝ) ≤ q / (3 / 2) by |
| have hh : 3 * (b : ℝ) ≤ 2 * q := by exact_mod_cast hbq' |
| linarith) |
| have hpot := mul_le_mul_of_nonneg_left hpotential (mul_nonneg hA hpow) |
| have hc := hadd (a * s + r₁) hsizeA (b * s + r₂) hsizeB |
| have he : a * s + r₁ + (b * s + r₂) = q * s + r := by |
| calc |
| _ = (a + b) * s + (r₁ + r₂) := by ring |
| _ = _ := by rw [habq, hrr] |
| rw [he] at hc |
| simp only [Nat.cast_add, Nat.cast_mul] at hc |
| nlinarith |
|
|
| theorem balanced_tail_bound (u : ℕ → ℝ) {A β : ℝ} (hA : 0 ≤ A) (hβ : 0 < β) |
| {N s : ℕ} (hsN : N ≤ s) (hs : 0 < s) |
| (hadd : ∀ r ≥ N, ∀ t ≥ N, |
| min (u r) (u t) - A * (min r t : ℝ)^(-β) ≤ u (r + t)) |
| (hnext : u s - A * (s : ℝ)^(-β) ≤ u (s + 1)) : |
| ∀ n ≥ s * s, |
| u s - A * (1 + balanceConstant β) * (s : ℝ)^(-β) ≤ u n := by |
| intro n hn |
| have hq : s ≤ n / s := (Nat.le_div_iff_mul_le hs).mpr hn |
| have hr : n % s ≤ n / s := (Nat.mod_lt n hs).le.trans hq |
| have hb := balanced_blocks_bound u hA hβ hsN hs hadd hnext (n / s) (by omega) (n % s) hr |
| rw [Nat.mul_comm (n / s) s, Nat.div_add_mod] at hb |
| have hcoef : 0 ≤ A * balanceConstant β * (s : ℝ)^(-β) * ((n / s : ℕ) : ℝ)^(-β) := by |
| have hB := (balanceConstant_pos hβ).le |
| exact mul_nonneg (mul_nonneg (mul_nonneg hA hB) (Real.rpow_nonneg (Nat.cast_nonneg _) _)) |
| (Real.rpow_nonneg (Nat.cast_nonneg _) _) |
| nlinarith |
|
|
| theorem summable_min_convergence (u : ℕ → ℝ) {A β : ℝ} (hA : 0 ≤ A) (hβ : 0 < β) |
| (hUpper : Filter.IsBoundedUnder (· ≤ ·) Filter.atTop u) |
| (hLower : Filter.IsBoundedUnder (· ≥ ·) Filter.atTop u) |
| (hcompare : ∃ N : ℕ, |
| (∀ r ≥ N, ∀ s ≥ N, min (u r) (u s) - A * (min r s : ℝ)^(-β) ≤ u (r + s)) ∧ |
| (∀ s ≥ N, u s - A * (s : ℝ)^(-β) ≤ u (s + 1))) : |
| Filter.Tendsto u Filter.atTop (nhds (Filter.limsup u Filter.atTop)) := by |
| obtain ⟨N, hadd, hnext⟩ := hcompare |
| let α := Filter.limsup u Filter.atTop |
| apply tendsto_order.mpr |
| constructor |
| · intro a ha |
| let ε := (α - a) / 3 |
| have hε : 0 < ε := by dsimp [ε, α]; linarith |
| have ht := (tendsto_rpow_neg_atTop hβ).comp (tendsto_natCast_atTop_atTop (R := ℝ)) |
| have hcost : Filter.Tendsto (fun s : ℕ => A * (1 + balanceConstant β) * (s : ℝ)^(-β)) |
| Filter.atTop (nhds 0) := by |
| simpa only [Function.comp_apply, mul_zero] using ht.const_mul (A * (1 + balanceConstant β)) |
| have hsmall := hcost.eventually_lt_const hε |
| have hhigh : ∃ᶠ s : ℕ in Filter.atTop, α - ε < u s := |
| Filter.frequently_lt_of_lt_limsup hLower.isCoboundedUnder_le (by change α - ε < α; linarith) |
| have hgood : ∀ᶠ s : ℕ in Filter.atTop, |
| N ≤ s ∧ 0 < s ∧ A * (1 + balanceConstant β) * (s : ℝ)^(-β) < ε := by |
| filter_upwards [Filter.eventually_ge_atTop (max N 1), hsmall] with s hs he |
| exact ⟨by omega, by omega, he⟩ |
| obtain ⟨s, hsHigh, hsN, hs, hsSmall⟩ := (hhigh.and_eventually hgood).exists |
| have htail := balanced_tail_bound u hA hβ hsN hs hadd (hnext s hsN) |
| filter_upwards [Filter.eventually_ge_atTop (s * s)] with n hn |
| have hh := htail n hn |
| dsimp [ε] at hsHigh hsSmall |
| linarith |
| · intro a ha |
| exact Filter.eventually_lt_of_limsup_lt ha hUpper |
|
|
| end |
|
|
|
|
| end FixedClauseThreshold |
|
|
| end OAI |
|
|
