openAI-math-dataset / lean /OAI /Combinatorics /LowSpaceSubsetSum /Representation /RepresentationAllocation.lean
| import OAI.Combinatorics.LowSpaceSubsetSum.Counting.BalancedLeafEntropy | |
| namespace OAI | |
| /-! # Feasibility of the executable representation allocation -/ | |
| noncomputable section | |
| namespace LowSpaceSubsetSum | |
| open scoped BigOperators | |
| open RepresentationSetup | |
| def representationCount (n : ℕ) (g : Guesses n) (complement : Bool) (j : Fin 3) : ℕ := | |
| if complement then mixerSize n / 2 - (g j).val else (g j).val | |
| def representationBits (n : ℕ) (g : Guesses n) (complement : Bool) (j : Fin 3) : ℕ := | |
| binomialBits (mixerSize n) (representationCount n g complement j) | |
| def representationBackgroundSize (n : ℕ) : ℕ := n - 3 * mixerSize n | |
| def representationParentSize (n : ℕ) (g : Guesses n) (j : Fin 2) : ℕ := | |
| allocateSide (j != 0) (representationBackgroundSize n) | |
| (representationBits n g false 0) (representationBits n g true 0) | |
| def representationChildSize (n : ℕ) (g : Guesses n) (j : Fin 2) (right : Bool) : ℕ := | |
| allocateSide right (representationParentSize n g j) | |
| (representationBits n g false j.succ) (representationBits n g true j.succ) | |
| def representationLeafCounts (n : ℕ) (g : Guesses n) : Fin 8 → ℕ := | |
| computedLeafCounts (representationBackgroundSize n) | |
| (representationBits n g false 0) (representationBits n g true 0) | |
| (representationBits n g false 1) (representationBits n g true 1) | |
| (representationBits n g false 2) (representationBits n g true 2) | |
| def representationEntropy (n : ℕ) (g : Guesses n) (complement : Bool) (j : Fin 3) : ℝ := | |
| (mixerSize n : ℝ) * binaryEntropy | |
| (orientedDensity complement (((g j).val : ℝ) / mixerSize n)) | |
| /-- The main-branch input-scale test supplies the small allocation error. -/ | |
| theorem representation_log_budget {n : ℕ} {u : ℝ} (hn : 10000 ≤ n) | |
| (hmu : (mixerSize n : ℝ) + 1 ≤ u) (hlog : Real.logb 2 u ≤ (n : ℝ) / 1000000000) : | |
| Real.logb 2 ((mixerSize n : ℝ) + 1) + 1 ≤ (n : ℝ) / 1000 := by | |
| have hmono := Real.logb_le_logb_of_le (by norm_num : (1 : ℝ) < 2) | |
| (by positivity : (0 : ℝ) < (mixerSize n : ℝ) + 1) hmu | |
| have hnR : (10000 : ℝ) ≤ n := by exact_mod_cast hn | |
| linarith | |
| theorem representationCount_le (n : ℕ) (g : Guesses n) (complement : Bool) (j : Fin 3) : | |
| representationCount n g complement j ≤ mixerSize n := by | |
| have hg := (Finset.mem_Icc.mp (g j).property).2 | |
| change (g j).val ≤ mixerSize n / 4 at hg | |
| cases complement <;> simp only [representationCount, Bool.false_eq_true, ↓reduceIte] <;> omega | |
| theorem representationCount_fraction {n : ℕ} (g : Guesses n) (complement : Bool) | |
| (hm : 0 < mixerSize n) (j : Fin 3) : | |
| (representationCount n g complement j : ℝ) / mixerSize n = | |
| orientedDensity complement (((g j).val : ℝ) / mixerSize n) := by | |
| have hg := (Finset.mem_Icc.mp (g j).property).2 | |
| change (g j).val ≤ mixerSize n / 4 at hg | |
| have hk : (g j).val ≤ mixerSize n / 2 := by omega | |
| have he : 2 * (mixerSize n / 2) = mixerSize n := by unfold mixerSize; omega | |
| have heR : (2 : ℝ) * (mixerSize n / 2 : ℕ) = mixerSize n := by exact_mod_cast he | |
| have hmR : (mixerSize n : ℝ) ≠ 0 := by positivity | |
| cases complement | |
| · rfl | |
| · simp only [representationCount, orientedDensity, ↓reduceIte, Nat.cast_sub hk] | |
| rw [sub_div] | |
| congr 1 | |
| apply (div_eq_iff hmR).mpr | |
| nlinarith | |
| theorem representationBits_entropy_error {n : ℕ} (g : Guesses n) (complement : Bool) | |
| (hm : 0 < mixerSize n) (j : Fin 3) : | |
| |(representationBits n g complement j : ℝ) - representationEntropy n g complement j| < | |
| Real.logb 2 ((mixerSize n : ℝ) + 1) + 1 := by | |
| have h := binomialBits_entropy_error (mixerSize n) (representationCount n g complement j) | |
| (representationCount_le n g complement j) | |
| rw [representationCount_fraction g complement hm j] at h | |
| exact h | |
| theorem representationBits_difference {n : ℕ} (g : Guesses n) | |
| (hm : 0 < mixerSize n) (j : Fin 3) : | |
| |(representationBits n g true j : ℝ) - representationBits n g false j| < | |
| (3 / 8 : ℝ) * mixerSize n + 2 * (Real.logb 2 ((mixerSize n : ℝ) + 1) + 1) := by | |
| apply binomialBits_difference (mixerSize n) (representationCount n g false j) | |
| (representationCount n g true j) | |
| (representationCount_le n g false j) (representationCount_le n g true j) | |
| · rw [representationCount_fraction g false hm] | |
| exact orientedDensity_mem (guess_density g hm j) false | |
| · rw [representationCount_fraction g true hm] | |
| exact orientedDensity_mem (guess_density g hm j) true | |
| theorem allocation_guards_of_error (r a b : ℕ) {d : ℝ} | |
| (hd : |(b : ℝ) - a| ≤ d) (hdr : d ≤ r) : a ≤ r + b ∧ b ≤ r + a := by | |
| have h := abs_le.mp hd | |
| constructor | |
| · have he : (a : ℝ) ≤ r + b := by linarith | |
| exact_mod_cast he | |
| · have he : (b : ℝ) ≤ r + a := by linarith | |
| exact_mod_cast he | |
| theorem weighted_parent_allocation_bound (side : Bool) (r a b : ℕ) | |
| (ha : a ≤ r + b) (hb : b ≤ r + a) {A B e : ℝ} | |
| (hA : |(a : ℝ) - A| ≤ e) (hB : |(b : ℝ) - B| ≤ e) : | |
| (if side then B else A) + (allocateSide side r a b : ℝ) ≤ | |
| (r : ℝ) / 2 + (A + B) / 2 + e + 1 := by | |
| have h := (abs_lt.mp (allocateSide_error side r a b ha hb hA hB)).2 | |
| cases side <;> simp only [idealSide, Bool.false_eq_true, ↓reduceIte] at h ⊢ <;> linarith | |
| theorem allocation_three_levels_feasible (r : ℕ) (a b : Fin 3 → ℕ) {d : ℝ} | |
| (hd0 : 0 ≤ d) (hd : ∀ j, |(b j : ℝ) - a j| ≤ d) (hr : 3 * d + 2 ≤ r) : | |
| (a 0 ≤ r + b 0 ∧ b 0 ≤ r + a 0) ∧ | |
| ∀ j : Fin 2, a j.succ ≤ allocateSide (j != 0) r (a 0) (b 0) + b j.succ ∧ | |
| b j.succ ≤ allocateSide (j != 0) r (a 0) (b 0) + a j.succ := by | |
| have hdr : d ≤ r := by linarith | |
| have hbase := allocation_guards_of_error r (a 0) (b 0) (hd 0) hdr | |
| have hparents := allocated_sides_lower r (a 0) (b 0) (hd 0) hdr | |
| refine ⟨hbase, fun j => ?_⟩ | |
| apply allocation_guards_of_error _ _ _ (hd j.succ) | |
| fin_cases j | |
| · change d ≤ (allocateLeft r (a 0) (b 0) : ℝ) | |
| linarith [hparents.1] | |
| · change d ≤ (allocateRight r (a 0) (b 0) : ℝ) | |
| linarith [hparents.2] | |
| theorem representationAllocation_feasible {n : ℕ} (g : Guesses n) (hn : 10000 ≤ n) | |
| (hlog : Real.logb 2 ((mixerSize n : ℝ) + 1) + 1 ≤ (n : ℝ) / 1000) : | |
| (representationBits n g false 0 ≤ representationBackgroundSize n + | |
| representationBits n g true 0 ∧ | |
| representationBits n g true 0 ≤ representationBackgroundSize n + | |
| representationBits n g false 0) ∧ | |
| ∀ j : Fin 2, representationBits n g false j.succ ≤ | |
| representationParentSize n g j + representationBits n g true j.succ ∧ | |
| representationBits n g true j.succ ≤ | |
| representationParentSize n g j + representationBits n g false j.succ := by | |
| have hm : 0 < mixerSize n := by unfold mixerSize; omega | |
| have hmbound := (mixerSize_bounds n).2 | |
| have hthreeR : (3 : ℝ) * mixerSize n ≤ n := by linarith | |
| have hthree : 3 * mixerSize n ≤ n := by exact_mod_cast hthreeR | |
| have hr : (representationBackgroundSize n : ℝ) = n - 3 * (mixerSize n : ℝ) := by | |
| simp only [representationBackgroundSize, Nat.cast_sub hthree, Nat.cast_mul, Nat.cast_ofNat] | |
| let d : ℝ := (3 / 8 : ℝ) * mixerSize n + | |
| 2 * (Real.logb 2 ((mixerSize n : ℝ) + 1) + 1) | |
| have hd : ∀ j, |(representationBits n g true j : ℝ) - representationBits n g false j| ≤ d := | |
| fun j => (representationBits_difference g hm j).le | |
| have hd0 : 0 ≤ d := (abs_nonneg _).trans (hd 0) | |
| have hmargin : 3 * d + 2 ≤ (representationBackgroundSize n : ℝ) := by | |
| have hnR : (10000 : ℝ) ≤ n := by exact_mod_cast hn | |
| dsimp only [d] | |
| rw [hr] | |
| linarith | |
| exact allocation_three_levels_feasible (representationBackgroundSize n) | |
| (representationBits n g false) (representationBits n g true) hd0 hd hmargin | |
| theorem representationLeafCounts_sum {n : ℕ} (g : Guesses n) (hn : 10000 ≤ n) | |
| (hlog : Real.logb 2 ((mixerSize n : ℝ) + 1) + 1 ≤ (n : ℝ) / 1000) : | |
| ∑ i, representationLeafCounts n g i = representationBackgroundSize n := by | |
| obtain ⟨h0, hchildren⟩ := representationAllocation_feasible g hn hlog | |
| exact computedLeafCounts_sum _ _ _ _ _ _ _ h0.1 h0.2 | |
| (hchildren 0).1 (hchildren 0).2 (hchildren 1).1 (hchildren 1).2 | |
| end LowSpaceSubsetSum | |
| end | |
| end OAI | |