math / data /lean /OAI /Combinatorics /LowSpaceSubsetSum /Storage /LeafAllocationBounds.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
4.03 kB
import OAI.Combinatorics.LowSpaceSubsetSum.Storage.BackgroundAllocation
import OAI.Combinatorics.LowSpaceSubsetSum.Representation.RepresentationResourceBounds
namespace OAI
/-! # Quantitative leaf entropy after both integer allocations -/
namespace LowSpaceSubsetSum
/-- A Boolean selects the two complementary allocations without changing the
fixed remainder convention. -/
def allocateSide (right : Bool) (r a b : β„•) : β„• :=
if right then allocateRight r a b else allocateLeft r a b
noncomputable def idealSide (right : Bool) (r A B : ℝ) : ℝ :=
if right then r / 2 + (A - B) / 2 else r / 2 + (B - A) / 2
theorem allocateSide_error (side : Bool) (r a b : β„•)
(ha : a ≀ r + b) (hb : b ≀ r + a) {A B e : ℝ}
(hA : |(a : ℝ) - A| ≀ e) (hB : |(b : ℝ) - B| ≀ e) :
|(allocateSide side r a b : ℝ) - idealSide side r A B| < e + 1 := by
cases side
Β· exact allocateLeft_entropy_error r a b ha hA hB
Β· exact allocateRight_entropy_error r a b ha hb hA hB
/-- The error of a two-level allocation followed by the leaf split is small
uniformly in the parent/child orientations. -/
theorem allocated_leaf_entropy_bound (parent child : Bool) (leaf : Fin 2)
(r a0 b0 a1 b1 : β„•) {A0 B0 A1 B1 e : ℝ}
(h0a : a0 ≀ r + b0) (h0b : b0 ≀ r + a0)
(h1a : a1 ≀ allocateSide parent r a0 b0 + b1)
(h1b : b1 ≀ allocateSide parent r a0 b0 + a1)
(hA0 : |(a0 : ℝ) - A0| ≀ e) (hB0 : |(b0 : ℝ) - B0| ≀ e)
(hA1 : |(a1 : ℝ) - A1| ≀ e) (hB1 : |(b1 : ℝ) - B1| ≀ e)
{top localPart : ℝ}
(htop : top ≀ (if parent then B0 else A0) / 4 + 3)
(hlocal : localPart ≀ (if child then B1 else A1) / 2 + 3) :
top + localPart + (leafBackgroundSize
(allocateSide child (allocateSide parent r a0 b0) a1 b1) leaf : ℝ) ≀
(r : ℝ) / 8 + (A0 + B0) / 8 + (A1 + B1) / 4 + 3 / 4 * e + 29 / 4 := by
have hP := abs_lt.mp (allocateSide_error parent r a0 b0 h0a h0b hA0 hB0)
have hC := abs_lt.mp (allocateSide_error child (allocateSide parent r a0 b0)
a1 b1 h1a h1b hA1 hB1)
have hF := (abs_le.mp (leafBackgroundSize_error
(allocateSide child (allocateSide parent r a0 b0) a1 b1) leaf)).2
cases parent <;> cases child <;> simp only [idealSide, Bool.false_eq_true,
↓reduceIte] at hP hC htop hlocal <;> linarith
/-- Once the input scale dominates the domain size, the ten-power leaf cap
absorbs the explicit allocation and rounding errors. -/
theorem allocated_leaf_error_absorbed {u m : ℝ} (hu : 2 ≀ u) (hm : 0 ≀ m)
(hmu : m + 1 ≀ u) :
(3 / 4 : ℝ) * (Real.logb 2 (m + 1) + 1) + 29 / 4 ≀ Real.logb 2 (u ^ 10) := by
have hu0 : 0 < u := by linarith
have huLog : 1 ≀ Real.logb 2 u := by
simpa using Real.logb_le_logb_of_le (by norm_num : (1 : ℝ) < 2)
(by norm_num : (0 : ℝ) < 2) hu
have hmLog := Real.logb_le_logb_of_le (by norm_num : (1 : ℝ) < 2)
(by linarith : 0 < m + 1) hmu
rw [Real.logb_pow]
norm_num
linarith
/-- A prescribed integer count within one of its ideal count changes its
weighted entropy by at most three. -/
theorem rounded_leaf_component {b : β„•} {k p : ℝ} (hb : 24 ≀ b)
(hp : p ∈ Set.Icc (1 / 6) (1 / 3)) (hk : |k - (b : ℝ) * p| ≀ 1) :
(b : ℝ) * binaryEntropy (k / b) ≀ (b : ℝ) * binaryEntropy p + 3 := by
have hbR : (24 : ℝ) ≀ b := by exact_mod_cast hb
have hb0 : (0 : ℝ) < b := by linarith
have herr := abs_le.mp hk
have hfrac : k / b ∈ Set.Icc (1 / 8) (7 / 8) := by
constructor
Β· apply (le_div_iffβ‚€ hb0).mpr
nlinarith [mul_le_mul_of_nonneg_left hp.1 hb0.le]
Β· apply (div_le_iffβ‚€ hb0).mpr
nlinarith [mul_le_mul_of_nonneg_left hp.2 hb0.le]
have h := weighted_binaryEntropy_error hb0.le hfrac
(show p ∈ Set.Icc (1 / 8) (7 / 8) by constructor <;> linarith [hp.1, hp.2])
(b := (b : ℝ))
have hcancel : (b : ℝ) * (k / b) = k := by field_simp
rw [hcancel, sub_self, abs_zero, mul_zero, add_zero] at h
have hupper := (abs_le.mp h).2
linarith
end LowSpaceSubsetSum
end OAI