openAI-math-dataset / lean /OAI /Combinatorics /EditApproximation /Coarse /CoarseIndexedCompare.lean
| import OAI.Combinatorics.EditApproximation.Coarse.CoarseIndexedChildren | |
| namespace OAI | |
| namespace EditApproximation | |
| namespace BinaryFraction | |
| def coarseIndexAdditionalWork {B : ℕ} (q L : ℕ) (width : Fin B → ℕ) (draw : Fin B → Fin B) | |
| (extra : Fin B → BinaryFraction → ℕ → ℕ) (allowance : BinaryFraction) : | |
| List (Fin B) → ℕ → ℕ | |
| | [], _ => 0 | |
| | i :: rest, start => | |
| extra i (coarseChildAllowanceWithWork L (coarseChildThresholdWithWork B q allowance (draw i)).1).1 start + | |
| coarseIndexAdditionalWork q L width draw extra allowance rest (start + width i) | |
| /-- Local arithmetic depends only on returned arrays, so replacing a child | |
| by a representation-equivalent implementation preserves every parent array. -/ | |
| theorem coarseIndexChildren_value_congr {B : ℕ} (k q L : ℕ) (two : BinaryFraction) | |
| (width : Fin B → ℕ) (draw : Fin B → Fin B) | |
| (evaluate other : Fin B → BinaryFraction → ℕ → CoarseBinaryArray × ℕ) | |
| (he : ∀ i a start, (evaluate i a start).1 = (other i a start).1) | |
| (allowance : BinaryFraction) (indices : List (Fin B)) (start : ℕ) : | |
| (coarseIndexChildren k q L two width evaluate draw allowance indices start).1 = | |
| (coarseIndexChildren k q L two width other draw allowance indices start).1 := by | |
| induction indices generalizing start with | |
| | nil => rfl | |
| | cons i rest ih => simp only [coarseIndexChildren, he, ih] | |
| /-- Extra costs compose along the same child traversal; no child arithmetic | |
| or array allocation is charged twice by this comparison. -/ | |
| theorem coarseIndexChildren_cost_compare {B : ℕ} (k q L : ℕ) (two : BinaryFraction) | |
| (width : Fin B → ℕ) (draw : Fin B → Fin B) | |
| (evaluate other : Fin B → BinaryFraction → ℕ → CoarseBinaryArray × ℕ) | |
| (extra : Fin B → BinaryFraction → ℕ → ℕ) | |
| (he : ∀ i a start, (evaluate i a start).1 = (other i a start).1) | |
| (hc : ∀ i a start, (evaluate i a start).2 ≤ (other i a start).2 + extra i a start) | |
| (allowance : BinaryFraction) (indices : List (Fin B)) (start : ℕ) : | |
| (coarseIndexChildren k q L two width evaluate draw allowance indices start).2 ≤ | |
| (coarseIndexChildren k q L two width other draw allowance indices start).2 + | |
| coarseIndexAdditionalWork q L width draw extra allowance indices start := by | |
| induction indices generalizing start with | |
| | nil => simp only [coarseIndexChildren, coarseIndexAdditionalWork, Nat.add_zero, le_refl] | |
| | cons i rest ih => | |
| let childAllowance := (coarseChildAllowanceWithWork L | |
| (coarseChildThresholdWithWork B q allowance (draw i)).1).1 | |
| have hi := hc i childAllowance start | |
| have hr := ih (start + width i) | |
| have hechild := he i childAllowance start | |
| have herest := coarseIndexChildren_value_congr k q L two width draw evaluate other he | |
| allowance rest (start + width i) | |
| simp only [coarseIndexChildren, coarseIndexAdditionalWork] | |
| dsimp only [childAllowance] at hi hechild | |
| rw [hechild, herest] | |
| omega | |
| theorem arithmeticMapWithWork_add_cost {α β : Type*} (f : α → β × ℕ) | |
| (extra : α → ℕ) (xs : List α) : | |
| (arithmeticMapWithWork (fun x => ((f x).1, (f x).2 + extra x)) xs).2 = | |
| (arithmeticMapWithWork f xs).2 + (xs.map extra).sum := by | |
| induction xs with | |
| | nil => rfl | |
| | cons a xs ih => | |
| simp only [arithmeticMapWithWork, List.map_cons, List.sum_cons, ih] | |
| omega | |
| end BinaryFraction | |
| end EditApproximation | |
| end OAI | |