math / data /lean /OAI /Computability /PerfectCompleteness /Repetition /RepetitionRateLemmas.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
12.1 kB
import OAI.Computability.PerfectCompleteness.Foundations.FiniteProduct
import OAI.Computability.PerfectCompleteness.Reduction.OccurrenceGame
import OAI.Computability.UniqueGames.Foundations.SamplingLemmas
import OAI.Computability.UniqueGames.Games.CompletedSamplingLemmas
import OAI.Computability.UniqueGames.Soundness.PartnerLinearLemmas
namespace OAI
namespace PerfectCompleteness.RepetitionRate
open scoped BigOperators
open UniqueGamesTheorem.Foundations Games
def halfRate (L : Nat) : β„š := 1 - 1 / (48000 * (L : β„š))
theorem halfRate_bounds {L : Nat} (hL : 0 < L) :
0 < halfRate L ∧ halfRate L < 1 := by
have hLq : (1 : β„š) ≀ L := by exact_mod_cast hL
have hden : (0 : β„š) < 48000 * L := by positivity
have hpos : (0 : β„š) < 1 / (48000 * L) := div_pos zero_lt_one hden
have hlt : (1 : β„š) / (48000 * L) < 1 :=
(div_lt_one hden).2 (by linarith)
constructor <;> unfold halfRate <;> linarith
theorem halfRate_cast (L : Nat) :
(halfRate L : ℝ) = 1 - 1 / (48000 * (L : ℝ)) := by
simp only [halfRate, Rat.cast_sub, Rat.cast_one, Rat.cast_div,
Rat.cast_mul, Rat.cast_ofNat, Rat.cast_natCast]
theorem halfRate_power_comparison {L : Nat} (hL : 0 < L) :
(1 - 1 / 48000 : ℝ) ≀ (halfRate L : ℝ) ^ L := by
have hLr : (1 : ℝ) ≀ L := by exact_mod_cast hL
have hLpos : (0 : ℝ) < L := by exact_mod_cast hL
have hden : (0 : ℝ) < 48000 * L := by positivity
have hfrac : (1 : ℝ) / (48000 * L) ≀ 1 :=
(div_le_one hden).2 (by linarith)
have h := one_add_mul_le_pow
(a := -((1 : ℝ) / (48000 * L))) (by linarith :
(-2 : ℝ) ≀ -((1 : ℝ) / (48000 * L))) L
rw [halfRate_cast]
calc
(1 - 1 / 48000 : ℝ) =
1 + (L : ℝ) * (-((1 : ℝ) / (48000 * L))) := by
field_simp [ne_of_gt hLpos]
ring
_ ≀ (1 + -((1 : ℝ) / (48000 * L))) ^ L := h
_ = (1 - 1 / (48000 * (L : ℝ))) ^ L := by rw [sub_eq_add_neg]
theorem halfRate_rpow_comparison {L : Nat} (hL : 0 < L) (n : Nat) :
(1 - 1 / 48000 : ℝ) ^ ((n : ℝ) / L) ≀ (halfRate L : ℝ) ^ n := by
have hLpos : (0 : ℝ) < L := by exact_mod_cast hL
have hr : (0 : ℝ) ≀ halfRate L := by
exact_mod_cast (halfRate_bounds hL).1.le
calc
_ ≀ ((halfRate L : ℝ) ^ L) ^ ((n : ℝ) / L) :=
Real.rpow_le_rpow (by norm_num) (halfRate_power_comparison hL) (by positivity)
_ = (halfRate L : ℝ) ^ ((L : ℝ) * ((n : ℝ) / L)) :=
(Real.rpow_natCast_mul hr L ((n : ℝ) / L)).symm
_ = (halfRate L : ℝ) ^ (n : ℝ) := by
congr 1
field_simp [ne_of_gt hLpos]
_ = (halfRate L : ℝ) ^ n := Real.rpow_natCast _ _
theorem game_repetition_halfRate {Q₁ Qβ‚‚ A₁ Aβ‚‚ : Type*}
[Fintype Q₁] [Fintype Qβ‚‚] [Fintype A₁] [Fintype Aβ‚‚]
[Nonempty A₁] [Nonempty Aβ‚‚] [DecidableEq Q₁] [DecidableEq Qβ‚‚]
(G : Game Q₁ Qβ‚‚ A₁ Aβ‚‚) {L : Nat} (hL : 0 < L)
(halphabet : Repetition.logTwo
((Fintype.card A₁ : ℝ) * (Fintype.card Aβ‚‚ : ℝ)) ≀ L)
(hvalue : G.value ≀ 1 / 2) (n : Nat) :
(G.repetition n).value ≀ (halfRate L : ℝ) ^ n := by
have hell : (1 : ℝ) ≀ L := by exact_mod_cast hL
have h := Repetition.holenstein_repetition_value G n hvalue
(by norm_num : (1 / 2 : ℝ) < 1) hell halphabet
have hbase : (1 - (1 - (1 / 2 : ℝ)) ^ 3 / 6000) = 1 - 1 / 48000 := by
norm_num
rw [hbase] at h
exact h.trans (halfRate_rpow_comparison hL n)
theorem occurrence_repetition_halfRate {E Q₁ Qβ‚‚ A₁ Aβ‚‚ : Type*}
[Fintype E] [Fintype Q₁] [Fintype Qβ‚‚] [Fintype A₁] [Fintype Aβ‚‚]
[Nonempty A₁] [Nonempty Aβ‚‚] [DecidableEq Q₁] [DecidableEq Qβ‚‚]
(G : OccurrenceGame E Q₁ Qβ‚‚ A₁ Aβ‚‚) (p : G.EndpointPresentation)
{L : Nat} (hL : 0 < L)
(halphabet : Repetition.logTwo
((Fintype.card A₁ : ℝ) * (Fintype.card Aβ‚‚ : ℝ)) ≀ L)
(hvalue : G.value ≀ 1 / 2) (n : Nat) :
(G.repetition n).value ≀ (halfRate L : ℝ) ^ n := by
have hv : (G.toGame p).value ≀ 1 / 2 := by
simpa only [G.toGame_value p] using hvalue
have h := game_repetition_halfRate (G.toGame p) hL halphabet hv n
simpa only [G.toGame_repetition_value p n] using h
noncomputable section
def bernoulli (p : ℝ) (hp : 0 ≀ p) (hp' : p ≀ 1) : FiniteDistribution Bool where
weight b := if b = true then p else 1 - p
nonnegative b := by
cases b
Β· simpa using sub_nonneg.mpr hp'
Β· simpa using hp
normalized := by simp
def cleanCount {n : Nat} (mask : Fin n β†’ Bool) : Nat :=
(Finset.univ.filter fun i => mask i = true).card
theorem pow_cleanCount_eq_prod {n : Nat} (a : ℝ) (mask : Fin n β†’ Bool) :
a ^ cleanCount mask = ∏ i, if mask i = true then a else 1 := by
rw [← Finset.prod_filter]
simp [cleanCount]
theorem cleanMask_moment (p : ℝ) (hp : 0 ≀ p) (hp' : p ≀ 1)
(a : ℝ) (n : Nat) :
((bernoulli p hp hp').iid n).expectation (fun mask => a ^ cleanCount mask) =
(1 - p * (1 - a)) ^ n := by
unfold FiniteDistribution.expectation FiniteDistribution.iid
simp_rw [pow_cleanCount_eq_prod, ← Finset.prod_mul_distrib]
rw [← Fintype.sum_pow
(fun b : Bool => (bernoulli p hp hp').weight b * (if b = true then a else 1)) n]
congr 1
simp [bernoulli]
ring
end
theorem cube_decay_bound {c : β„š} (hc : 0 ≀ c) (hc' : c ≀ 1)
{m : Nat} (hm : 0 < m) :
(1 - c / (m : β„š) ^ 2) ^ (m ^ 3) ≀ 1 / (1 + c * m) := by
have hmone : (1 : β„š) ≀ m := by exact_mod_cast hm
have hmpos : (0 : β„š) < m := by exact_mod_cast hm
have hmsq : (1 : β„š) ≀ (m : β„š) ^ 2 := by nlinarith
have hsqpos : (0 : β„š) < (m : β„š) ^ 2 := pow_pos hmpos _
have hfrac0 : (0 : β„š) ≀ c / (m : β„š) ^ 2 := div_nonneg hc hsqpos.le
have hfrac1 : c / (m : β„š) ^ 2 ≀ 1 := (div_le_one hsqpos).2 (hc'.trans hmsq)
have h := UniqueGamesTheorem.Soundness.RepetitionUpper.power_mul_growth_le_one
(1 - c / (m : β„š) ^ 2) (by linarith) (by linarith) (m ^ 3)
have hfactor : 1 + ((m ^ 3 : Nat) : β„š) * (1 - (1 - c / (m : β„š) ^ 2)) =
1 + c * m := by
push_cast
field_simp [ne_of_gt hmpos]
ring
rw [hfactor] at h
have hden : (0 : β„š) < 1 + c * m := by positivity
exact (le_div_iffβ‚€ hden).2 h
theorem exists_cube_decay_lt {c threshold : β„š}
(hc : 0 < c) (hc' : c ≀ 1) (hthreshold : 0 < threshold) :
βˆƒ m : Nat, 0 < m ∧
(1 - c / (m : β„š) ^ 2) ^ (m ^ 3) < threshold := by
obtain ⟨m, hm, hlarge⟩ :=
UniqueGamesTheorem.Soundness.RepetitionUpper.exists_pos_nat_gt (1 / (c * threshold))
refine ⟨m, hm, (cube_decay_bound hc.le hc' hm).trans_lt ?_⟩
have hlarge' : (1 : β„š) < (m : β„š) * (c * threshold) :=
(div_lt_iffβ‚€ (mul_pos hc hthreshold)).1 hlarge
have hden : (0 : β„š) < 1 + c * m := by positivity
apply (div_lt_iffβ‚€ hden).2
nlinarith
theorem exists_clean_branching {L : Nat} (hL : 0 < L) {p0 threshold : β„š}
(hp0 : 0 < p0) (hp0' : p0 ≀ 1) (hthreshold : 0 < threshold) :
βˆƒ m : Nat, 0 < m ∧
(1 - ((1 - halfRate L) * p0) / (m : β„š) ^ 2) ^ (m ^ 3) < threshold := by
have hr := halfRate_bounds hL
have hc : (0 : β„š) < (1 - halfRate L) * p0 :=
mul_pos (sub_pos.mpr hr.2) hp0
have hc' : (1 - halfRate L) * p0 ≀ 1 := by
have h := mul_le_mul_of_nonneg_left hp0' (sub_nonneg.mpr hr.2.le)
nlinarith
exact exists_cube_decay_lt hc hc' hthreshold
end PerfectCompleteness.RepetitionRate
namespace PerfectCompleteness.IndexedRepetition
open UniqueGamesTheorem.Foundations.Games
open FiniteProduct
noncomputable section
variable {E Q₁ Qβ‚‚ A₁ Aβ‚‚ : Type*}
[Fintype E] [Fintype Q₁] [Fintype Qβ‚‚] [Fintype A₁] [Fintype Aβ‚‚]
def game (G : OccurrenceGame E Q₁ Qβ‚‚ A₁ Aβ‚‚) (I : Type*)
[Fintype I] [DecidableEq I] :
OccurrenceGame (I β†’ E) (I β†’ Q₁) (I β†’ Qβ‚‚) (I β†’ A₁) (I β†’ Aβ‚‚) := by
classical
exact
{ occurrences := law (fun _ : I => G.occurrences)
left := fun x i => G.left (x i)
right := fun x i => G.right (x i)
accepts := fun x a b => decide (βˆ€ i, G.accepts (x i) (a i) (b i) = true) }
def reindexStrategy {I J : Type*} (e : J ≃ I)
(s : Strategy (I β†’ Q₁) (I β†’ Qβ‚‚) (I β†’ A₁) (I β†’ Aβ‚‚)) :
Strategy (J β†’ Q₁) (J β†’ Qβ‚‚) (J β†’ A₁) (J β†’ Aβ‚‚) :=
(fun x j => s.1 (x ∘ e.symm) (e j),
fun y j => s.2 (y ∘ e.symm) (e j))
theorem law_const_fin (ΞΌ : FiniteDistribution E) (n : Nat) :
law (fun _ : Fin n => ΞΌ) = ΞΌ.iid n := by
apply FiniteDistribution.eq_of_weight_eq
intro x
rfl
theorem game_fin (G : OccurrenceGame E Q₁ Qβ‚‚ A₁ Aβ‚‚) (n : Nat) :
game G (Fin n) = G.repetition n := by
unfold game OccurrenceGame.repetition
simp only [law_const_fin]
congr 1
funext x a b
by_cases h : βˆ€ i : Fin n, G.accepts (x i) (a i) (b i) = true <;>
simp only [h, decide_false]
theorem reindex_law {I J : Type*} [Fintype I] [Fintype J]
[DecidableEq I] [DecidableEq J]
(ΞΌ : FiniteDistribution E) (e : J ≃ I) :
(law (fun _ : I => μ)).pushforward (fun x => x ∘ e) =
law (fun _ : J => ΞΌ) :=
FiniteDistribution.table_const_reindex ΞΌ e
theorem reindex_success {I J : Type*} [Fintype I] [Fintype J]
[DecidableEq I] [DecidableEq J]
(G : OccurrenceGame E Q₁ Qβ‚‚ A₁ Aβ‚‚) (e : J ≃ I)
(s : Strategy (I β†’ Q₁) (I β†’ Qβ‚‚) (I β†’ A₁) (I β†’ Aβ‚‚)) :
(game G J).success (reindexStrategy e s) = (game G I).success s := by
classical
change (law (fun _ : J => G.occurrences)).probability _ =
(law (fun _ : I => G.occurrences)).probability _
rw [← reindex_law G.occurrences e, FiniteDistribution.probability_pushforward]
apply congrArg (law (fun _ : I => G.occurrences)).probability
funext x
have hl : (fun j => G.left ((x ∘ e) j)) ∘ e.symm = fun i => G.left (x i) := by
funext i
simp only [Function.comp_apply, e.apply_symm_apply]
have hr : (fun j => G.right ((x ∘ e) j)) ∘ e.symm = fun i => G.right (x i) := by
funext i
simp only [Function.comp_apply, e.apply_symm_apply]
change decide (βˆ€ j, G.accepts ((x ∘ e) j)
(s.1 ((fun j => G.left ((x ∘ e) j)) ∘ e.symm) (e j))
(s.2 ((fun j => G.right ((x ∘ e) j)) ∘ e.symm) (e j)) = true) =
decide (βˆ€ i, G.accepts (x i)
(s.1 (fun i => G.left (x i)) i) (s.2 (fun i => G.right (x i)) i) = true)
rw [hl, hr]
congr 1
apply propext
constructor
Β· intro h i
simpa only [Function.comp_apply, e.apply_symm_apply] using h (e.symm i)
Β· intro h j
exact h (e j)
theorem success_le_repetition_value {I : Type*} [Fintype I] [DecidableEq I]
[Nonempty A₁] [Nonempty Aβ‚‚]
(G : OccurrenceGame E Q₁ Qβ‚‚ A₁ Aβ‚‚)
(s : Strategy (I β†’ Q₁) (I β†’ Qβ‚‚) (I β†’ A₁) (I β†’ Aβ‚‚)) :
(game G I).success s ≀ (G.repetition (Fintype.card I)).value := by
rw [← reindex_success G (Fintype.equivFin I).symm s, game_fin]
exact (G.repetition (Fintype.card I)).success_le_value _
theorem value_eq_repetition {I : Type*} [Fintype I] [DecidableEq I]
[Nonempty A₁] [Nonempty Aβ‚‚] (G : OccurrenceGame E Q₁ Qβ‚‚ A₁ Aβ‚‚) :
(game G I).value = (G.repetition (Fintype.card I)).value := by
apply le_antisymm
Β· exact ((game G I).value_le_iff _).2 (success_le_repetition_value G)
Β· apply ((G.repetition (Fintype.card I)).value_le_iff _).2
intro s
have h := reindex_success G (Fintype.equivFin I) s
rw [game_fin] at h
rw [← h]
exact (game G I).success_le_value (reindexStrategy (Fintype.equivFin I) s)
theorem halfRate {I : Type*} [Fintype I] [DecidableEq I]
[Nonempty A₁] [Nonempty Aβ‚‚] [DecidableEq Q₁] [DecidableEq Qβ‚‚]
(G : OccurrenceGame E Q₁ Qβ‚‚ A₁ Aβ‚‚) (p : G.EndpointPresentation)
{L : Nat} (hL : 0 < L)
(alphabet : UniqueGamesTheorem.Foundations.Repetition.logTwo
((Fintype.card A₁ : ℝ) * (Fintype.card Aβ‚‚ : ℝ)) ≀ L)
(gap : G.value ≀ 1 / 2) :
(game G I).value ≀ (RepetitionRate.halfRate L : ℝ) ^ Fintype.card I := by
rw [value_eq_repetition]
exact RepetitionRate.occurrence_repetition_halfRate G p hL alphabet gap _
end
end PerfectCompleteness.IndexedRepetition
end OAI