File size: 5,255 Bytes
e63eb7f | 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 | import OAI.Combinatorics.EditApproximation.Geometry.BandNumericalBits
import OAI.Combinatorics.EditApproximation.Geometry.BandEnvelopes
namespace OAI
/-! Encoding lengths of the actual finite maxima and dyadic envelopes.
These estimates include the scales below one and require no good seed. -/
namespace EditApproximation
theorem positive_rational_binary_bounds (r : ℚ) (B : ℕ)
(hr : 0 < r) (hbits : rationalEncodingBits r ≤ B) :
(2 : ℚ) ^ (-(B : ℤ)) ≤ r ∧ r ≤ (2 : ℚ) ^ (B : ℤ) := by
have hnumSize : Nat.size r.num.natAbs ≤ B := by unfold rationalEncodingBits at hbits; omega
have hdenSize : Nat.size r.den ≤ B := by unfold rationalEncodingBits at hbits; omega
have hnum : r.num.natAbs ≤ 2 ^ B :=
(Nat.lt_size_self _).le.trans (Nat.pow_le_pow_right (by decide) hnumSize)
have hden : r.den ≤ 2 ^ B :=
(Nat.lt_size_self _).le.trans (Nat.pow_le_pow_right (by decide) hdenSize)
have hnumPos : 0 < r.num := Rat.num_pos.mpr hr
have hnumOne : 1 ≤ r.num.natAbs := Int.natAbs_pos.mpr (ne_of_gt hnumPos)
have hrep : r = (r.num.natAbs : ℚ) / r.den := by
rw [← Int.cast_natCast, Int.natCast_natAbs, abs_of_pos hnumPos]
exact r.num_div_den.symm
have hd : (0 : ℚ) < r.den := by exact_mod_cast r.den_pos
have hp : (0 : ℚ) < (2 : ℚ) ^ B := pow_pos (by norm_num) _
simp only [zpow_neg, zpow_natCast]
rw [hrep]
constructor
· rw [inv_eq_one_div, div_le_div_iff₀ hp hd, one_mul]
exact_mod_cast (hden.trans (Nat.le_mul_of_pos_left _ (by omega : 0 < r.num.natAbs)))
· apply (div_le_iff₀ hd).mpr
exact_mod_cast (hnum.trans (Nat.le_mul_of_pos_right _ r.den_pos))
theorem rationalDyadicCeiling_encoding (r : ℚ) (B : ℕ)
(hr : 0 < r) (hbits : rationalEncodingBits r ≤ B) :
rationalEncodingBits (rationalDyadicCeiling r) ≤ 5 * B + 5 := by
have hrange := positive_rational_binary_bounds r B hr hbits
have hlo := Int.clog_mono_right (b := 2) (zpow_pos (by norm_num : (0 : ℚ) < 2) (-(B : ℤ))) hrange.1
have hhi := Int.clog_mono_right (b := 2) hr hrange.2
have hclog (z : ℤ) : Int.clog 2 ((2 : ℚ) ^ z) = z := by
simpa only [Nat.cast_ofNat] using (Int.clog_zpow (R := ℚ) (b := 2) (by decide) z)
rw [hclog] at hlo hhi
have htwo : rationalEncodingBits (2 : ℚ) = 4 := by
rw [show (2 : ℚ) = (2 : ℕ) by norm_num, rationalEncodingBits_natCast]
rfl
unfold rationalDyadicCeiling
cases he : Int.clog 2 r with
| ofNat n =>
rw [he, Int.ofNat_eq_natCast] at hlo hhi
have hn : n ≤ B := by omega
rw [Int.ofNat_eq_natCast, zpow_natCast]
have h := rationalEncodingBits_pow (2 : ℚ) n
rw [htwo] at h
omega
| negSucc n =>
rw [he, Int.negSucc_eq] at hlo hhi
have hn : n + 1 ≤ B := by omega
rw [zpow_negSucc]
have hp := rationalEncodingBits_pow (2 : ℚ) (n + 1)
have hi := rationalEncodingBits_inv ((2 : ℚ) ^ (n + 1))
rw [htwo] at hp
omega
theorem rationalMaximum_encoding (fallback : ℚ) (values : List ℚ) (B : ℕ)
(hfallback : rationalEncodingBits fallback ≤ B)
(hvalues : ∀ value ∈ values, rationalEncodingBits value ≤ B) :
rationalEncodingBits (rationalMaximum fallback values) ≤ B := by
induction values with
| nil => exact hfallback
| cons value rest ih =>
have hv := hvalues value List.mem_cons_self
have ht := ih (fun q hq => hvalues q (List.mem_cons_of_mem _ hq))
change rationalEncodingBits (max value (rationalMaximum fallback rest)) ≤ B
rcases le_total value (rationalMaximum fallback rest) with h | h
· simpa only [max_eq_right h] using ht
· simpa only [max_eq_left h] using hv
def bandEnvelopeEncodingBudget (M b initialBits : ℕ) : ℕ :=
5 * max (Nat.size b + Nat.size M + 7) (initialBits + 2) + 5
theorem bandChildEnvelope_encoding {ny M : ℕ} (b : ℕ)
(band : List (Fin M → TargetInterval ny))
(initial : Fin M → TargetInterval ny → ℚ) (B : ℕ) (hb : 0 < b) (hM : 0 < M)
(hinitial : ∀ action ∈ band, ∀ i, rationalEncodingBits (initial i (action i)) ≤ B)
(i : Fin M) :
rationalEncodingBits (bandChildEnvelope b band initial i) ≤ bandEnvelopeEncodingBudget M b B := by
have hmax := rationalMaximum_encoding 0 (band.map fun action => initial i (action i)) (B + 2)
(by norm_num [rationalEncodingBits]) (by
intro q hq
obtain ⟨action, ha, rfl⟩ := List.mem_map.mp hq
exact (hinitial action ha i).trans (by omega))
have hfloor := rationalEncodingBits_div (b : ℚ) (M : ℚ)
rw [rationalEncodingBits_natCast, rationalEncodingBits_natCast] at hfloor
have hbits : rationalEncodingBits (max ((b : ℚ) / M)
(rationalMaximum 0 (band.map fun action => initial i (action i)))) ≤
max (Nat.size b + Nat.size M + 7) (B + 2) := by
rcases le_total ((b : ℚ) / M) (rationalMaximum 0 (band.map fun action => initial i (action i))) with h | h
· rw [max_eq_right h]
exact hmax.trans (Nat.le_max_right _ _)
· rw [max_eq_left h]
exact hfloor.trans (by have h := Nat.le_max_left (Nat.size b + Nat.size M + 7) (B + 2); omega)
exact rationalDyadicCeiling_encoding _ _
((div_pos (by exact_mod_cast hb) (by exact_mod_cast hM)).trans_le (le_max_left _ _)) hbits
end EditApproximation
end OAI
|