openAI-math-dataset / lean /OAI /Combinatorics /EditApproximation /Binary /BinaryCellCentersWork.lean
| import OAI.Combinatorics.EditApproximation.Binary.BinaryCellGridWork | |
| import OAI.Combinatorics.EditApproximation.Binary.BinaryLocalGuardWork | |
| import OAI.Combinatorics.EditApproximation.Binary.BinaryWideChildWork | |
| namespace OAI | |
| /-! Complete work for a whole-cell representative scan, including both | |
| endpoint grids and every initial-value eligibility test. -/ | |
| namespace EditApproximation | |
| namespace BinaryFraction | |
| private theorem flatMap_length_bound {α β : Type*} (f : α → List β) | |
| (xs : List α) (n : ℕ) (h : ∀ x ∈ xs, (f x).length ≤ n) : | |
| (xs.flatMap f).length ≤ xs.length * n := by | |
| induction xs with | |
| | nil => simp | |
| | cons x xs ih => | |
| simp only [List.flatMap_cons, List.length_append, List.length_cons] | |
| have hh := h x (by simp) | |
| have ht := ih (fun y hy => h y (by simp [hy])) | |
| rw [Nat.add_mul, Nat.one_mul] | |
| omega | |
| theorem cellStatesWithWork_length (n g : ℕ) (side : BinaryFraction) (cell : ℕ × ℕ) : | |
| (cellStatesWithWork n g side cell).1.length ≤ | |
| (cellGridPoints side.value g cell.1).length * | |
| (cellGridPoints side.value g cell.2).length := by | |
| simp only [cellStatesWithWork, arithmeticFlatMapWithWork_value, filterMapWithWork_value, | |
| makeStateWithWork_value] | |
| have h := flatMap_length_bound | |
| (fun lo => ((cellGridPointsWithWork side g cell.2).1.filterMap (makeTargetState n lo))) | |
| (cellGridPointsWithWork side g cell.1).1 (cellGridPointsWithWork side g cell.2).1.length | |
| (fun _ _ => List.length_filterMap_le _ _) | |
| simpa only [cellGridPointsWithWork_value] using h | |
| def cellCentersBitBudget (left right B : ℕ) : ℕ := | |
| 100 * (B + 2) ^ 2 + 2000 * (B + 1) ^ 2 + | |
| cellStatesBitBudget left right (4 * B + 40) + | |
| left * right * (localEligibilityBitBudget B + 3) + 3 | |
| theorem cellCentersWithWork_cost {n : ℕ} (P F b B : ℕ) (a theta : BinaryFraction) | |
| (initial : TargetInterval n → BinaryFraction) (cell : ℕ × ℕ) | |
| (hB : 6 ≤ B) (hn : Nat.size n ≤ B) (hb : Nat.size b + 2 ≤ B) | |
| (hP : Nat.size P ≤ B) (hF : Nat.size F + 2 ≤ B) | |
| (ha : a.width ≤ B) (htheta : theta.width ≤ B) | |
| (hi : ∀ q, (initial q).width ≤ B) | |
| (hleft : Nat.size cell.1 ≤ B) (hright : Nat.size cell.2 ≤ B) : | |
| (cellCentersWithWork P F b a theta initial cell).2 ≤ | |
| cellCentersBitBudget | |
| (cellGridPoints (theta.value * b) (bitWordValue (seedGridSpacingWithWork b P).1) cell.1).length | |
| (cellGridPoints (theta.value * b) (bitWordValue (seedGridSpacingWithWork b P).1) cell.2).length B := by | |
| let spacing := seedGridSpacingWithWork b P | |
| let side := canonicalMulWithWork theta (nat b) | |
| let states := cellStatesWithWork n (bitWordValue spacing.1) side.1 cell | |
| let C := 4 * B + 40 | |
| have hspacing := seedGridSpacingWithWork_bounds b P B (by omega) hP | |
| have hgs : Nat.size (bitWordValue spacing.1) ≤ C := | |
| (Nat.size_le.mpr (bitWordValue_lt_pow_length spacing.1)).trans (by | |
| have hh : spacing.1.length ≤ B + 1 := hspacing.1 | |
| dsimp only [C] | |
| omega) | |
| have hsidew := canonicalMulWithWork_width theta (nat b) B htheta ((nat_width_le b).trans hb) | |
| have hsidec := canonicalMulWithWork_cost theta (nat b) B htheta ((nat_width_le b).trans hb) | |
| change side.1.width ≤ 4 * B + 2 at hsidew | |
| have hstates := cellStatesWithWork_cost n (bitWordValue spacing.1) C side.1 cell | |
| (by dsimp only [C]; omega) hgs (by dsimp only [C]; omega) | |
| (by dsimp only [C]; omega) (by dsimp only [C]; omega) | |
| have hcount := cellStatesWithWork_length n (bitWordValue spacing.1) side.1 cell | |
| have hselected := filterWithWork_cost | |
| (fun r => centerEligibilityWithWork b F a (initial r)) states.1 | |
| (localEligibilityBitBudget B) | |
| (fun r _ => centerEligibilityWithWork_cost b F B a (initial r) hB hb hF ha (hi r)) | |
| change states.1.length ≤ _ at hcount | |
| change states.2 ≤ _ at hstates | |
| change side.2 ≤ _ at hsidec | |
| change spacing.2 + side.2 + states.2 + | |
| (filterWithWork (fun r => centerEligibilityWithWork b F a (initial r)) states.1).2 + 3 ≤ _ | |
| have hsc : spacing.2 ≤ 100 * (B + 2) ^ 2 := hspacing.2 | |
| have hv : side.1.value = theta.value * b := by | |
| simp only [side, canonicalMulWithWork_value, nat_value] | |
| rw [hv] at hstates hcount | |
| unfold cellCentersBitBudget | |
| change _ ≤ 100 * (B + 2) ^ 2 + 2000 * (B + 1) ^ 2 + | |
| cellStatesBitBudget | |
| (cellGridPoints (theta.value * b) (bitWordValue spacing.1) cell.1).length | |
| (cellGridPoints (theta.value * b) (bitWordValue spacing.1) cell.2).length (4 * B + 40) + | |
| (cellGridPoints (theta.value * b) (bitWordValue spacing.1) cell.1).length * | |
| (cellGridPoints (theta.value * b) (bitWordValue spacing.1) cell.2).length * | |
| (localEligibilityBitBudget B + 3) + 3 | |
| have hfilter := hselected.trans (Nat.mul_le_mul_right _ hcount) | |
| dsimp only [C] at hstates | |
| omega | |
| theorem cellCentersBitBudget_mono_count (l l' r r' B : ℕ) (hl : l ≤ l') (hr : r ≤ r') : | |
| cellCentersBitBudget l r B ≤ cellCentersBitBudget l' r' B := by | |
| unfold cellCentersBitBudget cellStatesBitBudget cellGridPointsBitBudget | |
| gcongr | |
| theorem cellCentersWithWork_uniform_cost {n : ℕ} (P F b B : ℕ) (a theta : BinaryFraction) | |
| (initial : TargetInterval n → BinaryFraction) (cell : ℕ × ℕ) | |
| (hB : 6 ≤ B) (hn : Nat.size n ≤ B) (hb : Nat.size b + 2 ≤ B) | |
| (hP : Nat.size P ≤ B) (hF : Nat.size F + 2 ≤ B) | |
| (ha : a.width ≤ B) (htheta : theta.width ≤ B) | |
| (hi : ∀ q, (initial q).width ≤ B) | |
| (hleft : Nat.size cell.1 ≤ B) (hright : Nat.size cell.2 ≤ B) | |
| (hthetaValue : 0 ≤ theta.value ∧ theta.value ≤ 1) | |
| (hbdyadic : ∃ e : ℕ, b = 2 ^ e) (hPdyadic : ∃ e : ℕ, P = 2 ^ e) : | |
| (cellCentersWithWork P F b a theta initial cell).2 ≤ cellCentersBitBudget P P B := by | |
| have hPpos : 0 < P := by obtain ⟨e, rfl⟩ := hPdyadic; exact Nat.two_pow_pos e | |
| have hg : (0 : ℚ) < seedGridSpacing b P := by | |
| exact_mod_cast (show 0 < seedGridSpacing b P by unfold seedGridSpacing; omega) | |
| have hcover : (b : ℚ) ≤ P * (seedGridSpacing b P : ℚ) := by | |
| exact_mod_cast seedGridSpacing_covers_dyadic hbdyadic hPdyadic | |
| have hsize : theta.value * b / seedGridSpacing b P ≤ (P : ℚ) := by | |
| apply (div_le_iff₀ hg).2 | |
| have hb : theta.value * b ≤ (b : ℚ) := by | |
| simpa only [one_mul] using | |
| mul_le_mul_of_nonneg_right hthetaValue.2 (Nat.cast_nonneg (α := ℚ) b) | |
| exact hb.trans hcover | |
| have hlen (j : ℕ) : (cellGridPoints (theta.value * b) (seedGridSpacing b P) j).length ≤ P := | |
| cellGridPoints_length_le (mul_nonneg hthetaValue.1 (Nat.cast_nonneg _)) hsize | |
| have hc := cellCentersWithWork_cost P F b B a theta initial cell hB hn hb hP hF ha htheta hi hleft hright | |
| rw [seedGridSpacingWithWork_value b P hPpos] at hc | |
| exact hc.trans (cellCentersBitBudget_mono_count _ _ _ _ B (hlen cell.1) (hlen cell.2)) | |
| end BinaryFraction | |
| end EditApproximation | |
| end OAI | |