| import OAI.Combinatorics.EditApproximation.Queries.QuerySharedGeometry |
| import OAI.Combinatorics.EditApproximation.Queries.QueryHistoryBounds |
|
|
| namespace OAI |
|
|
| namespace EditApproximation |
|
|
| theorem gridPointsBetween_radius_count (g p radius : ℕ) (hg : 0 < g) : |
| (gridPointsBetween g (p - radius) (p + radius)).length ≤ 2 * radius / g + 2 := |
| (gridPointsBetween_length_le g _ _ hg).trans |
| (Nat.add_le_add_right (Nat.div_le_div_right (by omega : p + radius - (p - radius) ≤ 2 * radius)) 2) |
|
|
| def queryGapStatesBitBudget (left right B : ℕ) : ℕ := |
| let C := 1000 * (B + 10) ^ 2 |
| C + gridPointsBitBudget left (B + 2) + |
| left * (C + gridPointsBitBudget right (B + 6) + right * (16 * (B + 6) + 11) + right + 7) + 3 |
|
|
| private theorem queryGapStates_arithmetic_bound (B u v w : ℕ) |
| (hu : u ≤ 26 * (B + 4) + 4) (hv : v ≤ 26 * (B + 4) + 4) |
| (hw : w ≤ 26 * (B + 4) + 4) : |
| u + v + w ≤ 1000 * (B + 10) ^ 2 := by |
| nlinarith only [hu, hv, hw, Nat.zero_le B] |
|
|
| theorem queryGapStatesWithWork_bounds (n g anchor radius sourceLength gapRadius left right B : ℕ) |
| (hg : 0 < g) (hn : Nat.size n ≤ B) (hgs : Nat.size g ≤ B) |
| (ha : Nat.size anchor ≤ B) (hr : Nat.size radius ≤ B) |
| (hl : Nat.size sourceLength ≤ B) (hgap : Nat.size gapRadius ≤ B) |
| (hleft : 2 * radius / g + 2 ≤ left) (hright : 2 * gapRadius / g + 2 ≤ right) : |
| (queryGapStatesWithWork n g anchor radius sourceLength gapRadius).1.length ≤ left * right ∧ |
| (queryGapStatesWithWork n g anchor radius sourceLength gapRadius).2 ≤ |
| queryGapStatesBitBudget left right B := by |
| let lo := saturatingSubtractWithWork anchor radius |
| let hi := binaryNaturalAddWithWork anchor radius |
| let firsts := gridPointsWithWork g (bitWordValue lo.1) (bitWordValue hi.1) |
| let run := fun first => |
| let center := binaryNaturalAddWithWork first sourceLength |
| let lower := saturatingSubtractWithWork (bitWordValue center.1) gapRadius |
| let upper := binaryNaturalAddWithWork (bitWordValue center.1) gapRadius |
| let last := gridPointsWithWork g (bitWordValue lower.1) (bitWordValue upper.1) |
| let valid := filterMapWithWork (makeStateWithWork n first) last.1 |
| (valid.1, center.2 + lower.2 + upper.2 + last.2 + valid.2 + 4) |
| let C := 1000 * (B + 10) ^ 2 |
| have hv : firsts.1 = gridPointsBetween g (anchor - radius) (anchor + radius) := by |
| simp only [firsts, gridPointsWithWork_value _ _ _ hg, lo, hi, |
| saturatingSubtractWithWork_value, binaryNaturalAddWithWork_value] |
| have hflen : firsts.1.length ≤ left := by rw [hv]; exact (gridPointsBetween_radius_count g anchor radius hg).trans hleft |
| have hlow : Nat.size (bitWordValue lo.1) ≤ B := by |
| rw [saturatingSubtractWithWork_value] |
| exact (Nat.size_le_size (Nat.sub_le _ _)).trans ha |
| have hhigh : Nat.size (bitWordValue hi.1) ≤ B + 2 := by |
| rw [binaryNaturalAddWithWork_value] |
| exact (binaryNaturalAdd_size_le anchor radius).trans (by omega) |
| have hfc := gridPointsWithWork_cost g (bitWordValue lo.1) (bitWordValue hi.1) (B + 2) hg |
| (by omega) (by omega) hhigh |
| rw [← gridPointsWithWork_value g (bitWordValue lo.1) (bitWordValue hi.1) hg] at hfc |
| have hfc' : firsts.2 ≤ gridPointsBitBudget left (B + 2) := hfc.trans (by |
| unfold gridPointsBitBudget |
| gcongr) |
| have hfirst (first : ℕ) (hf : first ∈ firsts.1) : Nat.size first ≤ B + 2 := by |
| rw [hv] at hf |
| exact (Nat.size_le_size (gridPointsBetween_sound hg hf).2.1).trans |
| ((binaryNaturalAdd_size_le anchor radius).trans (by omega)) |
| have hrun (first : ℕ) (hf : first ∈ firsts.1) : |
| (run first).1.length ≤ right ∧ |
| (run first).2 ≤ C + gridPointsBitBudget right (B + 6) + right * (16 * (B + 6) + 11) + 4 := by |
| let center := binaryNaturalAddWithWork first sourceLength |
| let lower := saturatingSubtractWithWork (bitWordValue center.1) gapRadius |
| let upper := binaryNaturalAddWithWork (bitWordValue center.1) gapRadius |
| let last := gridPointsWithWork g (bitWordValue lower.1) (bitWordValue upper.1) |
| have hsfirst := hfirst first hf |
| have hcenter : Nat.size (bitWordValue center.1) ≤ B + 4 := by |
| rw [binaryNaturalAddWithWork_value] |
| exact (binaryNaturalAdd_size_le first sourceLength).trans (by omega) |
| have hslow : Nat.size (bitWordValue lower.1) ≤ B + 4 := by |
| rw [saturatingSubtractWithWork_value] |
| exact (Nat.size_le_size (Nat.sub_le _ _)).trans hcenter |
| have hsup : Nat.size (bitWordValue upper.1) ≤ B + 6 := by |
| rw [binaryNaturalAddWithWork_value] |
| exact (binaryNaturalAdd_size_le (bitWordValue center.1) gapRadius).trans (by omega) |
| have hlv : last.1 = gridPointsBetween g (bitWordValue center.1 - gapRadius) |
| (bitWordValue center.1 + gapRadius) := by |
| simp only [last, gridPointsWithWork_value _ _ _ hg, lower, upper, |
| saturatingSubtractWithWork_value, binaryNaturalAddWithWork_value] |
| have hllen : last.1.length ≤ right := by |
| rw [hlv] |
| exact (gridPointsBetween_radius_count g (bitWordValue center.1) gapRadius hg).trans hright |
| have hlastCost := gridPointsWithWork_cost g (bitWordValue lower.1) |
| (bitWordValue upper.1) (B + 6) hg (by omega) (by omega) hsup |
| rw [← gridPointsWithWork_value g (bitWordValue lower.1) (bitWordValue upper.1) hg] at hlastCost |
| have hlast : last.2 ≤ gridPointsBitBudget right (B + 6) := by |
| have hmono : gridPointsBitBudget last.1.length (B + 6) ≤ gridPointsBitBudget right (B + 6) := by |
| unfold gridPointsBitBudget |
| gcongr |
| have hcost : last.2 ≤ gridPointsBitBudget last.1.length (B + 6) := by |
| simpa only [last] using hlastCost |
| exact hcost.trans hmono |
| have hvalid := (filterMapWithWork_cost (makeStateWithWork n first) last.1 |
| (16 * (B + 6) + 8) (fun second hsecond => |
| makeStateWithWork_cost n first second (B + 6) (by omega) (by omega) (by |
| rw [hlv] at hsecond |
| exact (Nat.size_le_size (gridPointsBetween_sound hg hsecond).2.1).trans (by |
| simpa only [upper, binaryNaturalAddWithWork_value] using hsup)))).trans |
| (Nat.mul_le_mul_right _ hllen) |
| have hcc : center.2 ≤ 9 * (Nat.size first + Nat.size sourceLength) + 1 := by |
| simpa only [center] using binaryNaturalAddWithWork_cost first sourceLength |
| have hlc : lower.2 ≤ 13 * (Nat.size (bitWordValue center.1) + Nat.size gapRadius) + 4 := by |
| simpa only [lower] using saturatingSubtractWithWork_cost (bitWordValue center.1) gapRadius |
| have huc : upper.2 ≤ 9 * (Nat.size (bitWordValue center.1) + Nat.size gapRadius) + 1 := by |
| simpa only [upper] using binaryNaturalAddWithWork_cost (bitWordValue center.1) gapRadius |
| have harith : center.2 + lower.2 + upper.2 ≤ C := by |
| exact queryGapStates_arithmetic_bound B center.2 lower.2 upper.2 |
| (hcc.trans (by omega)) (hlc.trans (by omega)) (huc.trans (by omega)) |
| constructor |
| · have hlen : (filterMapWithWork (makeStateWithWork n first) last.1).1.length ≤ right := by |
| rw [filterMapWithWork_value] |
| exact (List.length_filterMap_le _ _).trans hllen |
| simpa only [run, center, lower, upper, last] using hlen |
| · have hcost : center.2 + lower.2 + upper.2 + last.2 + |
| (filterMapWithWork (makeStateWithWork n first) last.1).2 + 4 ≤ |
| C + gridPointsBitBudget right (B + 6) + right * (16 * (B + 6) + 11) + 4 := by |
| simp only [Nat.add_assoc, Nat.reduceAdd] at hvalid |
| omega |
| simpa only [run, center, lower, upper, last] using hcost |
| have hflat := (arithmeticFlatMapWithWork_cost run firsts.1 |
| (C + gridPointsBitBudget right (B + 6) + right * (16 * (B + 6) + 11) + 4) right |
| (fun first hf => (hrun first hf).2) (fun first hf => (hrun first hf).1)).trans |
| (Nat.mul_le_mul_right _ hflen) |
| have hlc : lo.2 ≤ 13 * (Nat.size anchor + Nat.size radius) + 4 := by |
| simpa only [lo] using saturatingSubtractWithWork_cost anchor radius |
| have huc : hi.2 ≤ 9 * (Nat.size anchor + Nat.size radius) + 1 := by |
| simpa only [hi] using binaryNaturalAddWithWork_cost anchor radius |
| have hsetup : lo.2 + hi.2 ≤ C := by |
| have h := queryGapStates_arithmetic_bound B lo.2 hi.2 0 |
| (hlc.trans (by omega)) (huc.trans (by omega)) (by omega) |
| simpa only [Nat.add_zero] using h |
| constructor |
| · have hlen := (arithmeticFlatMapWithWork_length run firsts.1 right |
| (fun first hf => (hrun first hf).1)).trans (Nat.mul_le_mul_right _ hflen) |
| simpa only [queryGapStatesWithWork, lo, hi, firsts, run] using hlen |
| · have hcost : lo.2 + hi.2 + firsts.2 + (arithmeticFlatMapWithWork run firsts.1).2 + 3 ≤ |
| queryGapStatesBitBudget left right B := by |
| unfold queryGapStatesBitBudget |
| change _ ≤ C + gridPointsBitBudget left (B + 2) + |
| left * (C + gridPointsBitBudget right (B + 6) + right * (16 * (B + 6) + 11) + right + 7) + 3 |
| rw [show C + gridPointsBitBudget right (B + 6) + right * (16 * (B + 6) + 11) + 4 + right + 3 = |
| C + gridPointsBitBudget right (B + 6) + right * (16 * (B + 6) + 11) + right + 7 by omega] at hflat |
| omega |
| simpa only [queryGapStatesWithWork, lo, hi, firsts, run] using hcost |
| |
| end EditApproximation |
| |
| end OAI |
| |
