math / data /lean /OAI /Computability /UniqueGames /Games /Variation.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
5.16 kB
import Mathlib.Data.Fintype.BigOperators
import Mathlib.Tactic.Positivity
import OAI.Computability.UniqueGames.Foundations.SamplingLemmas
namespace OAI
section
/-!
Finite total-variation operations used by the dependency-breaking argument.
All statements concern the displayed real weight functions. In particular,
conditioning rescales actual restricted weights, and kernels act by finite sums.
-/
namespace UniqueGamesTheorem.Foundations.Repetition
open scoped BigOperators
open Information
variable {Ξ± Ξ² : Type*} [Fintype Ξ±] [Fintype Ξ²]
theorem totalVariation_triangle (p q r : Ξ± β†’ ℝ) :
totalVariation p r ≀ totalVariation p q + totalVariation q r := by
have hpoint : βˆ€ a, |p a - r a| ≀ |p a - q a| + |q a - r a| := by
intro a
have := abs_add_le (p a - q a) (q a - r a)
simpa only [sub_add_sub_cancel] using this
have hsum := Finset.sum_le_sum (fun a (_ : a ∈ (Finset.univ : Finset α)) => hpoint a)
simp only [Finset.sum_add_distrib] at hsum
unfold totalVariation
linarith
/-- The actual weights obtained by restricting to an event and normalizing. -/
noncomputable def conditionWeights (p : Ξ± β†’ ℝ) (event : Ξ± β†’ Bool) (z : ℝ) : Ξ± β†’ ℝ :=
fun a => if event a then p a / z else 0
theorem conditionWeights_isProbability (p : Ξ± β†’ ℝ) (hp : IsProbability p)
(event : Ξ± β†’ Bool) {z : ℝ} (hz : 0 < z)
(hmass : βˆ‘ a, (if event a then p a else 0) = z) :
IsProbability (conditionWeights p event z) := by
constructor
Β· intro a
dsimp [conditionWeights]
split
Β· exact div_nonneg (hp.1 a) hz.le
Β· exact le_rfl
Β· have hpoint : βˆ€ a, conditionWeights p event z a =
(if event a then p a else 0) / z := by
intro a
simp only [conditionWeights]
split <;> simp
simp only [hpoint, div_eq_mul_inv, ← Finset.sum_mul, hmass, mul_inv_cancelβ‚€ hz.ne']
/-- Conditioning two laws on the same event of equal positive mass costs at
most the inverse mass. The algebraic estimate itself needs no normalization. -/
theorem totalVariation_condition_le (p q : Ξ± β†’ ℝ) (event : Ξ± β†’ Bool)
{z : ℝ} (hz : 0 < z) :
totalVariation (conditionWeights p event z) (conditionWeights q event z) ≀
totalVariation p q / z := by
have hpoint : βˆ€ a,
|conditionWeights p event z a - conditionWeights q event z a| ≀
|p a - q a| / z := by
intro a
dsimp [conditionWeights]
split
Β· rw [← sub_div, abs_div, abs_of_pos hz]
Β· simp only [sub_self, abs_zero]
positivity
have hsum := Finset.sum_le_sum (fun a (_ : a ∈ (Finset.univ : Finset α)) => hpoint a)
simp only [div_eq_mul_inv, ← Finset.sum_mul] at hsum
have hsum' : (βˆ‘ a, |conditionWeights p event z a - conditionWeights q event z a|) ≀
(βˆ‘ a, |p a - q a|) / z := by
simpa only [div_eq_mul_inv] using hsum
unfold totalVariation
calc
_ ≀ (βˆ‘ a, |p a - q a|) / z / 2 := div_le_div_of_nonneg_right hsum' (by norm_num)
_ = _ := by ring
theorem totalVariation_condition_half_le (p q : Ξ± β†’ ℝ) (event : Ξ± β†’ Bool) :
totalVariation (conditionWeights p event (1 / 2))
(conditionWeights q event (1 / 2)) ≀ 2 * totalVariation p q := by
have h := totalVariation_condition_le p q event (z := 1 / 2) (by norm_num)
convert h using 1
ring
/-- Appending the same conditional kernel preserves total variation exactly. -/
theorem totalVariation_append_kernel (p q : Ξ± β†’ ℝ) (kernel : Ξ± β†’ Ξ² β†’ ℝ)
(hk : βˆ€ a, IsProbability (kernel a)) :
totalVariation (fun ab : Ξ± Γ— Ξ² => p ab.1 * kernel ab.1 ab.2)
(fun ab : Ξ± Γ— Ξ² => q ab.1 * kernel ab.1 ab.2) = totalVariation p q := by
unfold totalVariation
congr 1
rw [Fintype.sum_prod_type]
apply Finset.sum_congr rfl
intro a _
have habs : βˆ€ b, |kernel a b| = kernel a b := fun b => abs_of_nonneg ((hk a).1 b)
simp only [← sub_mul, abs_mul, habs, ← Finset.mul_sum, (hk a).2,
mul_one]
/-- Applying a finite stochastic kernel, forgetting its input. -/
noncomputable def kernelPushforward (p : Ξ± β†’ ℝ) (kernel : Ξ± β†’ Ξ² β†’ ℝ) : Ξ² β†’ ℝ :=
fun b => βˆ‘ a, p a * kernel a b
theorem totalVariation_kernelPushforward_le (p q : Ξ± β†’ ℝ) (kernel : Ξ± β†’ Ξ² β†’ ℝ)
(hk : βˆ€ a, IsProbability (kernel a)) :
totalVariation (kernelPushforward p kernel) (kernelPushforward q kernel) ≀
totalVariation p q := by
have hpoint : βˆ€ b,
|kernelPushforward p kernel b - kernelPushforward q kernel b| ≀
βˆ‘ a, |p a - q a| * kernel a b := by
intro b
simp only [kernelPushforward, ← Finset.sum_sub_distrib, ← sub_mul]
have h := Finset.abs_sum_le_sum_abs (fun a => (p a - q a) * kernel a b) Finset.univ
have habs : βˆ€ a, |kernel a b| = kernel a b := fun a => abs_of_nonneg ((hk a).1 b)
simpa only [abs_mul, habs] using h
have hsum := Finset.sum_le_sum (fun b (_ : b ∈ (Finset.univ : Finset β)) => hpoint b)
rw [Finset.sum_comm] at hsum
simp only [← Finset.mul_sum, (hk _).2, mul_one] at hsum
exact div_le_div_of_nonneg_right hsum (by norm_num : (0 : ℝ) ≀ 2)
end UniqueGamesTheorem.Foundations.Repetition
end
end OAI