openAI-math-dataset / lean /OAI /Combinatorics /EditApproximation /Binary /BinaryActionSelection.lean
| import OAI.Combinatorics.EditApproximation.Binary.BinaryOptimizerWork | |
| import OAI.Combinatorics.EditApproximation.Definitions | |
| namespace OAI | |
| /-! The final Boolean maximization retains the actual action label. This | |
| is the sampled atom of the optimizer, rather than its averaged vector. -/ | |
| namespace EditApproximation | |
| namespace BinaryFraction | |
| open Finset | |
| theorem dotWithWork_value {d : ℕ} (left right : Vector BinaryFraction d) : | |
| (dotWithWork left right).1.value = ∑ i, (left.get i).value * (right.get i).value := by | |
| rw [← representation_value, dotWithWork_representation, UnreducedRational.dot_value] | |
| simp only [vector_map_get, representation_value] | |
| theorem gradientWithWork_value {d : ℕ} (G : ℕ) (linear point : Vector BinaryFraction d) (i : Fin d) : | |
| ((gradientWithWork G linear point).1.get i).value = | |
| rationalSmoothedGradient G (fun j => (linear.get j).value) (fun j => (point.get j).value) i := by | |
| have h := congrArg (fun v : Vector UnreducedRational d => (v.get i).value) | |
| (gradientWithWork_representation G linear point) | |
| simp only [vector_map_get, representation_value, UnreducedRational.gradient_value] at h | |
| simpa only [vector_map_get, representation_value] using h | |
| theorem selectionWithWork_value {α : Type*} {d : ℕ} | |
| (vertices : List (α × Vector BinaryFraction d)) (linear : Vector BinaryFraction d) (G j : ℕ) : | |
| (selectionWithWork vertices linear G j).1 = | |
| (materializedSelectionWithWork | |
| (vertices.map fun v => (v.1, v.2.map value)) (linear.map value) G j).1 := by | |
| rw [materializedSelectionWithWork_value, argmax_map_commutes] | |
| simp only [selectionWithWork, scoredArgmaxWithWork_value, Option.map_map, Function.comp_def] | |
| apply congrArg (fun score => (vertices.argmax score).map Prod.fst) | |
| funext vertex | |
| rw [dotWithWork_value] | |
| have hget (v : Vector BinaryFraction d) : (v.map value).get = fun i => (v.get i).value := by | |
| funext i | |
| exact vector_map_get value v i | |
| simp only [gradientWithWork_value, finiteOptimizerWithWork_value, | |
| List.map_map, vector_map_get, Function.comp_def, hget] | |
| theorem scoredArgmaxWithWork_map_cost {α β : Type*} (mapping : α → β) | |
| (score : β → BinaryFraction × ℕ) (values : List α) : | |
| (scoredArgmaxWithWork (fun a => score (mapping a)) values).2 = | |
| (scoredArgmaxWithWork score (values.map mapping)).2 := by | |
| have h : (scoredArgmaxWithWork score (values.map mapping)).1 = | |
| (scoredArgmaxWithWork (fun a => score (mapping a)) values).1.map | |
| (fun result => (mapping result.1, result.2)) ∧ | |
| (scoredArgmaxWithWork (fun a => score (mapping a)) values).2 = | |
| (scoredArgmaxWithWork score (values.map mapping)).2 := by | |
| induction values with | |
| | nil => exact ⟨rfl, rfl⟩ | |
| | cons head tail ih => | |
| simp only [List.map_cons, scoredArgmaxWithWork, ih.1, ← ih.2] | |
| cases htail : (scoredArgmaxWithWork (fun a => score (mapping a)) tail).1 with | |
| | none => exact ⟨rfl, rfl⟩ | |
| | some best => | |
| simp only [Option.map_some] | |
| split_ifs <;> simp | |
| exact h.2 | |
| def selectionBitBudget (d vertices G K B Bv L V : ℕ) : ℕ := | |
| let P := optimizerPointWordBudget K B Bv | |
| let W := optimizerGradientWordBudget G K B Bv L | |
| optimizerBitBudget d vertices G K B Bv L V + d * (gradientCellBitBudget G P L + 6) + | |
| maximizerBitBudget d vertices (max P W) (2 * G ^ 60 + 1 + V + 1) | |
| theorem selectionWithWork_cost {α : Type*} {d : ℕ} | |
| (vertices : List (α × Vector BinaryFraction d)) (linear : Vector BinaryFraction d) | |
| (G K B Bv L V : ℕ) (hvertices : vertices ≠ []) | |
| (hinput : ∀ v ∈ vertices, ∀ i : Fin d, | |
| (v.2.get i).width ≤ (v.2.get i).representation.storageBits ∧ | |
| (0 ≤ (v.2.get i).value ∧ (v.2.get i).value ≤ 1) ∧ | |
| Nat.size (v.2.get i).representation.den ≤ B) | |
| (hvw : ∀ v ∈ vertices, ∀ i, (v.2.get i).width ≤ Bv) | |
| (hlw : ∀ i, (linear.get i).width ≤ L) | |
| (hlv : ∀ i, |(linear.get i).value| ≤ V) : | |
| (selectionWithWork vertices linear G K).2 ≤ selectionBitBudget d vertices.length G K B Bv L V := by | |
| let points := vertices.map Prod.snd | |
| let point := (finiteOptimizerWithWork points linear G K).1 | |
| let grad := (gradientWithWork G linear point).1 | |
| let P := optimizerPointWordBudget K B Bv | |
| let W := optimizerGradientWordBudget G K B Bv L | |
| have hpnonempty : points ≠ [] := by | |
| intro h | |
| exact hvertices (List.map_eq_nil_iff.mp h) | |
| have hpinput (v : Vector BinaryFraction d) (hv : v ∈ points) (i : Fin d) : | |
| (v.get i).width ≤ (v.get i).representation.storageBits ∧ | |
| (0 ≤ (v.get i).value ∧ (v.get i).value ≤ 1) ∧ Nat.size (v.get i).representation.den ≤ B := by | |
| obtain ⟨a, ha, rfl⟩ := List.mem_map.mp hv | |
| exact hinput a ha i | |
| have hpw (v : Vector BinaryFraction d) (hv : v ∈ points) (i : Fin d) : (v.get i).width ≤ Bv := by | |
| obtain ⟨a, ha, rfl⟩ := List.mem_map.mp hv | |
| exact hvw a ha i | |
| have hpoint (i : Fin d) : (point.get i).width ≤ P := by | |
| have h := finiteOptimizerWithWork_coordinate_width points linear G K B hpnonempty hpinput i | |
| change (point.get i).width ≤ _ at h | |
| dsimp only [P, optimizerPointWordBudget] | |
| omega | |
| have hpositive (i : Fin d) : 0 ≤ (point.get i).value := by | |
| have hn : (points.map fun v i => (v.get i).value) ≠ [] := by | |
| intro h | |
| exact hpnonempty (List.map_eq_nil_iff.mp h) | |
| have h := finiteRationalOptimizer_coordinate_bounds univ | |
| (points.map fun v i => (v.get i).value) (fun i => (linear.get i).value) G K hn i (by | |
| intro v hv | |
| obtain ⟨w, hw, rfl⟩ := List.mem_map.mp hv | |
| exact (hpinput w hw i).2.1) | |
| rw [← congrFun (finiteOptimizerWithWork_value points linear G K) i] at h | |
| exact h.1 | |
| have hgw (i : Fin d) : (grad.get i).width ≤ W := | |
| gradientWithWork_width G linear point P L hpositive hpoint hlw i | |
| have hgv (i : Fin d) : |(grad.get i).value| ≤ (2 * G ^ 60 + 1 + V + 1 : ℕ) := | |
| (gradientWithWork_abs G V linear point hpositive hlv i).trans | |
| (by exact_mod_cast Nat.le_add_right (2 * G ^ 60 + 1 + V) 1) | |
| have hvP (v : Vector BinaryFraction d) (hv : v ∈ points) (i : Fin d) : (v.get i).width ≤ P := by | |
| have h := hpw v hv i | |
| dsimp only [P, optimizerPointWordBudget] | |
| omega | |
| have hvabs (v : Vector BinaryFraction d) (hv : v ∈ points) (i : Fin d) : | |
| |(v.get i).value| ≤ (2 * G ^ 60 + 1 + V + 1 : ℕ) := by | |
| rw [abs_of_nonneg (hpinput v hv i).2.1.1] | |
| exact (hpinput v hv i).2.1.2.trans (by exact_mod_cast | |
| (show 1 ≤ 2 * G ^ 60 + 1 + V + 1 by omega)) | |
| have hiterate := finiteOptimizerWithWork_cost points linear G K B Bv L V hpnonempty hpinput hpw hlw hlv | |
| have hgradient := gradientWithWork_cost G linear point P L hpositive hpoint hlw | |
| have hselected := maximizerWithWork_cost grad points (max P W) (2 * G ^ 60 + 1 + V + 1) | |
| (fun i => (hgw i).trans (Nat.le_max_right _ _)) hgv | |
| (fun v hv i => (hvP v hv i).trans (Nat.le_max_left _ _)) hvabs | |
| rw [maximizerWithWork, ← scoredArgmaxWithWork_map_cost Prod.snd (dotWithWork grad) vertices] at hselected | |
| simp only [points, List.length_map] at hiterate hselected | |
| change (finiteOptimizerWithWork points linear G K).2 ≤ _ at hiterate | |
| change (finiteOptimizerWithWork points linear G K).2 + (gradientWithWork G linear point).2 + | |
| (scoredArgmaxWithWork (fun vertex => dotWithWork grad vertex.2) vertices).2 + 1 ≤ _ | |
| change _ ≤ optimizerBitBudget d vertices.length G K B Bv L V + | |
| d * (gradientCellBitBudget G P L + 6) + | |
| maximizerBitBudget d vertices.length (max P W) (2 * G ^ 60 + 1 + V + 1) | |
| omega | |
| end BinaryFraction | |
| end EditApproximation | |
| end OAI | |