introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
10.3 kB
import Mathlib
namespace OAI
namespace IndependentSetsGames.Foundations.Games
open scoped BigOperators
noncomputable section
structure FiniteDistribution (Ω : Type*) [Fintype Ω] where
weight : Ω → ℝ
nonnegative : ∀ x, 0 ≤ weight x
normalized : ∑ x, weight x = 1
namespace FiniteDistribution
variable {Ω Γ : Type*} [Fintype Ω] [Fintype Γ]
def expectation (μ : FiniteDistribution Ω) (f : Ω → ℝ) : ℝ :=
∑ x, μ.weight x * f x
def probability (μ : FiniteDistribution Ω) (event : Ω → Bool) : ℝ :=
∑ x, if event x then μ.weight x else 0
theorem probability_nonnegative (μ : FiniteDistribution Ω) (event : Ω → Bool) :
0 ≤ μ.probability event := by
apply Finset.sum_nonneg
intro x _
split
· exact μ.nonnegative x
· exact le_rfl
theorem probability_le_one (μ : FiniteDistribution Ω) (event : Ω → Bool) :
μ.probability event ≤ 1 := by
rw [← μ.normalized]
apply Finset.sum_le_sum
intro x _
split
· exact le_rfl
· exact μ.nonnegative x
@[simp] theorem probability_true (μ : FiniteDistribution Ω) :
μ.probability (fun _ => true) = 1 := by
simpa [probability] using μ.normalized
@[simp] theorem probability_false (μ : FiniteDistribution Ω) :
μ.probability (fun _ => false) = 0 := by
simp [probability]
theorem probability_mono (μ : FiniteDistribution Ω) {event event' : Ω → Bool}
(h : ∀ x, event x = true → event' x = true) :
μ.probability event ≤ μ.probability event' := by
apply Finset.sum_le_sum
intro x _
by_cases hx : event x = true
· simp [hx, h x hx]
· simp [hx]
split
· exact μ.nonnegative x
· exact le_rfl
def pushforward (μ : FiniteDistribution Ω) (f : Ω → Γ) : FiniteDistribution Γ := by
classical
exact
{ weight := fun y => ∑ x, if f x = y then μ.weight x else 0
nonnegative := fun y => Finset.sum_nonneg fun x _ => by
split
· exact μ.nonnegative x
· exact le_rfl
normalized := by
rw [Finset.sum_comm]
simpa using μ.normalized }
theorem probability_pushforward (μ : FiniteDistribution Ω) (f : Ω → Γ)
(event : Γ → Bool) :
(μ.pushforward f).probability event = μ.probability (fun x => event (f x)) := by
classical
simp only [probability, pushforward]
calc
_ = ∑ y, ∑ x, if f x = y then (if event y then μ.weight x else 0) else 0 := by
apply Finset.sum_congr rfl
intro y _
by_cases hy : event y = true <;> simp [hy]
_ = _ := by rw [Finset.sum_comm]; simp
def transport (μ : FiniteDistribution Ω) (equiv : Ω ≃ Γ) : FiniteDistribution Γ where
weight y := μ.weight (equiv.symm y)
nonnegative y := μ.nonnegative (equiv.symm y)
normalized := by rw [equiv.symm.sum_comp, μ.normalized]
theorem probability_transport (μ : FiniteDistribution Ω) (equiv : Ω ≃ Γ)
(event : Γ → Bool) :
(μ.transport equiv).probability event = μ.probability (fun x => event (equiv x)) := by
unfold probability transport
exact Fintype.sum_equiv equiv.symm _ _ (fun _ => by simp)
def iid (μ : FiniteDistribution Ω) (n : Nat) : FiniteDistribution (Fin n → Ω) where
weight x := ∏ i, μ.weight (x i)
nonnegative x := Finset.prod_nonneg fun i _ => μ.nonnegative (x i)
normalized := by rw [← Fintype.sum_pow, μ.normalized, one_pow]
theorem probability_iid_all (μ : FiniteDistribution Ω) (event : Ω → Bool) (n : Nat) :
(μ.iid n).probability (fun x => decide (∀ i, event (x i) = true)) =
μ.probability event ^ n := by
classical
unfold probability iid
rw [Fintype.sum_pow]
apply Finset.sum_congr rfl
intro x _
simp only [decide_eq_true_eq]
by_cases h : ∀ i, event (x i) = true
· simp [h]
· rw [ite_eq_right h]
obtain ⟨i, hi⟩ := not_forall.mp h
symm
apply Finset.prod_eq_zero (Finset.mem_univ i)
simp [hi]
end FiniteDistribution
abbrev Strategy (Q₁ Q₂ A₁ A₂ : Type*) := (Q₁ → A₁) × (Q₂ → A₂)
structure Game (Q₁ Q₂ A₁ A₂ : Type*) [Fintype Q₁] [Fintype Q₂]
[Fintype A₁] [Fintype A₂] where
questions : FiniteDistribution (Q₁ × Q₂)
accepts : Q₁ → Q₂ → A₁ → A₂ → Bool
namespace Game
variable {Q₁ Q₂ A₁ A₂ : Type*}
[Fintype Q₁] [Fintype Q₂] [Fintype A₁] [Fintype A₂]
def wins (G : Game Q₁ Q₂ A₁ A₂) (strategy : Strategy Q₁ Q₂ A₁ A₂)
(questions : Q₁ × Q₂) : Bool :=
G.accepts questions.1 questions.2 (strategy.1 questions.1) (strategy.2 questions.2)
def success (G : Game Q₁ Q₂ A₁ A₂) (strategy : Strategy Q₁ Q₂ A₁ A₂) : ℝ :=
G.questions.probability (G.wins strategy)
theorem success_nonnegative (G : Game Q₁ Q₂ A₁ A₂)
(strategy : Strategy Q₁ Q₂ A₁ A₂) : 0 ≤ G.success strategy :=
G.questions.probability_nonnegative _
theorem success_le_one (G : Game Q₁ Q₂ A₁ A₂)
(strategy : Strategy Q₁ Q₂ A₁ A₂) : G.success strategy ≤ 1 :=
G.questions.probability_le_one _
def simulatedStrategy {R₁ R₂ B₁ B₂ : Type*}
(questionMap₁ : Q₁ → R₁) (questionMap₂ : Q₂ → R₂)
(answerMap₁ : Q₁ → B₁ → A₁) (answerMap₂ : Q₂ → B₂ → A₂)
(strategy : Strategy R₁ R₂ B₁ B₂) : Strategy Q₁ Q₂ A₁ A₂ :=
(fun x => answerMap₁ x (strategy.1 (questionMap₁ x)),
fun y => answerMap₂ y (strategy.2 (questionMap₂ y)))
theorem success_le_of_localSimulation {R₁ R₂ B₁ B₂ : Type*}
[Fintype R₁] [Fintype R₂] [Fintype B₁] [Fintype B₂]
(G : Game Q₁ Q₂ A₁ A₂) (H : Game R₁ R₂ B₁ B₂)
(questionMap₁ : Q₁ → R₁) (questionMap₂ : Q₂ → R₂)
(answerMap₁ : Q₁ → B₁ → A₁) (answerMap₂ : Q₂ → B₂ → A₂)
(questionLaw : H.questions =
G.questions.pushforward (fun q => (questionMap₁ q.1, questionMap₂ q.2)))
(acceptance : ∀ x y a b,
H.accepts (questionMap₁ x) (questionMap₂ y) a b = true →
G.accepts x y (answerMap₁ x a) (answerMap₂ y b) = true)
(strategy : Strategy R₁ R₂ B₁ B₂) :
H.success strategy ≤
G.success (simulatedStrategy questionMap₁ questionMap₂ answerMap₁ answerMap₂ strategy) := by
unfold success
rw [questionLaw, FiniteDistribution.probability_pushforward]
apply FiniteDistribution.probability_mono
intro questions h
exact acceptance questions.1 questions.2 _ _ h
def tupleQuestionEquiv (n : Nat) :
(Fin n → Q₁ × Q₂) ≃ (Fin n → Q₁) × (Fin n → Q₂) where
toFun questions := (fun i => (questions i).1, fun i => (questions i).2)
invFun questions := fun i => (questions.1 i, questions.2 i)
left_inv _ := rfl
right_inv _ := rfl
def repetition (G : Game Q₁ Q₂ A₁ A₂) (n : Nat) :
Game (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂) := by
classical
exact
{ questions := (G.questions.iid n).transport (tupleQuestionEquiv n)
accepts := fun x y a b => decide (∀ i, G.accepts (x i) (y i) (a i) (b i) = true) }
def repeatStrategy (strategy : Strategy Q₁ Q₂ A₁ A₂) (n : Nat) :
Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂) :=
(fun x i => strategy.1 (x i), fun y i => strategy.2 (y i))
theorem success_repeatStrategy (G : Game Q₁ Q₂ A₁ A₂)
(strategy : Strategy Q₁ Q₂ A₁ A₂) (n : Nat) :
(G.repetition n).success (repeatStrategy strategy n) = G.success strategy ^ n := by
unfold success
change ((G.questions.iid n).transport (tupleQuestionEquiv n)).probability _ = _
rw [FiniteDistribution.probability_transport]
exact G.questions.probability_iid_all (G.wins strategy) n
@[simp] theorem repetition_question_weight (G : Game Q₁ Q₂ A₁ A₂) (n : Nat)
(questions : (Fin n → Q₁) × (Fin n → Q₂)) :
(G.repetition n).questions.weight questions =
∏ i, G.questions.weight (questions.1 i, questions.2 i) := rfl
@[simp] theorem repetition_accepts_iff (G : Game Q₁ Q₂ A₁ A₂) (n : Nat)
(x : Fin n → Q₁) (y : Fin n → Q₂) (a : Fin n → A₁) (b : Fin n → A₂) :
(G.repetition n).accepts x y a b = true ↔
∀ i, G.accepts (x i) (y i) (a i) (b i) = true := by
classical
simp [repetition]
def coordinateWin (G : Game Q₁ Q₂ A₁ A₂) {n : Nat}
(strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂))
(coordinate : Fin n) (questions : (Fin n → Q₁) × (Fin n → Q₂)) : Bool :=
G.accepts (questions.1 coordinate) (questions.2 coordinate)
(strategy.1 questions.1 coordinate) (strategy.2 questions.2 coordinate)
def selectedWins (G : Game Q₁ Q₂ A₁ A₂) {n : Nat}
(strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂))
(selected : Finset (Fin n)) (questions : (Fin n → Q₁) × (Fin n → Q₂)) : Bool := by
classical
exact decide (∀ i ∈ selected, G.coordinateWin strategy i questions = true)
theorem selectedWins_mono (G : Game Q₁ Q₂ A₁ A₂) {n : Nat}
(strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂))
{selected selected' : Finset (Fin n)} (h : selected ⊆ selected') :
(G.repetition n).questions.probability (G.selectedWins strategy selected') ≤
(G.repetition n).questions.probability (G.selectedWins strategy selected) := by
apply FiniteDistribution.probability_mono
intro questions hwin
simp only [selectedWins, decide_eq_true_eq] at hwin ⊢
intro i hi
exact hwin i (h hi)
@[simp] theorem selectedWins_empty (G : Game Q₁ Q₂ A₁ A₂) {n : Nat}
(strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂))
(questions : (Fin n → Q₁) × (Fin n → Q₂)) :
G.selectedWins strategy ∅ questions = true := by
simp [selectedWins]
theorem selectedWins_univ (G : Game Q₁ Q₂ A₁ A₂) {n : Nat}
(strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) :
G.selectedWins strategy Finset.univ = (G.repetition n).wins strategy := by
classical
funext questions
simp [selectedWins, coordinateWin, repetition, wins]
end Game
end
end IndependentSetsGames.Foundations.Games
end OAI