openAI-math-dataset / lean /OAI /Combinatorics /EditApproximation /Refinement /ComputedActualBandWork.lean
| import OAI.Combinatorics.EditApproximation.Geometry.ActualBandBitEnvelope | |
| import OAI.Combinatorics.EditApproximation.Refinement.ComputedOptimizerBitWork | |
| import OAI.Combinatorics.EditApproximation.Refinement.ComputedCacheWords | |
| namespace OAI | |
| /-! The same grid and dependency exponents control the full Boolean call, | |
| including exact envelope construction, vertices and the optimistic-history input. -/ | |
| namespace EditApproximation | |
| open Filter | |
| open scoped Topology | |
| theorem computed_dyadicScale_bits (N b : ℕ) (hN : 0 < N) (hb : b ∈ dyadicScales N) : | |
| Nat.size b ≤ inputHeight N := by | |
| obtain ⟨k, hk, rfl⟩ := List.mem_map.mp hb | |
| have hk' : k ≤ Nat.log 2 N := by | |
| have := List.mem_range.mp hk | |
| omega | |
| have hvalue := (Nat.pow_le_pow_right (by decide : 0 < (2 : ℕ)) hk').trans | |
| (Nat.pow_log_le_self 2 hN.ne') | |
| exact (Nat.size_le_size hvalue).trans (computed_input_size_le_height N) | |
| def localActualBandBitExponent (M p C : ℕ) : ℕ := | |
| ((44 * M + C + 4000) * (p + 1)) * actualBandOptimizerBitDegree | |
| theorem actualBandOptimizerBitBudget_grid_cap (H M P p C d b v G K t Be Bk Bi Bt E : ℕ) | |
| (hH : 64 ≤ H) (hM : M ≤ H) (hP : 1 ≤ P) (hPcap : P ≤ H ^ (p + 20)) | |
| (hd : d ≤ M * (40 * P + 2) ^ 2) (hv : v ≤ (40 * P + 2) ^ (2 * M)) | |
| (hG : G ≤ H + M * (40 * P + 2) ^ 2 + 4) (hK : K ≤ G ^ 80) (ht : t ≤ H) (hb : Nat.size b ≤ H) | |
| (hBe : Be ≤ H ^ (C * (p + 1))) (hBk : Bk ≤ H ^ (C * (p + 1))) | |
| (hBi : Bi ≤ H ^ (C * (p + 1))) (hBt : Bt ≤ H ^ (C * (p + 1))) | |
| (hE : E ≤ H ^ (C * (p + 1))) : | |
| BinaryFraction.actualBandOptimizerBitBudget M d b v G K t Be Bk Bi Bt E ≤ | |
| H ^ localActualBandBitExponent M p C := by | |
| let exponent := (44 * M + C + 4000) * (p + 1) | |
| have hHpos : 0 < H := by omega | |
| have hbox : 40 * P + 2 ≤ H ^ (p + 22) := by | |
| have hc : 42 ≤ H ^ 2 := by nlinarith | |
| calc | |
| _ ≤ 42 * P := by omega | |
| _ ≤ H ^ 2 * H ^ (p + 20) := Nat.mul_le_mul hc hPcap | |
| _ = H ^ (2 + (p + 20)) := (pow_add H _ _).symm | |
| _ = _ := by congr 1; omega | |
| have hv' : v ≤ H ^ exponent := by | |
| calc | |
| _ ≤ (H ^ (p + 22)) ^ (2 * M) := hv.trans (Nat.pow_le_pow_left hbox _) | |
| _ = H ^ ((p + 22) * (2 * M)) := (pow_mul H _ _).symm | |
| _ ≤ _ := Nat.pow_le_pow_right hHpos (by dsimp only [exponent]; nlinarith) | |
| have hd' : d ≤ H ^ exponent := | |
| (hd.trans (wide_coordinate_budget_le H M P p hH hM hP hPcap)).trans | |
| (Nat.pow_le_pow_right hHpos (by dsimp only [exponent]; nlinarith)) | |
| have hG0 := hG.trans (optimizer_parameter_budget_le H M P p hH hM hP hPcap) | |
| have hG' : G ≤ H ^ exponent := hG0.trans | |
| (Nat.pow_le_pow_right hHpos (by dsimp only [exponent]; nlinarith)) | |
| have hK' : K ≤ H ^ exponent := by | |
| calc | |
| _ ≤ (H ^ (2 * p + 46)) ^ 80 := hK.trans (Nat.pow_le_pow_left hG0 _) | |
| _ = H ^ ((2 * p + 46) * 80) := (pow_mul H _ _).symm | |
| _ ≤ _ := Nat.pow_le_pow_right hHpos (by dsimp only [exponent]; nlinarith) | |
| have hC : C * (p + 1) ≤ exponent := by dsimp only [exponent]; nlinarith | |
| have hheight : H ≤ H ^ exponent := Nat.le_pow (by dsimp only [exponent]; nlinarith) | |
| have hS : 64 ≤ H ^ exponent := hH.trans hheight | |
| have h := actualBandOptimizerBitBudget_le_fixed_power M d b v G K t Be Bk Bi Bt E | |
| (H ^ exponent) hS (hM.trans hheight) hd' (hb.trans hheight) hv' hG' hK' (ht.trans hheight) | |
| (hBe.trans (Nat.pow_le_pow_right hHpos hC)) | |
| (hBk.trans (Nat.pow_le_pow_right hHpos hC)) | |
| (hBi.trans (Nat.pow_le_pow_right hHpos hC)) | |
| (hBt.trans (Nat.pow_le_pow_right hHpos hC)) | |
| (hE.trans (Nat.pow_le_pow_right hHpos hC)) | |
| simpa only [← pow_mul, exponent, localActualBandBitExponent] using h | |
| noncomputable def computedActualBandBitExponent (C N : ℕ) : ℝ := | |
| (actualBandOptimizerBitDegree : ℝ) * | |
| ((44 * Real.log 2) * ((integerParameters N).M : ℝ) * | |
| ((coarseExponent (inputSmallLog N) : ℝ) + 1) * inputSmallLog N + | |
| ((C : ℝ) + 4000) * ((coarseExponent (inputSmallLog N) : ℝ) + 1) * | |
| Real.log (inputHeight N : ℝ)) | |
| theorem computedActualBandBitExponent_tendsto (C : ℕ) : | |
| Tendsto (fun N => computedActualBandBitExponent C N / inputHeight N) atTop (𝓝 0) := by | |
| have h := ((local_enumeration_exponent_div_height_tendsto.const_mul (44 * Real.log 2)).add | |
| (encoding_exponent_div_height_tendsto.const_mul ((C : ℝ) + 4000))).const_mul | |
| (actualBandOptimizerBitDegree : ℝ) | |
| simp only [mul_zero, zero_add] at h | |
| convert h using 1 | |
| ext N | |
| unfold computedActualBandBitExponent | |
| ring | |
| def computedActualBandBitBudget (C N : ℕ) : ℕ := | |
| inputHeight N ^ localActualBandBitExponent (integerParameters N).M | |
| (coarseExponent (inputSmallLog N)) C | |
| private theorem actualBandBitBudget_exp_scalar (D C H M p ell : ℕ) (hH : 0 < H) | |
| (hlog : Real.log (H : ℝ) ≤ (ell : ℝ) * Real.log 2) : | |
| ((H ^ (((44 * M + C + 4000) * (p + 1)) * D) : ℕ) : ℝ) ≤ | |
| Real.exp ((D : ℝ) * ((44 * Real.log 2) * (M : ℝ) * ((p : ℝ) + 1) * ell + | |
| ((C : ℝ) + 4000) * ((p : ℝ) + 1) * Real.log (H : ℝ))) := by | |
| rw [Nat.cast_pow, nat_pow_eq_exp_log H _ hH] | |
| apply Real.exp_le_exp.mpr | |
| have hM : (0 : ℝ) ≤ (M : ℝ) := Nat.cast_nonneg _ | |
| have hp : (0 : ℝ) ≤ (p : ℝ) + 1 := by have h := Nat.cast_nonneg (α := ℝ) p; linarith | |
| have hmul := mul_le_mul_of_nonneg_left hlog | |
| (mul_nonneg (mul_nonneg (by norm_num : (0 : ℝ) ≤ 44) hM) hp) | |
| have hD : (0 : ℝ) ≤ (D : ℝ) := Nat.cast_nonneg _ | |
| push_cast | |
| nlinarith only [mul_nonneg hD (sub_nonneg.mpr hmul)] | |
| theorem computedActualBandBitBudget_exp_bound (C N : ℕ) (hN : 0 < N) : | |
| (computedActualBandBitBudget C N : ℝ) ≤ Real.exp (computedActualBandBitExponent C N) := by | |
| have hH : 0 < inputHeight N := by | |
| dsimp only [inputHeight] | |
| exact Nat.pow_pos (by decide : 0 < (2 : ℕ)) | |
| have hlog : Real.log (inputHeight N : ℝ) ≤ (inputSmallLog N : ℝ) * Real.log 2 := by | |
| rw [inputHeight_real_log] | |
| exact mul_le_mul_of_nonneg_right (by exact_mod_cast (inputSmallLog_bounds N hN).1) | |
| (Real.log_nonneg (by norm_num)) | |
| exact actualBandBitBudget_exp_scalar actualBandOptimizerBitDegree C (inputHeight N) | |
| (integerParameters N).M (coarseExponent (inputSmallLog N)) (inputSmallLog N) hH hlog | |
| theorem computedActualBandBitBudget_subpolynomial (C : ℕ) (epsilon : ℝ) (hepsilon : 0 < epsilon) : | |
| ∀ᶠ N in atTop, (computedActualBandBitBudget C N : ℝ) ≤ (N + 2 : ℝ) ^ epsilon := by | |
| filter_upwards [subexponential_height_to_input (computedActualBandBitExponent C) | |
| (computedActualBandBitExponent_tendsto C) epsilon hepsilon, eventually_ge_atTop 1] with N he hN | |
| exact (computedActualBandBitBudget_exp_bound C N (by omega)).trans he | |
| theorem computedActualBandBitBudget_widthWork_near_linear (C : ℕ) (epsilon : ℝ) (hepsilon : 0 < epsilon) : | |
| ∀ᶠ N in atTop, ∀ n ≤ N, ∀ tree : DependencyExpansion, | |
| tree.Valid ((integerParameters N).M * inputSmallLog N ^ 257) | |
| (inputHeight N ^ (512 * (coarseExponent (inputSmallLog N) + 1))) → | |
| tree.depth = intervalTreeDepth (integerParameters N).M n → | |
| tree.rank ≤ computedDependencyIndexCount N → | |
| (tree.widthWork (integerParameters N).M n : ℝ) * computedActualBandBitBudget C N ≤ | |
| (N + 2 : ℝ) ^ (1 + epsilon) := by | |
| filter_upwards [computed_widthWork_subexponential (computedActualBandBitExponent C) | |
| (computedActualBandBitExponent_tendsto C) epsilon hepsilon, eventually_ge_atTop 1] with N he hN | |
| intro n hn tree hv hd hk | |
| exact (mul_le_mul_of_nonneg_left (computedActualBandBitBudget_exp_bound C N (by omega)) | |
| (Nat.cast_nonneg _)).trans (he n hn tree hv hd hk) | |
| end EditApproximation | |
| end OAI | |