openAI-math-dataset / lean /OAI /Combinatorics /EditApproximation /Numerics /OptimizerWorkspace.lean
| import OAI.Combinatorics.EditApproximation.Numerics.OptimizerBits | |
| namespace OAI | |
| /-! Bit storage of the concrete materialized iterates. The history bound | |
| allows every previous iterate to remain live; it does not rely on a garbage | |
| collector reclaiming old vector allocations. -/ | |
| namespace EditApproximation | |
| open Finset | |
| def rationalVectorStorageBits {d : ℕ} (values : Vector ℚ d) : ℕ := | |
| ∑ i : Fin d, rationalEncodingBits (values.get i) | |
| def optimizerStoredHistory {d : ℕ} (vertices : List (Vector ℚ d)) | |
| (linear : Vector ℚ d) (G K : ℕ) : List (Vector ℚ d) := | |
| (List.range (K + 1)).map fun j => (materializedOptimizerWithWork vertices linear G j).1 | |
| def rationalVectorListStorageBits {d : ℕ} (values : List (Vector ℚ d)) : ℕ := | |
| (values.map rationalVectorStorageBits).sum | |
| theorem rationalVectorStorageBits_le {d : ℕ} (values : Vector ℚ d) (B : ℕ) | |
| (hB : ∀ i, rationalEncodingBits (values.get i) ≤ B) : | |
| rationalVectorStorageBits values ≤ d * B := by | |
| calc | |
| _ ≤ ∑ _i : Fin d, B := Finset.sum_le_sum (fun i _ => hB i) | |
| _ = _ := by simp | |
| theorem rationalVectorListStorageBits_le {d : ℕ} (values : List (Vector ℚ d)) (B : ℕ) | |
| (hB : ∀ value ∈ values, rationalVectorStorageBits value ≤ B) : | |
| rationalVectorListStorageBits values ≤ values.length * B := by | |
| unfold rationalVectorListStorageBits | |
| induction values with | |
| | nil => simp | |
| | cons value rest ih => | |
| have hv := hB value List.mem_cons_self | |
| have hr := ih (fun v hv => hB v (List.mem_cons_of_mem _ hv)) | |
| simp only [List.map_cons, List.sum_cons, List.length_cons, Nat.add_mul, Nat.one_mul] | |
| omega | |
| theorem materializedOptimizerWithWork_uniform_encoding {d : ℕ} | |
| (vertices : List (Vector ℚ d)) (linear : Vector ℚ d) (G K B j : ℕ) | |
| (hvertices : vertices ≠ []) (hj : j ≤ K) (i : Fin d) | |
| (hinput : ∀ vertex ∈ vertices, | |
| (0 ≤ vertex.get i ∧ vertex.get i ≤ 1) ∧ Nat.size (vertex.get i).den ≤ B) : | |
| rationalEncodingBits ((materializedOptimizerWithWork vertices linear G j).1.get i) ≤ | |
| 2 * ((K + 1) * (2 * Nat.size (K + 1) + 2 + B) + 1) + 1 := by | |
| by_cases hjzero : j = 0 | |
| · subst j | |
| cases vertices with | |
| | nil => exact False.elim (hvertices rfl) | |
| | cons vertex rest => | |
| have hcoord := hinput vertex List.mem_cons_self | |
| have hnum := Nat.size_le_size (rational_numerator_bound (vertex.get i) 1 (by | |
| rw [abs_of_nonneg hcoord.1.1] | |
| exact hcoord.1.2)) | |
| simp only [Nat.one_mul] at hnum | |
| change rationalEncodingBits (vertex.get i) ≤ _ | |
| unfold rationalEncodingBits | |
| have hK : 1 ≤ K + 1 := by omega | |
| have hpositive : B ≤ 2 * Nat.size (K + 1) + 2 + B := by omega | |
| have hproduct := Nat.mul_le_mul hK hpositive | |
| omega | |
| · have hbound := materializedOptimizerWithWork_encoding vertices linear G j B | |
| hvertices (by omega) i hinput | |
| have hsize := Nat.size_le_size (by omega : j ≤ K + 1) | |
| have hproduct := Nat.mul_le_mul (by omega : j ≤ K + 1) | |
| (by omega : 2 * Nat.size j + 2 + B ≤ 2 * Nat.size (K + 1) + 2 + B) | |
| omega | |
| theorem optimizerStoredHistory_storage_le {d : ℕ} | |
| (vertices : List (Vector ℚ d)) (linear : Vector ℚ d) (G K B : ℕ) | |
| (hvertices : vertices ≠ []) | |
| (hinput : ∀ vertex ∈ vertices, ∀ i, | |
| (0 ≤ vertex.get i ∧ vertex.get i ≤ 1) ∧ Nat.size (vertex.get i).den ≤ B) : | |
| rationalVectorListStorageBits (optimizerStoredHistory vertices linear G K) ≤ | |
| (K + 1) * (d * (2 * ((K + 1) * (2 * Nat.size (K + 1) + 2 + B) + 1) + 1)) := by | |
| have hstorage := rationalVectorListStorageBits_le (optimizerStoredHistory vertices linear G K) | |
| (d * (2 * ((K + 1) * (2 * Nat.size (K + 1) + 2 + B) + 1) + 1)) (by | |
| intro value hv | |
| obtain ⟨j, hj, rfl⟩ := List.mem_map.mp hv | |
| apply rationalVectorStorageBits_le | |
| intro i | |
| exact materializedOptimizerWithWork_uniform_encoding vertices linear G K B j hvertices | |
| (by have := List.mem_range.mp hj; omega) i (fun vertex hv => hinput vertex hv i)) | |
| simpa only [optimizerStoredHistory, List.length_map, List.length_range] using hstorage | |
| end EditApproximation | |
| end OAI | |