Download data/lean/OAI/Combinatorics/BinaryEdit/FiniteParameters.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 10.3 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/BinaryEdit/FiniteParameters.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Combinatorics/BinaryEdit/FiniteParameters.lean
-
curl -L -o FiniteParameters.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/BinaryEdit/FiniteParameters.lean
10.3 kB
| import Mathlib | |
| namespace OAI | |
| namespace TreeEdit.BinaryLower.Parameters | |
| /-- Binary word length for the quadratic-width code, with source length `(20 * k * k^(20*k))^k`. -/ | |
| def finiteLength (k : β) : β := (20 * k * k ^ (20 * k)) ^ (3 * k) | |
| lemma finiteLength_pos {k : β} (hk : 0 < k) : 0 < finiteLength k := by | |
| unfold finiteLength | |
| positivity | |
| lemma log_finiteLength {k : β} (hk : 0 < k) : | |
| Real.log (finiteLength k : β) = | |
| 60 * (k : β) ^ 2 * Real.log k + 3 * k * Real.log (20 * k) := by | |
| have hkR : (k : β) β 0 := by exact_mod_cast (Nat.ne_of_gt hk) | |
| unfold finiteLength | |
| push_cast | |
| rw [Real.log_pow, Real.log_mul (by positivity : (20 : β) * k β 0) | |
| (pow_ne_zero _ hkR), Real.log_pow] | |
| push_cast | |
| ring | |
| lemma finiteLength_log_succ_le {k : β} (hk : 20 β€ k) : | |
| Real.log (finiteLength (k + 1) : β) β€ | |
| 300 * (k : β) ^ 2 * Real.log k := by | |
| have hkR : (20 : β) β€ k := by exact_mod_cast hk | |
| have hkpos : (0 : β) < k := by linarith | |
| have hlog : 0 β€ Real.log (k : β) := Real.log_nonneg (by linarith) | |
| have hx : (0 : β) < (k : β) + 1 := by linarith | |
| have hxk : (k : β) + 1 β€ (k : β) ^ 2 := by nlinarith | |
| have hlogx : Real.log ((k : β) + 1) β€ 2 * Real.log k := by | |
| calc | |
| Real.log ((k : β) + 1) β€ Real.log ((k : β) ^ 2) := | |
| Real.log_le_log hx hxk | |
| _ = 2 * Real.log k := by rw [Real.log_pow]; norm_num | |
| have hk2 : (400 : β) β€ (k : β) ^ 2 := by nlinarith | |
| have hprod : 20 * ((k : β) + 1) β€ (k : β) ^ 3 := by | |
| have := mul_le_mul_of_nonneg_right hk2 (le_of_lt hkpos) | |
| nlinarith | |
| have hlogprod : Real.log (20 * ((k : β) + 1)) β€ 3 * Real.log k := by | |
| calc | |
| Real.log (20 * ((k : β) + 1)) β€ Real.log ((k : β) ^ 3) := | |
| Real.log_le_log (by positivity) hprod | |
| _ = 3 * Real.log k := by rw [Real.log_pow]; norm_num | |
| have hsq : ((k : β) + 1) ^ 2 β€ (3 / 2 : β) * (k : β) ^ 2 := by | |
| nlinarith | |
| have hterm1 : 60 * ((k : β) + 1) ^ 2 * Real.log ((k : β) + 1) β€ | |
| 180 * (k : β) ^ 2 * Real.log k := by | |
| calc | |
| _ β€ 60 * ((k : β) + 1) ^ 2 * (2 * Real.log k) := | |
| mul_le_mul_of_nonneg_left hlogx (by positivity) | |
| _ β€ 60 * ((3 / 2 : β) * (k : β) ^ 2) * (2 * Real.log k) := by | |
| exact mul_le_mul_of_nonneg_right | |
| (mul_le_mul_of_nonneg_left hsq (by norm_num)) (by positivity) | |
| _ = _ := by ring | |
| have hterm2 : 3 * ((k : β) + 1) * Real.log (20 * ((k : β) + 1)) β€ | |
| 18 * (k : β) ^ 2 * Real.log k := by | |
| calc | |
| _ β€ 3 * ((k : β) + 1) * (3 * Real.log k) := | |
| mul_le_mul_of_nonneg_left hlogprod (by positivity) | |
| _ β€ 18 * (k : β) ^ 2 * Real.log k := by | |
| have := mul_le_mul_of_nonneg_right hxk hlog | |
| nlinarith | |
| rw [log_finiteLength (by omega : 0 < k + 1)] | |
| push_cast | |
| nlinarith [mul_nonneg (sq_nonneg (k : β)) hlog] | |
| lemma le_finiteLength {k : β} (hk : 0 < k) : k β€ finiteLength k := by | |
| have hp : 1 β€ k ^ (20 * k) := Nat.one_le_pow _ _ hk | |
| have hb : k β€ 20 * k * k ^ (20 * k) := by | |
| have := Nat.mul_le_mul_left (20 * k) hp | |
| nlinarith | |
| exact hb.trans (Nat.le_pow (by omega : 0 < 3 * k)) | |
| lemma finiteLength_log_succ_pos {k : β} (hk : 20 β€ k) : | |
| 0 < Real.log (finiteLength (k + 1) : β) := by | |
| apply Real.log_pos | |
| have := le_finiteLength (by omega : 0 < k + 1) | |
| exact_mod_cast (show 1 < finiteLength (k + 1) by omega) | |
| lemma finiteLength_loglog_succ_le {k : β} (hk : 20 β€ k) : | |
| Real.log (Real.log (finiteLength (k + 1) : β)) β€ | |
| 5 * Real.log k := by | |
| have hkR : (20 : β) β€ k := by exact_mod_cast hk | |
| have hk0 : (0 : β) β€ k := by positivity | |
| have hk2 : (300 : β) β€ (k : β) ^ 2 := by nlinarith | |
| have hlog : Real.log (k : β) β€ k := Real.log_le_self hk0 | |
| have hbound : Real.log (finiteLength (k + 1) : β) β€ (k : β) ^ 5 := by | |
| calc | |
| _ β€ 300 * (k : β) ^ 2 * Real.log k := finiteLength_log_succ_le hk | |
| _ β€ 300 * (k : β) ^ 3 := by | |
| have := mul_le_mul_of_nonneg_left hlog (show 0 β€ 300 * (k : β) ^ 2 by positivity) | |
| nlinarith | |
| _ β€ (k : β) ^ 5 := by | |
| have := mul_le_mul_of_nonneg_right hk2 (pow_nonneg hk0 3) | |
| nlinarith | |
| calc | |
| _ β€ Real.log ((k : β) ^ 5) := | |
| Real.log_le_log (finiteLength_log_succ_pos hk) hbound | |
| _ = 5 * Real.log k := by rw [Real.log_pow]; norm_num | |
| lemma finite_lower_log_bound {cβ : β} (hcβ : 0 < cβ) {k : β} | |
| (hk : 20 β€ k) (hkc : -4 * Real.log cβ β€ (k : β)) : | |
| (1 / 4 : β) * k * Real.log k β€ | |
| Real.log (cβ * ((k : β) / 4) ^ k) := by | |
| have hkR : (20 : β) β€ k := by exact_mod_cast hk | |
| have hkpos : (0 : β) < k := by linarith | |
| have hlog1 : 1 β€ Real.log (k : β) := by | |
| apply (Real.le_log_iff_exp_le hkpos).2 | |
| exact Real.exp_one_lt_three.le.trans (by linarith) | |
| have hlog4 : 2 * Real.log 4 β€ Real.log (k : β) := by | |
| calc | |
| 2 * Real.log 4 = Real.log ((4 : β) ^ 2) := by rw [Real.log_pow]; norm_num | |
| _ β€ Real.log (k : β) := Real.log_le_log (by positivity) (by norm_num; linarith) | |
| rw [Real.log_mul hcβ.ne' (by positivity), Real.log_pow, | |
| Real.log_div hkpos.ne' (by norm_num : (4 : β) β 0)] | |
| have hmul1 := mul_le_mul_of_nonneg_left hlog1 (le_of_lt hkpos) | |
| have hmul4 := mul_le_mul_of_nonneg_left hlog4 (le_of_lt hkpos) | |
| nlinarith | |
| lemma eventually_finite_lower_log_bound {cβ : β} (hcβ : 0 < cβ) : | |
| β kβ : β, β k β₯ kβ, | |
| (1 / 4 : β) * k * Real.log k β€ | |
| Real.log (cβ * ((k : β) / 4) ^ k) := by | |
| obtain β¨n, hnβ© := exists_nat_ge (-4 * Real.log cβ) | |
| refine β¨max 20 n, ?_β© | |
| intro k hk | |
| apply finite_lower_log_bound hcβ (le_trans (le_max_left _ _) hk) | |
| exact hn.trans (by exact_mod_cast (le_trans (le_max_right 20 n) hk)) | |
| /-- The logarithmic scale at any cap below the next construction length. -/ | |
| lemma finite_cap_sqrt_bound {k d : β} (hk : 20 β€ k) (hd : 2 β€ d) | |
| (hcap : d β€ finiteLength (k + 1)) : | |
| Real.sqrt (Real.log (d : β) * Real.log (Real.log (d : β))) β€ | |
| 40 * k * Real.log k := by | |
| have hkR : (20 : β) β€ k := by exact_mod_cast hk | |
| have hk0 : (0 : β) β€ k := by positivity | |
| have hlogk : 0 β€ Real.log (k : β) := Real.log_nonneg (by linarith only [hkR]) | |
| have hdR : (1 : β) < d := by exact_mod_cast (show 1 < d by omega) | |
| have hdlog : 0 < Real.log (d : β) := Real.log_pos hdR | |
| have hlogcap : Real.log (d : β) β€ Real.log (finiteLength (k + 1) : β) := | |
| Real.log_le_log (lt_trans zero_lt_one hdR) (Nat.cast_le.mpr hcap) | |
| have hlogbound : Real.log (d : β) β€ 300 * (k : β) ^ 2 * Real.log k := | |
| hlogcap.trans (finiteLength_log_succ_le hk) | |
| have hloglogbound : Real.log (Real.log (d : β)) β€ 5 * Real.log k := | |
| (Real.log_le_log hdlog hlogcap).trans (finiteLength_loglog_succ_le hk) | |
| apply Real.sqrt_le_iff.mpr | |
| refine β¨mul_nonneg (mul_nonneg (by norm_num) hk0) hlogk, ?_β© | |
| have h1 := mul_le_mul_of_nonneg_left hloglogbound hdlog.le | |
| have h2 := mul_le_mul_of_nonneg_right hlogbound | |
| (mul_nonneg (by norm_num : (0 : β) β€ 5) hlogk) | |
| have h3 : 0 β€ (k : β) ^ 2 * Real.log k ^ 2 := | |
| mul_nonneg (sq_nonneg _) (sq_nonneg _) | |
| nlinarith only [h1, h2, h3] | |
| /-- Numerical transfer from a finite-family distortion to an intervening cap. -/ | |
| lemma finite_cap_exponential_bound {cβ : β} (hcβ : 0 < cβ) {k d : β} | |
| (hk : 20 β€ k) (hkc : -4 * Real.log cβ β€ (k : β)) | |
| (hd : 2 β€ d) (hcap : d β€ finiteLength (k + 1)) : | |
| Real.exp ((1 / 160 : β) * | |
| Real.sqrt (Real.log (d : β) * Real.log (Real.log (d : β)))) β€ | |
| cβ * ((k : β) / 4) ^ k := by | |
| have hsqrt := finite_cap_sqrt_bound hk hd hcap | |
| have hlower := finite_lower_log_bound hcβ hk hkc | |
| have hexponent : (1 / 160 : β) * | |
| Real.sqrt (Real.log (d : β) * Real.log (Real.log (d : β))) β€ | |
| Real.log (cβ * ((k : β) / 4) ^ k) := by nlinarith only [hsqrt, hlower] | |
| have hkpos : (0 : β) < k := by exact_mod_cast (show 0 < k by omega) | |
| calc | |
| _ β€ Real.exp (Real.log (cβ * ((k : β) / 4) ^ k)) := | |
| Real.exp_le_exp.mpr hexponent | |
| _ = _ := Real.exp_log (by positivity) | |
| /-- Choose adjacent construction lengths bracketing a cap. No strict | |
| monotonicity of the length sequence is needed for this selection argument. -/ | |
| lemma exists_finiteLength_bracket {kβ d : β} (hkβ : 0 < kβ) | |
| (hd : finiteLength kβ β€ d) : | |
| β k : β, kβ β€ k β§ finiteLength k β€ d β§ d < finiteLength (k + 1) := by | |
| have hex : β n : β, d < finiteLength (kβ + n + 1) := by | |
| refine β¨d, ?_β© | |
| have hb := le_finiteLength (by omega : 0 < kβ + d + 1) | |
| omega | |
| let n : β := Nat.find hex | |
| refine β¨kβ + n, by omega, ?_, ?_β© | |
| Β· by_cases hn : n = 0 | |
| Β· simpa only [hn, Nat.add_zero] using hd | |
| Β· have hmin := Nat.find_min hex (m := n - 1) (by dsimp [n] at hn β’; omega) | |
| have heq : kβ + (n - 1) + 1 = kβ + n := by omega | |
| rw [heq] at hmin | |
| exact Nat.le_of_not_gt hmin | |
| Β· exact Nat.find_spec hex | |
| /-- The complete numerical all-large-cap selection used after constructing the | |
| finite-tree witness family. The requested lower threshold `K` is arbitrary. -/ | |
| lemma exists_finite_cap_parameters {cβ : β} (hcβ : 0 < cβ) (K : β) : | |
| β dβ : β, β d β₯ dβ, β k : β, | |
| K β€ k β§ 20 β€ k β§ finiteLength k β€ d β§ | |
| Real.exp ((1 / 160 : β) * | |
| Real.sqrt (Real.log (d : β) * Real.log (Real.log (d : β)))) β€ | |
| cβ * ((k : β) / 4) ^ k := by | |
| obtain β¨n, hnβ© := exists_nat_ge (-4 * Real.log cβ) | |
| let kβ : β := max 20 (max K n) | |
| have hk20 : 20 β€ kβ := le_max_left _ _ | |
| have hkK : K β€ kβ := (le_max_left K n).trans (le_max_right 20 (max K n)) | |
| have hkn : n β€ kβ := (le_max_right K n).trans (le_max_right 20 (max K n)) | |
| refine β¨finiteLength kβ, ?_β© | |
| intro d hd | |
| obtain β¨k, hkβ, hkd, hdkβ© := exists_finiteLength_bracket (by omega : 0 < kβ) hd | |
| have hk : 20 β€ k := hk20.trans hkβ | |
| have hkc : -4 * Real.log cβ β€ (k : β) := | |
| hn.trans (Nat.cast_le.mpr (hkn.trans hkβ)) | |
| have hd2 : 2 β€ d := by | |
| have := le_finiteLength (by omega : 0 < k) | |
| omega | |
| exact β¨k, hkK.trans hkβ, hk, hkd, | |
| finite_cap_exponential_bound hcβ hk hkc hd2 hdk.leβ© | |
| end TreeEdit.BinaryLower.Parameters | |
| end OAI | |