math / data /lean /OAI /Computability /MeanPayoff /BitDepth.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
12.7 kB
import OAI.Computability.MeanPayoff.InputSize
namespace OAI
section
namespace MeanPayoff
namespace RandomTree
open scoped Classical
def bitDepth {α : Type} : RandomTree α → ℕ
| .leaf _ => 0
| .coin l r => max l.bitDepth r.bitDepth + 1
def read {α : Type} : RandomTree α → (ℕ → Bool) → α
| .leaf a, _ => a
| .coin l r, bits => if bits 0 then r.read (fun i => bits (i + 1))
else l.read (fun i => bits (i + 1))
def readPrefix {α : Type} (t : RandomTree α) {T : ℕ} (bits : Fin T → Bool) : α :=
t.read (padBits bits)
@[simp] theorem padBits_cons_zero {T : ℕ} (b : Bool) (bits : Fin T → Bool) :
padBits (Fin.cons b bits) 0 = b := by simp [padBits]
@[simp] theorem padBits_cons_succ {T : ℕ} (b : Bool) (bits : Fin T → Bool) (j : ℕ) :
padBits (Fin.cons b bits) (j + 1) = padBits bits j := by
by_cases h : j < T
· simp only [padBits, Nat.add_lt_add_iff_right, h, ↓reduceDIte]
rfl
· simp only [padBits, Nat.add_lt_add_iff_right, h, ↓reduceDIte]
@[simp] theorem readPrefix_leaf {α : Type} (a : α) {T : ℕ} (bits : Fin T → Bool) :
readPrefix (.leaf a) bits = a := rfl
@[simp] theorem readPrefix_coin_cons {α : Type} (l r : RandomTree α) {T : ℕ}
(b : Bool) (bits : Fin T → Bool) :
readPrefix (.coin l r) (Fin.cons b bits) =
if b then readPrefix r bits else readPrefix l bits := by
simp only [readPrefix, read, padBits_cons_zero, padBits_cons_succ]
theorem prefix_sum {α : Type} (t : RandomTree α) (f : α → ℚ) (T : ℕ)
(hT : t.bitDepth ≤ T) :
∑ bits : Fin T → Bool, f (t.readPrefix bits) = (2 : ℚ) ^ T * t.expect f := by
induction T generalizing t with
| zero =>
cases t with
| leaf a => simp [expect]
| coin l r => simp [bitDepth] at hT
| succ T ih =>
cases t with
| leaf a => simp [expect]
| coin l r =>
have hl : l.bitDepth ≤ T := by simp only [bitDepth] at hT; omega
have hr : r.bitDepth ≤ T := by simp only [bitDepth] at hT; omega
have he := Equiv.sum_comp (Fin.consEquiv (fun _ : Fin (T + 1) => Bool))
(fun bits => f ((coin l r).readPrefix bits))
rw [← he, Fintype.sum_prod_type]
simp only [Fin.consEquiv, Equiv.coe_fn_mk, readPrefix_coin_cons]
rw [Fintype.sum_bool]
simp only [Bool.false_eq_true, ↓reduceIte]
rw [ih l hl, ih r hr]
simp only [expect, pow_succ]
ring
theorem prefix_probability {α : Type} (t : RandomTree α) (P : α → Prop) (T : ℕ)
(hT : t.bitDepth ≤ T) :
((Finset.univ.filter (fun bits : Fin T → Bool => P (t.readPrefix bits))).card : ℚ) =
(2 : ℚ) ^ T * t.probability P := by
classical
have h := prefix_sum t (fun a => if P a then (1 : ℚ) else 0) T hT
simpa only [probability, Finset.sum_boole] using h
theorem game_prefix_success (G : Game) (T : ℕ) (hT : (gameSolve G).bitDepth ≤ T) :
7 * 2 ^ T ≤ 8 * (Finset.univ.filter
(fun bits : Fin T → Bool => CorrectSet G ((gameSolve G).readPrefix bits))).card := by
classical
have hp := prefix_probability (gameSolve G) (CorrectSet G) T hT
have hs := gameSolve_success G
have hh := mul_le_mul_of_nonneg_left hs (by positivity : (0 : ℚ) ≤ 2 ^ T)
rw [← hp] at hh
have hh' : (7 : ℚ) * 2 ^ T ≤ 8 * (Finset.univ.filter
(fun bits : Fin T → Bool => CorrectSet G ((gameSolve G).readPrefix bits))).card := by
linarith only [hh]
exact_mod_cast hh'
end RandomTree
end MeanPayoff
namespace MeanPayoff
noncomputable def rootInvocationBound (G : Game) : ℕ :=
callBound G.n (topWidth G).toNat (parameterRank (rootBudgets G).parameter)
theorem rootInvocationBound_nat (G : Game) :
rootInvocationBound G ≤ 2 ^ (24000 * (Nat.clog 2 ((input G).length + 2)) ^ 2) := by
let h := Nat.clog 2 ((input G).length + 2)
let X := inputScale G
have hh : 1 ≤ h := by
apply (Nat.lt_clog_iff_pow_lt (by norm_num : 1 < 2)).mpr
simp only [pow_zero]
omega
have hn := input_n_le G
have hr := rootRank_bound G
have hclog : Nat.clog 2 (G.n + 1) ≤ h :=
Nat.clog_mono_right (b := 2) (by omega)
have hrank : parameterRank (rootBudgets G).parameter + 1 ≤ 25 * h := by omega
have hc := callBase_scale (inputScale_large G) (inputScale_n G) (inputScale_g G)
(inputScale_s G) (inputScale_log G)
have hx : X ≤ 2 ^ (24 + h) := by
have hp := Nat.le_pow_clog (by norm_num : 1 < 2) ((input G).length + 2)
have hm := Nat.mul_le_mul_left (2 ^ 24) hp
simpa only [X, inputScale, pow_add] using hm
have hx37 := Nat.pow_le_pow_left hx 37
have hcall : callBase G.n (topWidth G).toNat ≤ 2 ^ ((24 + h) * 37) := by
exact hc.trans (by simpa only [← pow_mul] using hx37)
have hp := Nat.pow_le_pow_left hcall (parameterRank (rootBudgets G).parameter + 1)
have he : (24 + h) * 37 * (parameterRank (rootBudgets G).parameter + 1) ≤ 24000 * h ^ 2 := by
have h24 : 24 + h ≤ 25 * h := by omega
have hm := Nat.mul_le_mul (Nat.mul_le_mul_right 37 h24) hrank
nlinarith only [hm]
unfold rootInvocationBound callBound
exact hp.trans (by rw [← pow_mul]; exact Nat.pow_le_pow_right (by norm_num) he)
theorem clog_real_le_twice_logb (L : ℕ) :
(Nat.clog 2 (L + 2) : ℝ) ≤ 2 * Real.logb 2 (L + 2) := by
have hpos : (0 : ℝ) < L + 2 := by positivity
have hlog : (1 : ℝ) ≤ Real.logb 2 (L + 2) := by
apply (Real.le_logb_iff_rpow_le (by norm_num : (1 : ℝ) < 2) hpos).mpr
simp only [Real.rpow_one]
linarith only [show (0 : ℝ) ≤ L from Nat.cast_nonneg L]
have hceil := Nat.ceil_lt_add_one (by linarith : (0 : ℝ) ≤ Real.logb 2 (L + 2))
have he : ⌈Real.logb 2 (L + 2)⌉₊ = Nat.clog 2 (L + 2) := by
simpa only [Nat.cast_add, Nat.cast_ofNat] using Real.natCeil_logb_natCast 2 (L + 2)
rw [he] at hceil
linarith only [hceil, hlog]
theorem rootInvocationBound_real (G : Game) :
(rootInvocationBound G : ℝ) ≤
(2 : ℝ) ^ (100000 * (Real.logb 2 ((input G).length + 2)) ^ 2) := by
have hnat := rootInvocationBound_nat G
have hcast : (rootInvocationBound G : ℝ) ≤
(2 : ℝ) ^ (24000 * (Nat.clog 2 ((input G).length + 2)) ^ 2) := by exact_mod_cast hnat
have hc := clog_real_le_twice_logb (input G).length
have hc0 : (0 : ℝ) ≤ (Nat.clog 2 ((input G).length + 2) : ℝ) := Nat.cast_nonneg _
have hl0 : 0 ≤ Real.logb 2 ((input G).length + 2) := by linarith only [hc, hc0]
have hs : 24000 * ((Nat.clog 2 ((input G).length + 2) : ℝ)) ^ 2 ≤
100000 * (Real.logb 2 ((input G).length + 2)) ^ 2 := by nlinarith only [hc, hc0, hl0]
apply hcast.trans
rw [← Real.rpow_natCast]
apply Real.rpow_le_rpow_of_exponent_le (by norm_num : (1 : ℝ) ≤ 2)
simpa only [Nat.cast_mul, Nat.cast_ofNat, Nat.cast_pow] using hs
namespace RandomTree
inductive Path {α : Type} : RandomTree α → α → ℕ → Prop
| leaf (a) : Path (.leaf a) a 0
| left {l r a d} : Path l a d → Path (.coin l r) a (d + 1)
| right {l r a d} : Path r a d → Path (.coin l r) a (d + 1)
theorem Path.all {α : Type} {t : RandomTree α} {a : α} {d : ℕ}
(h : Path t a d) {P : α → Prop} (hp : t.All P) : P a := by
induction h with
| leaf a => exact hp
| left h ih => exact ih hp.1
| right h ih => exact ih hp.2
theorem Path.depth_le {α : Type} {t : RandomTree α} {a : α} {d : ℕ}
(h : Path t a d) : d ≤ t.bitDepth := by
induction h with
| leaf a => exact le_rfl
| left h ih => dsimp [bitDepth]; omega
| right h ih => dsimp [bitDepth]; omega
theorem depth_attained {α : Type} (t : RandomTree α) : ∃ a, Path t a t.bitDepth := by
induction t with
| leaf a => exact ⟨a, .leaf a⟩
| coin l r il ir =>
obtain ⟨a, ha⟩ := il
obtain ⟨b, hb⟩ := ir
by_cases h : l.bitDepth ≤ r.bitDepth
· exact ⟨b, by simpa only [bitDepth, max_eq_right h] using Path.right (l := l) hb⟩
· exact ⟨a, by simpa only [bitDepth, max_eq_left (le_of_not_ge h)] using Path.left (r := r) ha⟩
theorem path_bind_iff {α β : Type} (t : RandomTree α) (f : α → RandomTree β)
(b : β) (d : ℕ) : Path (t.bind f) b d ↔
∃ a d₁ d₂, Path t a d₁ ∧ Path (f a) b d₂ ∧ d = d₁ + d₂ := by
induction t generalizing d with
| leaf a =>
constructor
· intro h; exact ⟨a, 0, d, .leaf a, h, by omega⟩
· rintro ⟨a', d₁, d₂, h, hf, he⟩
cases h
simpa only [leaf_bind, he, Nat.zero_add] using hf
| coin l r il ir =>
constructor
· intro h
cases h with
| left h =>
obtain ⟨a, d₁, d₂, h₁, h₂, he⟩ := (il _).mp h
exact ⟨a, d₁ + 1, d₂, .left h₁, h₂, by omega⟩
| right h =>
obtain ⟨a, d₁, d₂, h₁, h₂, he⟩ := (ir _).mp h
exact ⟨a, d₁ + 1, d₂, .right h₁, h₂, by omega⟩
· rintro ⟨a, d₁, d₂, h₁, h₂, he⟩
cases h₁ with
| left h =>
subst d
rw [Nat.add_right_comm]
exact .left ((il _).mpr ⟨a, _, d₂, h, h₂, rfl⟩)
| right h =>
subst d
rw [Nat.add_right_comm]
exact .right ((ir _).mpr ⟨a, _, d₂, h, h₂, rfl⟩)
theorem path_map_iff {α β : Type} (t : RandomTree α) (f : α → β) (b : β) (d : ℕ) :
Path (t.map f) b d ↔ ∃ a, Path t a d ∧ f a = b := by
rw [map, path_bind_iff]
constructor
· rintro ⟨a, d₁, d₂, h₁, h₂, he⟩
cases h₂
exact ⟨a, by simpa only [he, Nat.add_zero] using h₁, rfl⟩
· rintro ⟨a, h, rfl⟩
exact ⟨a, d, 0, h, .leaf _, by omega⟩
@[simp] theorem bitDepth_map {α β : Type} (t : RandomTree α) (f : α → β) :
(t.map f).bitDepth = t.bitDepth := by
induction t with
| leaf a => rfl
| coin l r il ir => simpa only [map, bind, bitDepth] using congrArg₂ (fun x y => max x y + 1) il ir
@[simp] theorem bitDepth_uniformBelow (k : ℕ) : (uniformBelow k).bitDepth = k := by
induction k with
| zero => rfl
| succ k ih => simp only [uniformBelow, bitDepth, bitDepth_map, ih, max_self]
end RandomTree
namespace Counted
def Resource {α : Type} (t : Counted α) (K E : ℕ) : Prop :=
∀ p d, RandomTree.Path t.tree p d → d ≤ K * p.2 + E
theorem resource_pure {α : Type} (a : α) (K E : ℕ) : (pure a).Resource K E := by
intro p d h
cases h
exact Nat.zero_le _
theorem resource_mono {α : Type} {t : Counted α} {K E F : ℕ}
(h : t.Resource K E) (hle : E ≤ F) : t.Resource K F := by
intro p d hp
exact (h p d hp).trans (Nat.add_le_add_left hle _)
theorem resource_map {α β : Type} {t : Counted α} (f : α → β) {K E : ℕ}
(h : t.Resource K E) : (t.map f).Resource K E := by
intro p d hp
obtain ⟨q, hq, rfl⟩ := (RandomTree.path_map_iff _ _ _ _).mp hp
exact h q d hq
theorem resource_bind {α β : Type} {t : Counted α} (f : α → Counted β) {K E F : ℕ}
(h : t.Resource K E) (hf : ∀ a, (f a).Resource K F) : (t.bind f).Resource K (E + F) := by
intro p d hp
obtain ⟨q, d₁, d₂, hq, hp', he⟩ := (RandomTree.path_bind_iff _ _ _ _).mp hp
obtain ⟨r, hr, rfl⟩ := (RandomTree.path_map_iff _ _ _ _).mp hp'
have h₁ := h q d₁ hq
have h₂ := hf q.1 r d₂ hr
dsimp only [Prod.snd]
rw [Nat.mul_add]
omega
theorem resource_lift {α : Type} (t : RandomTree α) (K : ℕ) :
(lift t).Resource K t.bitDepth := by
intro p d hp
obtain ⟨a, ha, rfl⟩ := (RandomTree.path_map_iff _ _ _ _).mp hp
simpa using ha.depth_le
theorem resource_charge {α : Type} {t : Counted α} {K : ℕ} (h : t.Resource K K) :
(t.charge 1).Resource K 0 := by
intro p d hp
obtain ⟨q, hq, rfl⟩ := (RandomTree.path_map_iff _ _ _ _).mp hp
have hh := h q d hq
dsimp only [Prod.snd]
rw [Nat.mul_add, Nat.mul_one]
omega
theorem resource_trials {α : Type} {t : Counted α} {K E : ℕ} (h : t.Resource K E) (J : ℕ) :
(trials t J).Resource K (J * E) := by
induction J with
| zero => exact resource_pure _ _ _
| succ J ih =>
simpa only [trials, Nat.succ_mul, Nat.add_comm] using
resource_bind (fun a => (trials t J).map (a :: ·)) h (fun a => resource_map _ ih)
theorem resource_traverse {α β : Type} (f : α → Counted β) {K : ℕ}
(h : ∀ a, (f a).Resource K 0) (as : List α) : (traverse f as).Resource K 0 := by
induction as with
| nil => exact resource_pure _ _ _
| cons a as ih => exact resource_bind _ (h a) (fun _ => resource_map _ ih)
theorem depth_le {α : Type} {t : Counted α} {K E N : ℕ}
(h : t.Resource K E) (hN : t.Bounded N) : t.erase.bitDepth ≤ K * N + E := by
rw [erase, RandomTree.bitDepth_map]
obtain ⟨p, hp⟩ := RandomTree.depth_attained t.tree
exact (h p _ hp).trans (Nat.add_le_add_right (Nat.mul_le_mul_left K (hp.all hN)) E)
end Counted
end MeanPayoff
end
end OAI