File size: 8,259 Bytes
5d5048e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 | 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
|