openAI-math-dataset / lean /OAI /Combinatorics /EditApproximation /Refinement /ComputedCoarseInitialWork.lean
| import OAI.Combinatorics.EditApproximation.Refinement.ComputedCoarseCandidateWork | |
| import OAI.Combinatorics.EditApproximation.Coarse.CoarseInitialScalar | |
| namespace OAI | |
| namespace EditApproximation | |
| open Filter | |
| namespace BinaryFraction | |
| /-- All actual initial-estimator branches have the same source-width charging | |
| form. In the long-target branch no target scan or root is executed. -/ | |
| theorem computedCoarseInitialWithWork_bound : | |
| ∀ᶠ N : ℕ in atTop, ∀ B d : ℕ, ∀ x y : List ℕ, | |
| B = (integerParameters N).B → d = computedCoarseDepth N (coarseEntryWidth x y) → | |
| coarseEntryWidth x y ≤ N → | |
| (∀ a ∈ x ++ y, Nat.size a ≤ inputHeight N ^ 3) → | |
| ∀ (hB : 0 < B) (hq : 0 < inputHeight N ^ 4) (hL : 0 < 64 * inputHeight N) | |
| (draws : CoarseGuessIndex (coarseEntryWidth x y) → CoarseThresholdDraws B d), | |
| (coarseInitialWithWork (inputHeight N ^ 4) (64 * inputHeight N) N hB hq hL x y draws).2 ≤ | |
| inputHeight N ^ 36 * (coarseInitialArrayWork B d (initialThresholdQ N) (initialLambda N) | |
| x y draws + x.length + 1) := by | |
| filter_upwards [computedCoarseCandidate_bounds, eventually_ge_atTop 1, | |
| inputSmallLog_tendsto.eventually (eventually_ge_atTop 200)] with N hcandidate hN hell | |
| intro B d x y hBdef hddef hsize hsymbols hB hq hL draws | |
| let H := inputHeight N | |
| change (coarseInitialWithWork (H ^ 4) (64 * H) N hB hq hL x y draws).2 ≤ | |
| H ^ 36 * (coarseInitialArrayWork B d (initialThresholdQ N) (initialLambda N) x y draws + x.length + 1) | |
| have hH : 100 ≤ H := (by decide : 100 ≤ 256).trans | |
| (computed_coarse_height_large N (by omega) hell) | |
| have hlength : Nat.size N ≤ H + 1 := | |
| (Nat.size_le_size (Nat.le_add_right N 2)).trans (inputLength_register_word N) | |
| have hxlen : x.length ≤ N := (le_max_left _ _).trans hsize | |
| have hylen : y.length ≤ N := (le_max_right _ _).trans hsize | |
| have hx : Nat.size x.length ≤ H + 1 := (Nat.size_le_size hxlen).trans hlength | |
| have hy : Nat.size y.length ≤ H + 1 := (Nat.size_le_size hylen).trans hlength | |
| have hlongcost : (binaryNaturalCompareWithWork (2 * x.length) y.length).2 ≤ 8 * H + 17 := by | |
| have hc := binaryNaturalCompareWithWork_cost (2 * x.length) y.length | |
| have hp := natural_product_bit_length 2 x.length | |
| rw [show Nat.size 2 = 2 by decide] at hp | |
| omega | |
| have hpow36 : 100 * H ^ 3 ≤ H ^ 36 := by | |
| have hh := Nat.mul_le_mul_right (H ^ 3) hH | |
| have hp := Nat.pow_le_pow_right (by omega : 0 < H) (by decide : 4 ≤ 36) | |
| nlinarith only [hh, hp] | |
| have hH3 : H ≤ H ^ 3 := Nat.le_pow (by decide) | |
| have hmul := Nat.mul_le_mul_left (H ^ 36) | |
| (show 1 ≤ coarseInitialArrayWork B d (initialThresholdQ N) (initialLambda N) x y draws + | |
| x.length + 1 by omega) | |
| by_cases hlong : 2 * x.length < y.length | |
| · have hb := (binaryNaturalCompareWithWork_lt (2 * x.length) y.length).mpr hlong | |
| change (coarseInitialWithWork _ _ _ _ _ _ _ _ _).2 ≤ _ | |
| simp only [coarseInitialWithWork, hb, ite_true] | |
| nlinarith only [hlongcost, hlength, hy, hH, hpow36, hmul, hH3] | |
| have hb : ¬ (binaryNaturalCompareWithWork (2 * x.length) y.length).1 = Ordering.lt := | |
| fun h => hlong ((binaryNaturalCompareWithWork_lt _ _).mp h) | |
| by_cases he : x = y | |
| · have heq := (naturalListEqualWithWork_value x y).mpr he | |
| have hc := naturalListEqualWithWork_cost x y (H ^ 3) hsymbols | |
| have hsource : y.length = x.length := congrArg List.length he.symm | |
| have hf : (2 * x.length + 1) * (8 * H ^ 3 + 4) + (8 * H + 17) + 3 ≤ | |
| H ^ 36 * (x.length + 1) := by | |
| have ha := Nat.mul_le_mul_right (x.length + 1) hpow36 | |
| have h3 : 1 ≤ H ^ 3 := one_le_pow₀ (by omega) | |
| nlinarith only [ha, hH, h3, hH3] | |
| simp only [coarseInitialWithWork, ite_eq_right hb, heq, ite_true] | |
| rw [hsource] at hc | |
| have hz : coarseInitialArrayWork B d (initialThresholdQ N) (initialLambda N) x y draws = 0 := by | |
| simp only [coarseInitialArrayWork, ite_eq_right hlong, ite_eq_left he] | |
| rw [hz, zero_add] | |
| nlinarith only [hc, hf, hlongcost] | |
| have hclog : Nat.clog 2 (coarseEntryWidth x y) ≤ H := | |
| (Nat.clog_le_iff_le_pow (by decide : 1 < (2 : ℕ))).mpr | |
| (hsize.trans ((Nat.le_add_right N 2).trans (inputHeight_covers_length N))) | |
| have hN4 : Nat.size N ≤ H ^ 4 := by | |
| have hp2 : H + 1 ≤ H ^ 2 := by nlinarith | |
| have hp : H + 1 ≤ H ^ 4 := hp2.trans | |
| (Nat.pow_le_pow_right (by omega : 0 < H) (by decide : 2 ≤ 4)) | |
| exact hlength.trans hp | |
| have hw := coarseInitialWithWork_cost (inputHeight N ^ 4) (64 * inputHeight N) N | |
| (H ^ 4) (H ^ 3) hB hq hL x y draws (by | |
| have hp : H ≤ H ^ 4 := Nat.le_pow (by decide) | |
| omega) hN4 | |
| ((Nat.size_le_size hxlen).trans hN4) ((Nat.size_le_size hylen).trans hN4) hsymbols | |
| (fun i => (hcandidate B d x y hBdef hddef hsize hB hq hL i (draws i)).1) | |
| let f := fun i : CoarseGuessIndex (coarseEntryWidth x y) => | |
| (coarseCandidateWithWork (H ^ 4) (64 * H) hB hq hL x y i (draws i)).2 | |
| have hsum : ((List.finRange (Nat.clog 2 (coarseEntryWidth x y) + 1)).map f).sum = | |
| ∑ i, f i := by | |
| rw [← List.ofFn_eq_map, List.sum_ofFn] | |
| have hr : ((List.finRange (Nat.clog 2 (coarseEntryWidth x y) + 1)).map f).sum ≤ | |
| H ^ 32 * (coarseInitialArrayWork B d (initialThresholdQ N) (initialLambda N) x y draws + | |
| (Nat.clog 2 (coarseEntryWidth x y) + 1)) := by | |
| rw [hsum] | |
| calc | |
| _ ≤ ∑ i : CoarseGuessIndex (coarseEntryWidth x y), H ^ 32 * | |
| (coarseActiveArrayWork (coarseGuess (coarseEntryWidth x y) i) | |
| (initialThresholdQ N) (initialLambda N) (coarseEntryTree B d x y) (draws i) | |
| (coarseGuess (coarseEntryWidth x y) i) + 1) := | |
| Finset.sum_le_sum (fun i _ => (hcandidate B d x y hBdef hddef hsize hB hq hL i (draws i)).2) | |
| _ = _ := by | |
| simp only [coarseInitialArrayWork, ite_eq_right hlong, ite_eq_right he, | |
| ← Finset.mul_sum, Finset.sum_add_distrib, Finset.sum_const, Finset.card_univ, | |
| Fintype.card_fin, smul_eq_mul, mul_one] | |
| have hscan : x.length + y.length + 1 ≤ 3 * x.length + 1 := by omega | |
| apply coarseInitial_aggregate_scalar H x.length _ (Nat.clog 2 (coarseEntryWidth x y) + 1) | |
| _ _ hH (by omega) hr | |
| exact hw.trans (Nat.add_le_add_right (Nat.add_le_add_left | |
| (Nat.mul_le_mul_right (8 * H ^ 3 + 4) hscan) _) _) | |
| end BinaryFraction | |
| end EditApproximation | |
| end OAI | |