| import Mathlib.Algebra.BigOperators.Ring.Finset |
| import Mathlib.Algebra.Order.BigOperators.Group.Finset |
| import Mathlib.Data.Fintype.BigOperators |
| import Mathlib.Data.Fintype.Sum |
| import Mathlib.Basic.Real.Basic |
| import Mathlib.Tactic.FieldSimp |
| import Mathlib.Tactic.Linarith |
| import Mathlib.Tactic.Positivity |
| import Mathlib.Tactic.Ring |
| import OAI.Computability.BinPacking.Games.LocalSimulation |
| import OAI.Computability.BinPacking.Information.SideInformation |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace BinPackingGames.Foundations.Repetition |
|
|
| section |
|
|
| open scoped BigOperators |
|
|
| variable {ι α β : Type*} [Fintype ι] [DecidableEq α] [DecidableEq β] |
|
|
| def revealedProductWeight (weight : ι → α → β → ℝ) (mask : ι → Bool) |
| (fixedLeft : ι → α) (fixedRight : ι → β) (x : ι → α) (y : ι → β) : ℝ := |
| ∏ i, weight i (x i) (y i) * |
| (if mask i then (if y i = fixedRight i then 1 else 0) |
| else (if x i = fixedLeft i then 1 else 0)) |
|
|
| def revealedLeftWeight (weight : ι → α → β → ℝ) (mask : ι → Bool) |
| (fixedLeft : ι → α) (fixedRight : ι → β) (x : ι → α) : ℝ := |
| ∏ i, if mask i then weight i (x i) (fixedRight i) |
| else (if x i = fixedLeft i then 1 else 0) |
|
|
| def revealedRightWeight (weight : ι → α → β → ℝ) (mask : ι → Bool) |
| (fixedLeft : ι → α) (fixedRight : ι → β) (y : ι → β) : ℝ := |
| ∏ i, if mask i then (if y i = fixedRight i then 1 else 0) |
| else weight i (fixedLeft i) (y i) |
|
|
| theorem revealedProductWeight_factorizes (weight : ι → α → β → ℝ) (mask : ι → Bool) |
| (fixedLeft : ι → α) (fixedRight : ι → β) (x : ι → α) (y : ι → β) : |
| revealedProductWeight weight mask fixedLeft fixedRight x y = |
| revealedLeftWeight weight mask fixedLeft fixedRight x * |
| revealedRightWeight weight mask fixedLeft fixedRight y := by |
| unfold revealedProductWeight revealedLeftWeight revealedRightWeight |
| rw [← Finset.prod_mul_distrib] |
| apply Finset.prod_congr rfl |
| intro i _ |
| by_cases hm : mask i = true |
| · by_cases hy : y i = fixedRight i <;> simp [hm, hy] |
| · by_cases hx : x i = fixedLeft i <;> simp [hm, hx] |
|
|
| theorem revealedProductWeight_local_restrictions |
| (weight : ι → α → β → ℝ) (mask : ι → Bool) |
| (fixedLeft : ι → α) (fixedRight : ι → β) |
| (leftTest : (ι → α) → ℝ) (rightTest : (ι → β) → ℝ) |
| (x : ι → α) (y : ι → β) : |
| revealedProductWeight weight mask fixedLeft fixedRight x y * leftTest x * rightTest y = |
| (revealedLeftWeight weight mask fixedLeft fixedRight x * leftTest x) * |
| (revealedRightWeight weight mask fixedLeft fixedRight y * rightTest y) := by |
| rw [revealedProductWeight_factorizes] |
| ring |
|
|
| variable {X Y : Type*} [Fintype X] [Fintype Y] |
|
|
| theorem productWeight_mass (left : X → ℝ) (right : Y → ℝ) : |
| (∑ xy : X × Y, left xy.1 * right xy.2) = |
| (∑ x, left x) * (∑ y, right y) := by |
| rw [Fintype.sum_prod_type] |
| simp only [← Finset.mul_sum, ← Finset.sum_mul] |
|
|
| def normalizedWeight (weight : X → ℝ) : X → ℝ := |
| fun x => weight x / ∑ x', weight x' |
|
|
| theorem normalizedWeight_isProbability (weight : X → ℝ) |
| (hweight : ∀ x, 0 ≤ weight x) (hmass : 0 < ∑ x, weight x) : |
| (∀ x, 0 ≤ normalizedWeight weight x) ∧ (∑ x, normalizedWeight weight x) = 1 := by |
| constructor |
| · intro x |
| exact div_nonneg (hweight x) hmass.le |
| · simp only [normalizedWeight, div_eq_mul_inv, ← Finset.sum_mul, mul_inv_cancel₀ hmass.ne'] |
|
|
| theorem normalized_productWeight (left : X → ℝ) (right : Y → ℝ) |
| (hleft : 0 < ∑ x, left x) (hright : 0 < ∑ y, right y) (xy : X × Y) : |
| normalizedWeight (fun z : X × Y => left z.1 * right z.2) xy = |
| normalizedWeight left xy.1 * normalizedWeight right xy.2 := by |
| unfold normalizedWeight |
| rw [productWeight_mass] |
| field_simp |
|
|
| theorem normalized_rectangle_restriction |
| (left : X → ℝ) (right : Y → ℝ) (leftTest : X → ℝ) (rightTest : Y → ℝ) |
| (hleft : 0 < ∑ x, left x * leftTest x) |
| (hright : 0 < ∑ y, right y * rightTest y) (xy : X × Y) : |
| normalizedWeight |
| (fun z : X × Y => left z.1 * right z.2 * leftTest z.1 * rightTest z.2) xy = |
| normalizedWeight (fun x => left x * leftTest x) xy.1 * |
| normalizedWeight (fun y => right y * rightTest y) xy.2 := by |
| have hfun : (fun z : X × Y => left z.1 * right z.2 * leftTest z.1 * rightTest z.2) = |
| (fun z : X × Y => (left z.1 * leftTest z.1) * (right z.2 * rightTest z.2)) := by |
| funext z |
| ring |
| rw [hfun] |
| exact normalized_productWeight _ _ hleft hright xy |
|
|
| end |
|
|
| section |
|
|
| open scoped BigOperators |
| open Games |
|
|
| variable {X Y : Type*} [Fintype X] [Fintype Y] |
|
|
| def normalizeOr (w : X → ℝ) (hw : ∀ x, 0 ≤ w x) |
| (fallback : FiniteDistribution X) : FiniteDistribution X := |
| if h : 0 < ∑ x, w x then |
| { weight := normalizedWeight w |
| nonnegative := (normalizedWeight_isProbability w hw h).1 |
| normalized := (normalizedWeight_isProbability w hw h).2 } |
| else fallback |
|
|
| theorem sum_mul_normalizeOr (w : X → ℝ) (hw : ∀ x, 0 ≤ w x) |
| (fallback : FiniteDistribution X) (x : X) : |
| (∑ z, w z) * (normalizeOr w hw fallback).weight x = w x := by |
| classical |
| have hs : 0 ≤ ∑ z, w z := Finset.sum_nonneg (fun z _ => hw z) |
| by_cases h : 0 < ∑ z, w z |
| · simp only [normalizeOr, dite_eq_left h, normalizedWeight] |
| field_simp |
| · have hz : ∑ z, w z = 0 := le_antisymm (le_of_not_gt h) hs |
| have hx : w x = 0 := by |
| apply le_antisymm _ (hw x) |
| have hl := Finset.single_le_sum (fun z _ => hw z) (Finset.mem_univ x) |
| simpa only [hz] using hl |
| simp [normalizeOr, hz, hx] |
|
|
| theorem local_completion_recombination |
| (left : X → ℝ) (right : Y → ℝ) |
| (hl : ∀ x, 0 ≤ left x) (hr : ∀ y, 0 ≤ right y) |
| (defaultLeft : FiniteDistribution X) (defaultRight : FiniteDistribution Y) |
| (c : ℝ) (x : X) (y : Y) : |
| (c * (∑ z, left z) * (∑ z, right z)) * |
| ((normalizeOr left hl defaultLeft).weight x * |
| (normalizeOr right hr defaultRight).weight y) = c * left x * right y := by |
| calc |
| _ = c * ((∑ z, left z) * (normalizeOr left hl defaultLeft).weight x) * |
| ((∑ z, right z) * (normalizeOr right hr defaultRight).weight y) := by ring |
| _ = _ := by rw [sum_mul_normalizeOr, sum_mul_normalizeOr] |
|
|
| theorem factorized_completion_row |
| (left : X → ℝ) (right : Y → ℝ) |
| (hl : ∀ x, 0 ≤ left x) (hr : ∀ y, 0 ≤ right y) |
| (defaultLeft : FiniteDistribution X) (defaultRight : FiniteDistribution Y) |
| (c : ℝ) (xy : X × Y) : |
| (∑ z : X × Y, c * left z.1 * right z.2) * |
| ((normalizeOr left hl defaultLeft).product |
| (normalizeOr right hr defaultRight)).weight xy = c * left xy.1 * right xy.2 := by |
| have hm : (∑ z : X × Y, c * left z.1 * right z.2) = |
| c * (∑ z, left z) * (∑ z, right z) := by |
| simp_rw [mul_assoc, ← Finset.mul_sum] |
| rw [productWeight_mass] |
| rw [hm] |
| exact local_completion_recombination left right hl hr defaultLeft defaultRight c xy.1 xy.2 |
|
|
| end |
|
|
| section |
| open scoped BigOperators |
| open Games Information |
|
|
| variable {X Y : Type*} [Fintype X] [Fintype Y] [DecidableEq X] [DecidableEq Y] |
|
|
| def revealEndpoint (q : X × Y) (side : Bool) : X ⊕ Y := |
| if side then Sum.inr q.2 else Sum.inl q.1 |
|
|
| def revealLaw (μ : FiniteDistribution (X × Y)) : |
| FiniteDistribution ((X × Y) × (X ⊕ Y)) := |
| (μ.product (FiniteDistribution.uniform Bool)).pushforward |
| (fun z => (z.1, revealEndpoint z.1 z.2)) |
|
|
| theorem revealLaw_weight (μ : FiniteDistribution (X × Y)) (q : X × Y) (r : X ⊕ Y) : |
| (revealLaw μ).weight (q,r) = |
| (if r = Sum.inl q.1 then μ.weight q / 2 else 0) + |
| (if r = Sum.inr q.2 then μ.weight q / 2 else 0) := by |
| classical |
| rcases q with ⟨x,y⟩ |
| simp only [revealLaw, FiniteDistribution.pushforward, FiniteDistribution.product, |
| Fintype.sum_prod_type, Prod.mk.injEq, ite_and] |
| simp [revealEndpoint, FiniteDistribution.uniform, div_eq_mul_inv, add_comm, eq_comm] |
|
|
| def revealFirstLaw (μ : FiniteDistribution (X × Y)) : |
| FiniteDistribution ((X ⊕ Y) × (X × Y)) := |
| (revealLaw μ).transport (Equiv.prodComm _ _) |
|
|
| omit [DecidableEq X] [DecidableEq Y] in |
| @[simp] theorem revealFirstLaw_weight (μ : FiniteDistribution (X × Y)) |
| (r : X ⊕ Y) (q : X × Y) : |
| (revealFirstLaw μ).weight (r,q) = (revealLaw μ).weight (q,r) := rfl |
|
|
| def revealFallback (μ : FiniteDistribution (X × Y)) (r : X ⊕ Y) : |
| FiniteDistribution (X × Y) := |
| match r with |
| | Sum.inl x => μ.pushforward (fun q => (x,q.2)) |
| | Sum.inr y => μ.pushforward (fun q => (q.1,y)) |
|
|
| def revealProfile (μ : FiniteDistribution (X × Y)) (r : X ⊕ Y) : |
| FiniteDistribution (X × Y) := |
| gameConditionalKernel (revealFirstLaw μ) (revealFallback μ r) r |
|
|
| theorem revealProfile_inl_support (μ : FiniteDistribution (X × Y)) |
| (x : X) (q : X × Y) (h : q.1 ≠ x) : |
| (revealProfile μ (Sum.inl x)).weight q = 0 := by |
| classical |
| rcases q with ⟨x',y⟩ |
| dsimp at h |
| simp only [revealProfile, gameConditionalKernel, toGameLaw, conditionalKernel] |
| split |
| · simp [revealFallback, FiniteDistribution.pushforward, Fintype.sum_prod_type, |
| Prod.mk.injEq, Ne.symm h] |
| · simp [revealLaw_weight, Ne.symm h] |
|
|
| theorem revealProfile_inr_support (μ : FiniteDistribution (X × Y)) |
| (y : Y) (q : X × Y) (h : q.2 ≠ y) : |
| (revealProfile μ (Sum.inr y)).weight q = 0 := by |
| classical |
| rcases q with ⟨x,y'⟩ |
| dsimp at h |
| simp only [revealProfile, gameConditionalKernel, toGameLaw, conditionalKernel] |
| split |
| · simp [revealFallback, FiniteDistribution.pushforward, Fintype.sum_prod_type, |
| Prod.mk.injEq, Ne.symm h] |
| · simp [revealLaw_weight, Ne.symm h] |
|
|
| def revealInputLaw (μ : FiniteDistribution (X × Y)) : FiniteDistribution (X ⊕ Y) := |
| (revealLaw μ).pushforward Prod.snd |
|
|
| theorem revealInputLaw_weight (μ : FiniteDistribution (X × Y)) (r : X ⊕ Y) : |
| (revealInputLaw μ).weight r = firstMarginal (revealFirstLaw μ).weight r := by |
| classical |
| cases r <;> |
| simp [revealInputLaw, FiniteDistribution.pushforward, firstMarginal, Fintype.sum_prod_type] |
|
|
| theorem reveal_profile_recombination (μ : FiniteDistribution (X × Y)) |
| (r : X ⊕ Y) (q : X × Y) : |
| (revealInputLaw μ).weight r * (revealProfile μ r).weight q = |
| (revealLaw μ).weight (q,r) := by |
| rw [revealInputLaw_weight] |
| exact gameConditionalKernel_recombine (revealFirstLaw μ) (revealFallback μ r) r q |
|
|
| theorem reveal_profile_inl_recombination (μ : FiniteDistribution (X × Y)) |
| (x : X) (q : X × Y) : |
| (revealInputLaw μ).weight (Sum.inl x) * (revealProfile μ (Sum.inl x)).weight q = |
| if x = q.1 then μ.weight q / 2 else 0 := by |
| rw [reveal_profile_recombination, revealLaw_weight] |
| simp |
|
|
| theorem reveal_profile_inr_recombination (μ : FiniteDistribution (X × Y)) |
| (y : Y) (q : X × Y) : |
| (revealInputLaw μ).weight (Sum.inr y) * (revealProfile μ (Sum.inr y)).weight q = |
| if y = q.2 then μ.weight q / 2 else 0 := by |
| rw [reveal_profile_recombination, revealLaw_weight] |
| simp |
|
|
| theorem revealInputLaw_inl (μ : FiniteDistribution (X × Y)) (x : X) : |
| (revealInputLaw μ).weight (Sum.inl x) = (∑ y, μ.weight (x,y)) / 2 := by |
| classical |
| rw [revealInputLaw_weight] |
| simp [firstMarginal, Fintype.sum_prod_type, revealLaw_weight, div_eq_mul_inv] |
| rw [Finset.sum_comm] |
| simp [← Finset.sum_mul] |
|
|
| theorem revealInputLaw_inr (μ : FiniteDistribution (X × Y)) (y : Y) : |
| (revealInputLaw μ).weight (Sum.inr y) = (∑ x, μ.weight (x,y)) / 2 := by |
| classical |
| rw [revealInputLaw_weight] |
| simp [firstMarginal, Fintype.sum_prod_type, revealLaw_weight, |
| div_eq_mul_inv, ← Finset.sum_mul] |
|
|
| theorem revealProfile_inl_diagonal (μ : FiniteDistribution (X × Y)) (x : X) (y : Y) : |
| (revealProfile μ (Sum.inl x)).weight (x,y) = |
| conditionalKernel μ.weight (μ.pushforward Prod.snd).weight x y := by |
| classical |
| have hm : firstMarginal (revealFirstLaw μ).weight (Sum.inl x) = |
| firstMarginal μ.weight x / 2 := by |
| rw [← revealInputLaw_weight, revealInputLaw_inl] |
| rfl |
| have hf : (revealFallback μ (Sum.inl x)).weight (x,y) = |
| (μ.pushforward Prod.snd).weight y := by |
| simp [revealFallback, FiniteDistribution.pushforward, Prod.mk.injEq] |
| apply Finset.sum_congr rfl |
| intro q _ |
| by_cases hq : q.2 = y <;> simp [hq] |
| simp only [revealProfile, gameConditionalKernel, toGameLaw, conditionalKernel, hm] |
| by_cases h : firstMarginal μ.weight x = 0 |
| · simpa [h] using hf |
| · have hh : firstMarginal μ.weight x / 2 ≠ 0 := div_ne_zero h (by norm_num) |
| simp only [ite_eq_right h, ite_eq_right hh, revealFirstLaw_weight, revealLaw_weight, |
| ite_true, Sum.inl_ne_inr, ite_false, add_zero] |
| field_simp |
|
|
| theorem revealProfile_inr_diagonal (μ : FiniteDistribution (X × Y)) (x : X) (y : Y) : |
| (revealProfile μ (Sum.inr y)).weight (x,y) = |
| conditionalKernel (μ.transport (Equiv.prodComm X Y)).weight |
| (μ.pushforward Prod.fst).weight y x := by |
| classical |
| have hm : firstMarginal (revealFirstLaw μ).weight (Sum.inr y) = |
| firstMarginal (μ.transport (Equiv.prodComm X Y)).weight y / 2 := by |
| rw [← revealInputLaw_weight, revealInputLaw_inr] |
| rfl |
| have hf : (revealFallback μ (Sum.inr y)).weight (x,y) = |
| (μ.pushforward Prod.fst).weight x := by |
| simp [revealFallback, FiniteDistribution.pushforward, Prod.mk.injEq] |
| apply Finset.sum_congr rfl |
| intro q _ |
| by_cases hq : q.1 = x <;> simp [hq] |
| simp only [revealProfile, gameConditionalKernel, toGameLaw, conditionalKernel, hm] |
| by_cases h : firstMarginal (μ.transport (Equiv.prodComm X Y)).weight y = 0 |
| · simpa [h] using hf |
| · have hh : firstMarginal (μ.transport (Equiv.prodComm X Y)).weight y / 2 ≠ 0 := |
| div_ne_zero h (by norm_num) |
| simp only [ite_eq_right h, ite_eq_right hh, revealFirstLaw_weight, revealLaw_weight, |
| ite_true, Sum.inr_ne_inl, ite_false, zero_add] |
| change (μ.weight (x,y) / 2) / (firstMarginal (μ.transport (Equiv.prodComm X Y)).weight y / 2) = |
| μ.weight (x,y) / firstMarginal (μ.transport (Equiv.prodComm X Y)).weight y |
| field_simp |
|
|
| theorem revealLaw_sum_left (μ : FiniteDistribution (X × Y)) (q : X × Y) : |
| (∑ x, (revealLaw μ).weight (q, Sum.inl x)) = μ.weight q / 2 := by |
| classical |
| simp [revealLaw_weight] |
|
|
| theorem revealLaw_sum_right (μ : FiniteDistribution (X × Y)) (q : X × Y) : |
| (∑ y, (revealLaw μ).weight (q, Sum.inr y)) = μ.weight q / 2 := by |
| classical |
| simp [revealLaw_weight] |
|
|
| theorem revealLaw_forget (μ : FiniteDistribution (X × Y)) : |
| (revealLaw μ).pushforward Prod.fst = μ := by |
| classical |
| apply FiniteDistribution.eq_of_weight_eq |
| intro q |
| rcases q with ⟨x,y⟩ |
| simp [FiniteDistribution.pushforward, Fintype.sum_prod_type, |
| Finset.sum_ite_irrel, revealLaw_weight] |
|
|
| theorem reveal_product_factorization {ι : Type*} [Fintype ι] |
| (μ : FiniteDistribution (X × Y)) (r : ι → X ⊕ Y) (q : ι → X × Y) : |
| (∏ i, (revealInputLaw μ).weight (r i)) * |
| (∏ i, (revealProfile μ (r i)).weight (q i)) = |
| ∏ i, (revealLaw μ).weight (q i,r i) := by |
| rw [← Finset.prod_mul_distrib] |
| apply Finset.prod_congr rfl |
| intro i _ |
| exact reveal_profile_recombination μ (r i) (q i) |
|
|
| theorem reveal_product_forget {ι : Type*} [Fintype ι] [DecidableEq ι] |
| (μ : FiniteDistribution (X × Y)) (q : ι → X × Y) : |
| (∑ r : ι → X ⊕ Y, |
| (∏ i, (revealInputLaw μ).weight (r i)) * |
| (∏ i, (revealProfile μ (r i)).weight (q i))) = |
| ∏ i, μ.weight (q i) := by |
| classical |
| simp_rw [reveal_product_factorization] |
| calc |
| _ = ∏ i, ∑ r : X ⊕ Y, (revealLaw μ).weight (q i,r) := |
| (Fintype.prod_sum (fun (i : ι) (r : X ⊕ Y) => (revealLaw μ).weight (q i,r))).symm |
| _ = _ := by |
| apply Finset.prod_congr rfl |
| intro i _ |
| rw [Fintype.sum_sum_type, revealLaw_sum_left, revealLaw_sum_right] |
| ring |
|
|
| theorem reveal_product_expectation {ι : Type*} [Fintype ι] [DecidableEq ι] |
| (μ : FiniteDistribution (X × Y)) (f : (ι → X × Y) → ℝ) : |
| (∑ r : ι → X ⊕ Y, |
| (∏ i, (revealInputLaw μ).weight (r i)) * |
| ∑ q : ι → X × Y, (∏ i, (revealProfile μ (r i)).weight (q i)) * f q) = |
| ∑ q : ι → X × Y, (∏ i, μ.weight (q i)) * f q := by |
| classical |
| simp_rw [Finset.mul_sum] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro q _ |
| simp_rw [← mul_assoc, ← Finset.sum_mul] |
| rw [reveal_product_forget] |
|
|
| end |
|
|
| section |
| open scoped BigOperators |
| open Games Information |
|
|
| def mergeCoordinates {Ω : Type*} {n : Nat} (selected : Finset (Fin n)) |
| (fixed : selected → Ω) (remaining : {i : Fin n // i ∉ selected} → Ω) : Fin n → Ω := |
| fun i => if h : i ∈ selected then fixed ⟨i,h⟩ else remaining ⟨i,h⟩ |
|
|
| def coordinateSplitEquiv {Ω : Type*} {n : Nat} (selected : Finset (Fin n)) : |
| (Fin n → Ω) ≃ ((selected → Ω) × ({i : Fin n // i ∉ selected} → Ω)) where |
| toFun x := (fun i => x i.1, fun i => x i.1) |
| invFun x := mergeCoordinates selected x.1 x.2 |
| left_inv x := by funext i; simp [mergeCoordinates] |
| right_inv x := by |
| apply Prod.ext <;> funext i <;> simp [mergeCoordinates, i.property] |
|
|
| theorem iid_coordinate_split {Ω : Type*} [Fintype Ω] {n : Nat} |
| (μ : FiniteDistribution Ω) (selected : Finset (Fin n)) : |
| (μ.iid n).transport (coordinateSplitEquiv selected) = |
| (FiniteDistribution.table (fun _ : selected => μ)).product |
| (FiniteDistribution.table (fun _ : {i : Fin n // i ∉ selected} => μ)) := by |
| classical |
| apply FiniteDistribution.eq_of_weight_eq |
| intro x |
| change (∏ i, μ.weight (mergeCoordinates selected x.1 x.2 i)) = |
| (∏ i : selected, μ.weight (x.1 i)) * |
| ∏ i : {i : Fin n // i ∉ selected}, μ.weight (x.2 i) |
| have h := Fintype.prod_subtype_mul_prod_subtype (fun i : Fin n => i ∈ selected) |
| (fun i => μ.weight (mergeCoordinates selected x.1 x.2 i)) |
| have hi : Subtype.fintype (fun i : Fin n => i ∈ selected) = |
| Finset.Subtype.fintype selected := Subsingleton.elim _ _ |
| rw [hi] at h |
| calc |
| _ = (∏ i : {i : Fin n // i ∈ selected}, |
| μ.weight (mergeCoordinates selected x.1 x.2 i.1)) * |
| ∏ i : {i : Fin n // i ∉ selected}, |
| μ.weight (mergeCoordinates selected x.1 x.2 i.1) := h.symm |
| _ = _ := by |
| congr 1 <;> apply Finset.prod_congr rfl <;> intro i _ <;> |
| simp [mergeCoordinates, i.property] |
|
|
| variable {Q₁ Q₂ A₁ A₂ : Type*} |
| [Fintype Q₁] [Fintype Q₂] [Fintype A₁] [Fintype A₂] |
| [DecidableEq Q₁] [DecidableEq Q₂] |
| {n : Nat} |
|
|
| abbrev SelectedLabels (selected : Finset (Fin n)) := |
| (selected → A₁) × (selected → A₂) |
|
|
| def selectedQuestionTuple (selected : Finset (Fin n)) |
| (fixed : selected → Q₁ × Q₂) |
| (remaining : {i : Fin n // i ∉ selected} → Q₁ × Q₂) : |
| (Fin n → Q₁) × (Fin n → Q₂) := |
| (fun i => (mergeCoordinates selected fixed remaining i).1, |
| fun i => (mergeCoordinates selected fixed remaining i).2) |
|
|
| def selectedAnswerLabel |
| (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₂)) : |
| SelectedLabels (A₁ := A₁) (A₂ := A₂) selected := |
| (fun i => strategy.1 questions.1 i.1, fun i => strategy.2 questions.2 i.1) |
|
|
| def selectedLikelihood (G : Game Q₁ Q₂ A₁ A₂) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) |
| (selected : Finset (Fin n)) (fixed : selected → Q₁ × Q₂) |
| (label : SelectedLabels (A₁ := A₁) (A₂ := A₂) selected) |
| (remaining : {i : Fin n // i ∉ selected} → Q₁ × Q₂) : ℝ := by |
| classical |
| let questions := selectedQuestionTuple selected fixed remaining |
| exact if selectedAnswerLabel strategy selected questions = label then |
| (if G.selectedWins strategy selected questions then 1 else 0) else 0 |
|
|
| omit [DecidableEq Q₁] [DecidableEq Q₂] in |
| theorem selectedLikelihood_nonnegative (G : Game Q₁ Q₂ A₁ A₂) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) |
| (selected : Finset (Fin n)) (fixed : selected → Q₁ × Q₂) |
| (label : SelectedLabels (A₁ := A₁) (A₂ := A₂) selected) |
| (remaining : {i : Fin n // i ∉ selected} → Q₁ × Q₂) : |
| 0 ≤ selectedLikelihood G strategy selected fixed label remaining := by |
| classical |
| dsimp only [selectedLikelihood] |
| split_ifs <;> norm_num |
|
|
| omit [DecidableEq Q₁] [DecidableEq Q₂] in |
| theorem selectedLikelihood_sum (G : Game Q₁ Q₂ A₁ A₂) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) |
| (selected : Finset (Fin n)) (fixed : selected → Q₁ × Q₂) |
| (remaining : {i : Fin n // i ∉ selected} → Q₁ × Q₂) : |
| (∑ label, selectedLikelihood G strategy selected fixed label remaining) = |
| if G.selectedWins strategy selected (selectedQuestionTuple selected fixed remaining) |
| then 1 else 0 := by |
| classical |
| simp [selectedLikelihood] |
|
|
| omit [DecidableEq Q₁] [DecidableEq Q₂] in |
| theorem selectedLikelihood_sum_le_one (G : Game Q₁ Q₂ A₁ A₂) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) |
| (selected : Finset (Fin n)) (fixed : selected → Q₁ × Q₂) |
| (remaining : {i : Fin n // i ∉ selected} → Q₁ × Q₂) : |
| (∑ label, selectedLikelihood G strategy selected fixed label remaining) ≤ 1 := by |
| rw [selectedLikelihood_sum] |
| split <;> norm_num |
|
|
| def selectedSplitLaw (G : Game Q₁ Q₂ A₁ A₂) (selected : Finset (Fin n)) : |
| FiniteDistribution ((selected → Q₁ × Q₂) × |
| ({i : Fin n // i ∉ selected} → Q₁ × Q₂)) := |
| (FiniteDistribution.table (fun _ : selected => G.questions)).product |
| (FiniteDistribution.table (fun _ : {i : Fin n // i ∉ selected} => G.questions)) |
|
|
| omit [DecidableEq Q₁] [DecidableEq Q₂] in |
| theorem selectedSplit_probability (G : Game Q₁ Q₂ A₁ A₂) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) |
| (selected : Finset (Fin n)) : |
| (selectedSplitLaw G selected).probability |
| (fun q => G.selectedWins strategy selected (selectedQuestionTuple selected q.1 q.2)) = |
| G.selectedSuccess strategy selected := by |
| rw [selectedSplitLaw, ← iid_coordinate_split, FiniteDistribution.probability_transport] |
| change (G.questions.iid n).probability _ = |
| ((G.questions.iid n).transport (Game.tupleQuestionEquiv n)).probability _ |
| rw [FiniteDistribution.probability_transport] |
| apply congrArg (G.questions.iid n).probability |
| funext q |
| congr 1 |
| apply Prod.ext <;> funext i <;> |
| simp [selectedQuestionTuple, coordinateSplitEquiv, mergeCoordinates, Game.tupleQuestionEquiv] |
|
|
| abbrev SelectedInput (Q₁ Q₂ : Type*) {n : Nat} (selected : Finset (Fin n)) := |
| (selected → Q₁ × Q₂) × ({i : Fin n // i ∉ selected} → Q₁ ⊕ Q₂) |
|
|
| def selectedInputLaw (G : Game Q₁ Q₂ A₁ A₂) (selected : Finset (Fin n)) : |
| FiniteDistribution (SelectedInput Q₁ Q₂ selected) := |
| (FiniteDistribution.table (fun _ : selected => G.questions)).product |
| (FiniteDistribution.table (fun _ : {i : Fin n // i ∉ selected} => revealInputLaw G.questions)) |
|
|
| def selectedInputProfile (G : Game Q₁ Q₂ A₁ A₂) (selected : Finset (Fin n)) |
| (t : SelectedInput Q₁ Q₂ selected) (i : {i : Fin n // i ∉ selected}) : |
| FiniteDistribution (Q₁ × Q₂) := revealProfile G.questions (t.2 i) |
|
|
| def selectedSideMass (G : Game Q₁ Q₂ A₁ A₂) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) |
| (selected : Finset (Fin n)) |
| (tv : SelectedInput Q₁ Q₂ selected × SelectedLabels (A₁ := A₁) (A₂ := A₂) selected) : ℝ := |
| ∑ u, independentProduct (fun i => (selectedInputProfile G selected tv.1 i).weight) u * |
| selectedLikelihood G strategy selected tv.1.1 tv.2 u |
|
|
| omit [DecidableEq Q₁] [DecidableEq Q₂] in |
| theorem selectedSideMass_sum (G : Game Q₁ Q₂ A₁ A₂) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) |
| (selected : Finset (Fin n)) (t : SelectedInput Q₁ Q₂ selected) : |
| (∑ v, selectedSideMass G strategy selected (t,v)) = |
| ∑ u, independentProduct (fun i => (selectedInputProfile G selected t i).weight) u * |
| (if G.selectedWins strategy selected (selectedQuestionTuple selected t.1 u) |
| then 1 else 0) := by |
| classical |
| simp only [selectedSideMass] |
| rw [Finset.sum_comm] |
| simp_rw [← Finset.mul_sum, selectedLikelihood_sum] |
|
|
| theorem selectedSideMass_total (G : Game Q₁ Q₂ A₁ A₂) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) |
| (selected : Finset (Fin n)) : |
| (∑ tv, (selectedInputLaw G selected).weight tv.1 * |
| selectedSideMass G strategy selected tv) = G.selectedSuccess strategy selected := by |
| classical |
| rw [Fintype.sum_prod_type] |
| simp_rw [← Finset.mul_sum, selectedSideMass_sum] |
| rw [Fintype.sum_prod_type] |
| simp only [selectedInputLaw, FiniteDistribution.product, FiniteDistribution.table, |
| selectedInputProfile, independentProduct] |
| simp_rw [mul_assoc, ← Finset.mul_sum] |
| have hforget (fixed : selected → Q₁ × Q₂) := |
| reveal_product_expectation G.questions |
| (fun u : {i : Fin n // i ∉ selected} → Q₁ × Q₂ => |
| if G.selectedWins strategy selected (selectedQuestionTuple selected fixed u) |
| then (1 : ℝ) else 0) |
| simp_rw [hforget] |
| have h := selectedSplit_probability G strategy selected |
| simpa [selectedSplitLaw, FiniteDistribution.probability, FiniteDistribution.product, |
| FiniteDistribution.table, Fintype.sum_prod_type, Finset.mul_sum, mul_ite, mul_assoc] using h |
|
|
| def selectedSideWeight (G : Game Q₁ Q₂ A₁ A₂) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) |
| (selected : Finset (Fin n)) |
| (tv : SelectedInput Q₁ Q₂ selected × SelectedLabels (A₁ := A₁) (A₂ := A₂) selected) : ℝ := |
| (selectedInputLaw G selected).weight tv.1 * selectedSideMass G strategy selected tv / |
| G.selectedSuccess strategy selected |
|
|
| theorem selected_information_bound [Nonempty A₁] [Nonempty A₂] |
| (G : Game Q₁ Q₂ A₁ A₂) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) |
| (selected : Finset (Fin n)) (positive : 0 < G.selectedSuccess strategy selected) : |
| (∑ i : {i : Fin n // i ∉ selected}, totalVariation |
| (fun tva : (SelectedInput Q₁ Q₂ selected × |
| SelectedLabels (A₁ := A₁) (A₂ := A₂) selected) × (Q₁ × Q₂) => |
| selectedSideWeight G strategy selected tva.1 * coordinateMarginal |
| (posteriorOrOriginal |
| (independentProduct (fun j => (selectedInputProfile G selected tva.1.1 j).weight)) |
| (selectedLikelihood G strategy selected tva.1.1.1 tva.1.2) |
| (selectedSideMass G strategy selected tva.1)) i tva.2) |
| (fun tva => selectedSideWeight G strategy selected tva.1 * |
| (selectedInputProfile G selected tva.1.1 i).weight tva.2)) ≤ |
| Real.sqrt ((Fintype.card {i : Fin n // i ∉ selected} : ℝ) * |
| (Real.log (Fintype.card (SelectedLabels (A₁ := A₁) (A₂ := A₂) selected) : ℝ) + |
| Real.log (1 / G.selectedSuccess strategy selected))) := by |
| exact finite_side_information_bound (selectedInputLaw G selected).weight |
| (fun t i => (selectedInputProfile G selected t i).weight) |
| (fun tv => selectedLikelihood G strategy selected tv.1.1 tv.2) |
| (selectedSideMass G strategy selected) (selectedSideWeight G strategy selected) |
| (gameLaw_isProbability _) (fun t i => gameLaw_isProbability _) |
| (fun tv => selectedLikelihood_nonnegative G strategy selected tv.1.1 tv.2) |
| (fun t => selectedLikelihood_sum_le_one G strategy selected t.1) |
| (fun _ => rfl) positive (selectedSideMass_total G strategy selected) (fun _ => rfl) |
|
|
| end |
|
|
| section |
| open scoped BigOperators |
| variable {S X Y : Type*} [Fintype S] [Fintype X] [Fintype Y] |
| [DecidableEq X] [DecidableEq Y] |
|
|
| def maskedJoint (p : S × (X × Y) → ℝ) : (S × (X ⊕ Y)) × (X × Y) → ℝ := fun z => |
| (if z.1.2 = Sum.inl z.2.1 then p (z.1.1, z.2) / 2 else 0) + |
| (if z.1.2 = Sum.inr z.2.2 then p (z.1.1, z.2) / 2 else 0) |
|
|
| def maskedModel (μ : Games.FiniteDistribution (X × Y)) (p : S × (X × Y) → ℝ) : |
| (S × (X ⊕ Y)) × (X × Y) → ℝ := fun z => |
| Information.firstMarginal (maskedJoint p) z.1 * (revealProfile μ z.1.2).weight z.2 |
|
|
| def leftRevealModel (μ : Games.FiniteDistribution (X × Y)) (p : S × (X × Y) → ℝ) : |
| S × (X × Y) → ℝ := fun z => |
| (∑ y, p (z.1, (z.2.1, y))) * (revealProfile μ (Sum.inl z.2.1)).weight z.2 |
|
|
| def rightRevealModel (μ : Games.FiniteDistribution (X × Y)) (p : S × (X × Y) → ℝ) : |
| S × (X × Y) → ℝ := fun z => |
| (∑ x, p (z.1, (x, z.2.2))) * (revealProfile μ (Sum.inr z.2.2)).weight z.2 |
|
|
| theorem sum_maskedJoint (p : S × (X × Y) → ℝ) : |
| (∑ z, maskedJoint p z) = ∑ z, p z := by |
| classical |
| have hrow (s : S) (q : X × Y) : |
| (∑ r : X ⊕ Y, maskedJoint p ((s,r),q)) = p (s,q) := by |
| simp [maskedJoint] |
| calc |
| _ = ∑ s : S, ∑ r : X ⊕ Y, ∑ q : X × Y, maskedJoint p ((s,r),q) := by |
| simp only [Fintype.sum_prod_type] |
| _ = ∑ s : S, ∑ q : X × Y, p (s,q) := by |
| apply Finset.sum_congr rfl |
| intro s _ |
| rw [Finset.sum_comm] |
| simp_rw [hrow] |
| _ = _ := (Fintype.sum_prod_type _).symm |
|
|
| theorem maskedJoint_isProbability_iff (p : S × (X × Y) → ℝ) : |
| Information.IsProbability (maskedJoint p) ↔ Information.IsProbability p := by |
| classical |
| constructor |
| · intro h |
| constructor |
| · intro z |
| have hp := h.1 ((z.1,Sum.inl z.2.1),z.2) |
| simp [maskedJoint] at hp |
| linarith |
| · rw [← sum_maskedJoint] |
| exact h.2 |
| · intro h |
| constructor |
| · intro z |
| have hp : 0 ≤ p (z.1.1,z.2) / 2 := div_nonneg (h.1 _) (by norm_num) |
| dsimp [maskedJoint] |
| split_ifs <;> linarith |
| · rw [sum_maskedJoint] |
| exact h.2 |
|
|
| omit [Fintype S] in |
| theorem maskedJoint_firstMarginal_inl (p : S × (X × Y) → ℝ) (s : S) (x : X) : |
| Information.firstMarginal (maskedJoint p) (s, Sum.inl x) = |
| (∑ y, p (s, (x, y))) / 2 := by |
| simp [Information.firstMarginal, maskedJoint, Fintype.sum_prod_type, |
| div_eq_mul_inv, Finset.sum_mul] |
| rw [Finset.sum_comm] |
| simp |
|
|
| omit [Fintype S] in |
| theorem maskedJoint_firstMarginal_inr (p : S × (X × Y) → ℝ) (s : S) (y : Y) : |
| Information.firstMarginal (maskedJoint p) (s, Sum.inr y) = |
| (∑ x, p (s, (x, y))) / 2 := by |
| simp [Information.firstMarginal, maskedJoint, Fintype.sum_prod_type, |
| div_eq_mul_inv, Finset.sum_mul] |
|
|
| private theorem abs_half_sub_half_mul (a b c : ℝ) : |
| |a / 2 - b / 2 * c| = |a - b * c| / 2 := by |
| rw [show a / 2 - b / 2 * c = (a - b * c) / 2 by ring, abs_div] |
| norm_num |
|
|
| omit [Fintype S] in |
| theorem abs_masked_inl (μ : Games.FiniteDistribution (X × Y)) |
| (p : S × (X × Y) → ℝ) (s : S) (u x : X) (y : Y) : |
| |maskedJoint p ((s, Sum.inl u), (x, y)) - maskedModel μ p ((s, Sum.inl u), (x, y))| = |
| if x = u then |p (s, (x, y)) - leftRevealModel μ p (s, (x, y))| / 2 else 0 := by |
| by_cases hx : x = u |
| · subst x |
| simp only [maskedModel, maskedJoint_firstMarginal_inl] |
| simpa [maskedJoint, leftRevealModel] using |
| abs_half_sub_half_mul (p (s, (u, y))) (∑ v, p (s, (u, v))) |
| ((revealProfile μ (Sum.inl u)).weight (u, y)) |
| · have hs := revealProfile_inl_support μ u (x, y) hx |
| simp [maskedJoint, maskedModel, hs, hx, Ne.symm hx] |
|
|
| omit [Fintype S] in |
| theorem abs_masked_inr (μ : Games.FiniteDistribution (X × Y)) |
| (p : S × (X × Y) → ℝ) (s : S) (v : Y) (x : X) (y : Y) : |
| |maskedJoint p ((s, Sum.inr v), (x, y)) - maskedModel μ p ((s, Sum.inr v), (x, y))| = |
| if y = v then |p (s, (x, y)) - rightRevealModel μ p (s, (x, y))| / 2 else 0 := by |
| by_cases hy : y = v |
| · subst y |
| simp only [maskedModel, maskedJoint_firstMarginal_inr] |
| simpa [maskedJoint, rightRevealModel] using |
| abs_half_sub_half_mul (p (s, (x, v))) (∑ u, p (s, (u, v))) |
| ((revealProfile μ (Sum.inr v)).weight (x, v)) |
| · have hs := revealProfile_inr_support μ v (x, y) hy |
| simp [maskedJoint, maskedModel, hs, hy, Ne.symm hy] |
|
|
| theorem masked_totalVariation_identity (μ : Games.FiniteDistribution (X × Y)) |
| (p : S × (X × Y) → ℝ) : |
| 2 * Information.totalVariation (maskedJoint p) (maskedModel μ p) = |
| Information.totalVariation p (leftRevealModel μ p) + |
| Information.totalVariation p (rightRevealModel μ p) := by |
| have hleft (s : S) : |
| (∑ u : X, ∑ q : X × Y, |
| |maskedJoint p ((s, Sum.inl u), q) - maskedModel μ p ((s, Sum.inl u), q)|) = |
| (∑ q : X × Y, |p (s, q) - leftRevealModel μ p (s, q)|) / 2 := by |
| simp_rw [Fintype.sum_prod_type, abs_masked_inl] |
| simp [Finset.sum_ite_irrel, div_eq_mul_inv, Finset.sum_mul] |
| have hright (s : S) : |
| (∑ v : Y, ∑ q : X × Y, |
| |maskedJoint p ((s, Sum.inr v), q) - maskedModel μ p ((s, Sum.inr v), q)|) = |
| (∑ q : X × Y, |p (s, q) - rightRevealModel μ p (s, q)|) / 2 := by |
| have hcollapse : |
| (∑ v : Y, ∑ q : X × Y, |
| |maskedJoint p ((s, Sum.inr v), q) - maskedModel μ p ((s, Sum.inr v), q)|) = |
| ∑ v : Y, ∑ x : X, |p (s, (x, v)) - rightRevealModel μ p (s, (x, v))| / 2 := by |
| simp [Fintype.sum_prod_type, abs_masked_inr] |
| rw [hcollapse, Finset.sum_comm] |
| simp [Fintype.sum_prod_type, div_eq_mul_inv, Finset.sum_mul] |
| have hmass : |
| (∑ z : (S × (X ⊕ Y)) × (X × Y), |maskedJoint p z - maskedModel μ p z|) = |
| ((∑ z : S × (X × Y), |p z - leftRevealModel μ p z|) + |
| (∑ z : S × (X × Y), |p z - rightRevealModel μ p z|)) / 2 := by |
| calc |
| _ = ∑ s : S, |
| ((∑ u : X, ∑ q : X × Y, |maskedJoint p ((s, Sum.inl u), q) - maskedModel μ p ((s, Sum.inl u), q)|) + |
| (∑ v : Y, ∑ q : X × Y, |maskedJoint p ((s, Sum.inr v), q) - maskedModel μ p ((s, Sum.inr v), q)|)) := by |
| simp only [Fintype.sum_prod_type, Fintype.sum_sum_type] |
| _ = ∑ s : S, |
| ((∑ q : X × Y, |p (s, q) - leftRevealModel μ p (s, q)|) / 2 + |
| (∑ q : X × Y, |p (s, q) - rightRevealModel μ p (s, q)|) / 2) := by |
| simp_rw [hleft, hright] |
| _ = _ := by |
| simp [Fintype.sum_prod_type, div_eq_mul_inv, Finset.sum_add_distrib, Finset.sum_mul, add_mul] |
| unfold Information.totalVariation |
| rw [hmass] |
| ring |
|
|
| theorem leftRevealModel_totalVariation_le (μ : Games.FiniteDistribution (X × Y)) |
| (p : S × (X × Y) → ℝ) : |
| Information.totalVariation p (leftRevealModel μ p) ≤ |
| 2 * Information.totalVariation (maskedJoint p) (maskedModel μ p) := by |
| rw [masked_totalVariation_identity] |
| linarith [Information.totalVariation_nonneg p (rightRevealModel μ p)] |
|
|
| theorem rightRevealModel_totalVariation_le (μ : Games.FiniteDistribution (X × Y)) |
| (p : S × (X × Y) → ℝ) : |
| Information.totalVariation p (rightRevealModel μ p) ≤ |
| 2 * Information.totalVariation (maskedJoint p) (maskedModel μ p) := by |
| rw [masked_totalVariation_identity] |
| linarith [Information.totalVariation_nonneg p (leftRevealModel μ p)] |
|
|
| end |
|
|
| section |
| open scoped BigOperators |
| open Games Information |
|
|
| variable {Q₁ Q₂ A₁ A₂ : Type*} |
| [Fintype Q₁] [Fintype Q₂] [Fintype A₁] [Fintype A₂] |
| [DecidableEq Q₁] [DecidableEq Q₂] {n : Nat} |
|
|
| def selectedJointWeight (G : Game Q₁ Q₂ A₁ A₂) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) |
| (selected : Finset (Fin n)) |
| (z : (SelectedInput Q₁ Q₂ selected × SelectedLabels (A₁ := A₁) (A₂ := A₂) selected) × |
| ({i : Fin n // i ∉ selected} → Q₁ × Q₂)) : ℝ := |
| (selectedInputLaw G selected).weight z.1.1 * |
| independentProduct (fun i => (selectedInputProfile G selected z.1.1 i).weight) z.2 * |
| selectedLikelihood G strategy selected z.1.1.1 z.1.2 z.2 / |
| G.selectedSuccess strategy selected |
|
|
| omit [DecidableEq Q₁] [DecidableEq Q₂] in |
| theorem selectedJointWeight_nonnegative (G : Game Q₁ Q₂ A₁ A₂) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) |
| (selected : Finset (Fin n)) (z) : 0 ≤ selectedJointWeight G strategy selected z := by |
| apply div_nonneg |
| · exact mul_nonneg |
| (mul_nonneg ((selectedInputLaw G selected).nonnegative _) |
| ((independentProduct_isProbability _ |
| (fun i => gameLaw_isProbability (selectedInputProfile G selected z.1.1 i))).1 z.2)) |
| (selectedLikelihood_nonnegative G strategy selected z.1.1.1 z.1.2 z.2) |
| · exact G.selectedSuccess_nonnegative strategy selected |
|
|
| omit [DecidableEq Q₁] [DecidableEq Q₂] in |
| theorem selectedJointWeight_firstMarginal (G : Game Q₁ Q₂ A₁ A₂) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) |
| (selected : Finset (Fin n)) (tv) : |
| firstMarginal (selectedJointWeight G strategy selected) tv = |
| selectedSideWeight G strategy selected tv := by |
| simp only [firstMarginal, selectedJointWeight, selectedSideWeight, selectedSideMass, |
| div_eq_mul_inv, Finset.mul_sum, Finset.sum_mul] |
| apply Finset.sum_congr rfl |
| intro i _ |
| ring |
|
|
| theorem selectedJointWeight_isProbability (G : Game Q₁ Q₂ A₁ A₂) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) |
| (selected : Finset (Fin n)) (positive : 0 < G.selectedSuccess strategy selected) : |
| IsProbability (selectedJointWeight G strategy selected) := by |
| constructor |
| · exact selectedJointWeight_nonnegative G strategy selected |
| · rw [Fintype.sum_prod_type] |
| change (∑ tv, firstMarginal (selectedJointWeight G strategy selected) tv) = 1 |
| simp_rw [selectedJointWeight_firstMarginal, selectedSideWeight, div_eq_mul_inv] |
| rw [← Finset.sum_mul, selectedSideMass_total, mul_inv_cancel₀ positive.ne'] |
|
|
| def selectedJointLaw (G : Game Q₁ Q₂ A₁ A₂) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) |
| (selected : Finset (Fin n)) (positive : 0 < G.selectedSuccess strategy selected) := |
| toGameLaw (selectedJointWeight G strategy selected) |
| (selectedJointWeight_isProbability G strategy selected positive) |
|
|
| theorem selectedJointWeight_factorization (G : Game Q₁ Q₂ A₁ A₂) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) |
| (selected : Finset (Fin n)) (tv) (u) : |
| selectedJointWeight G strategy selected (tv,u) = |
| (∏ i : selected, G.questions.weight (tv.1.1 i)) * |
| (∏ i : {i : Fin n // i ∉ selected}, (revealLaw G.questions).weight (u i,tv.1.2 i)) * |
| selectedLikelihood G strategy selected tv.1.1 tv.2 u / |
| G.selectedSuccess strategy selected := by |
| unfold selectedJointWeight |
| simp only [selectedInputLaw, FiniteDistribution.product, FiniteDistribution.table, |
| independentProduct, selectedInputProfile] |
| rw [mul_assoc (∏ i : selected, G.questions.weight (tv.1.1 i)), reveal_product_factorization] |
|
|
| end |
|
|
| open scoped BigOperators |
| open Games Information |
|
|
| variable {Q₁ Q₂ A₁ A₂ : Type*} |
| [Fintype Q₁] [Fintype Q₂] [Fintype A₁] [Fintype A₂] |
| [DecidableEq Q₁] [DecidableEq Q₂] |
| {n : Nat} |
|
|
| def selectedTupleLikelihood (G : Game Q₁ Q₂ A₁ A₂) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) |
| (selected : Finset (Fin n)) (questions : Fin n → Q₁ × Q₂) : ℝ := |
| if G.selectedWins strategy selected (Game.tupleQuestionEquiv n questions) then 1 else 0 |
|
|
| omit [DecidableEq Q₁] [DecidableEq Q₂] in |
| theorem selectedTupleLikelihood_nonnegative (G : Game Q₁ Q₂ A₁ A₂) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) |
| (selected : Finset (Fin n)) (questions : Fin n → Q₁ × Q₂) : |
| 0 ≤ selectedTupleLikelihood G strategy selected questions := by |
| unfold selectedTupleLikelihood |
| split <;> norm_num |
|
|
| omit [DecidableEq Q₁] [DecidableEq Q₂] in |
| theorem selectedTupleLikelihood_le_one (G : Game Q₁ Q₂ A₁ A₂) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) |
| (selected : Finset (Fin n)) (questions : Fin n → Q₁ × Q₂) : |
| selectedTupleLikelihood G strategy selected questions ≤ 1 := by |
| unfold selectedTupleLikelihood |
| split <;> norm_num |
|
|
| omit [DecidableEq Q₁] [DecidableEq Q₂] in |
| theorem selectedTupleLikelihood_mass (G : Game Q₁ Q₂ A₁ A₂) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) |
| (selected : Finset (Fin n)) : |
| (∑ questions, independentProduct (fun _ : Fin n => G.questions.weight) questions * |
| selectedTupleLikelihood G strategy selected questions) = |
| G.selectedSuccess strategy selected := by |
| classical |
| change _ = ((G.questions.iid n).transport (Game.tupleQuestionEquiv n)).probability |
| (G.selectedWins strategy selected) |
| rw [FiniteDistribution.probability_transport] |
| simp only [FiniteDistribution.probability, FiniteDistribution.iid, independentProduct, |
| selectedTupleLikelihood, mul_ite, mul_one, mul_zero] |
|
|
| def selectedQuestionMarginal (G : Game Q₁ Q₂ A₁ A₂) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) |
| (selected : Finset (Fin n)) (positive : 0 < G.selectedSuccess strategy selected) |
| (i : Fin n) : FiniteDistribution (Q₁ × Q₂) := |
| ((G.repetition n).questions.condition (G.selectedWins strategy selected) positive).pushforward |
| (fun questions => (questions.1 i, questions.2 i)) |
|
|
| theorem selectedQuestionMarginal_weight (G : Game Q₁ Q₂ A₁ A₂) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) |
| (selected : Finset (Fin n)) (positive : 0 < G.selectedSuccess strategy selected) |
| (i : Fin n) : |
| (selectedQuestionMarginal G strategy selected positive i).weight = |
| coordinateMarginal |
| (posterior (independentProduct (fun _ : Fin n => G.questions.weight)) |
| (selectedTupleLikelihood G strategy selected) (G.selectedSuccess strategy selected)) i := by |
| classical |
| funext a |
| simp only [selectedQuestionMarginal, FiniteDistribution.pushforward, |
| FiniteDistribution.condition, coordinateMarginal] |
| refine Fintype.sum_equiv (Game.tupleQuestionEquiv (Q₁ := Q₁) (Q₂ := Q₂) n).symm _ _ ?_ |
| intro questions |
| cases he : G.selectedWins strategy selected questions <;> |
| simp [Game.repetition_question_weight, Game.tupleQuestionEquiv, |
| posterior, independentProduct, selectedTupleLikelihood, Game.selectedSuccess, he] |
|
|
| theorem selectedQuestionMarginal_totalVariation_sq_sum_le_log |
| (G : Game Q₁ Q₂ A₁ A₂) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) |
| (selected : Finset (Fin n)) (positive : 0 < G.selectedSuccess strategy selected) : |
| (∑ i : Fin n, |
| (selectedQuestionMarginal G strategy selected positive i).totalVariation G.questions ^ 2) ≤ |
| Real.log (1 / G.selectedSuccess strategy selected) := by |
| classical |
| change (∑ i : Fin n, Information.totalVariation |
| (selectedQuestionMarginal G strategy selected positive i).weight G.questions.weight ^ 2) ≤ _ |
| simp_rw [selectedQuestionMarginal_weight] |
| exact posterior_coordinate_totalVariation_sq_sum_le_log |
| (fun _ : Fin n => G.questions.weight) (fun _ => gameLaw_isProbability G.questions) |
| (selectedTupleLikelihood G strategy selected) |
| (selectedTupleLikelihood_nonnegative G strategy selected) |
| (selectedTupleLikelihood_le_one G strategy selected) |
| positive (selectedTupleLikelihood_mass G strategy selected) |
|
|
| theorem unselectedQuestionMarginal_totalVariation_sq_sum_le_log |
| (G : Game Q₁ Q₂ A₁ A₂) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) |
| (selected : Finset (Fin n)) (positive : 0 < G.selectedSuccess strategy selected) : |
| (∑ i : {i : Fin n // i ∉ selected}, |
| (selectedQuestionMarginal G strategy selected positive i.1).totalVariation G.questions ^ 2) ≤ |
| Real.log (1 / G.selectedSuccess strategy selected) := by |
| classical |
| let d : Fin n → ℝ := fun i => |
| (selectedQuestionMarginal G strategy selected positive i).totalVariation G.questions |
| have hfull := selectedQuestionMarginal_totalVariation_sq_sum_le_log G strategy selected positive |
| have hsplit := Fintype.sum_subtype_add_sum_subtype (fun i : Fin n => i ∈ selected) |
| (fun i => d i ^ 2) |
| have hinst : Subtype.fintype (fun i : Fin n => i ∈ selected) = |
| Finset.Subtype.fintype selected := Subsingleton.elim _ _ |
| rw [hinst] at hsplit |
| have hselected : 0 ≤ ∑ i : {i : Fin n // i ∈ selected}, d i.1 ^ 2 := |
| Finset.sum_nonneg (fun _ _ => sq_nonneg _) |
| change (∑ i : {i : Fin n // i ∉ selected}, d i.1 ^ 2) ≤ _ |
| change (∑ i : Fin n, d i ^ 2) ≤ _ at hfull |
| linarith |
|
|
| theorem unselectedQuestionMarginal_totalVariation_sum_le_sqrt |
| (G : Game Q₁ Q₂ A₁ A₂) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) |
| (selected : Finset (Fin n)) (positive : 0 < G.selectedSuccess strategy selected) : |
| (∑ i : {i : Fin n // i ∉ selected}, |
| (selectedQuestionMarginal G strategy selected positive i.1).totalVariation G.questions) ≤ |
| Real.sqrt ((Fintype.card {i : Fin n // i ∉ selected} : ℝ) * |
| Real.log (1 / G.selectedSuccess strategy selected)) := by |
| classical |
| let d : {i : Fin n // i ∉ selected} → ℝ := fun i => |
| (selectedQuestionMarginal G strategy selected positive i.1).totalVariation G.questions |
| have hsq := unselectedQuestionMarginal_totalVariation_sq_sum_le_log G strategy selected positive |
| have hcs := Finset.sum_mul_sq_le_sq_mul_sq |
| (Finset.univ : Finset {i : Fin n // i ∉ selected}) d (fun _ => (1 : ℝ)) |
| simp only [mul_one, one_pow, Finset.sum_const, Finset.card_univ, nsmul_eq_mul, mul_one] at hcs |
| have hln : 0 ≤ Real.log (1 / G.selectedSuccess strategy selected) := |
| (Finset.sum_nonneg (fun _ _ => sq_nonneg _)).trans hsq |
| have hcard : 0 ≤ (Fintype.card {i : Fin n // i ∉ selected} : ℝ) := Nat.cast_nonneg _ |
| have hmul := mul_le_mul_of_nonneg_left hsq hcard |
| have hsqrt := Real.sq_sqrt (mul_nonneg hcard hln) |
| have hsqrtpos := Real.sqrt_nonneg |
| ((Fintype.card {i : Fin n // i ∉ selected} : ℝ) * |
| Real.log (1 / G.selectedSuccess strategy selected)) |
| change (∑ i, d i) ≤ _ |
| change (∑ i, d i ^ 2) ≤ _ at hsq |
| change (Fintype.card {i : Fin n // i ∉ selected} : ℝ) * (∑ i, d i ^ 2) ≤ _ at hmul |
| nlinarith |
|
|
| theorem unselectedQuestionMarginal_totalVariation_sum_le_sqrt_sub_card |
| (G : Game Q₁ Q₂ A₁ A₂) |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) |
| (selected : Finset (Fin n)) (positive : 0 < G.selectedSuccess strategy selected) : |
| (∑ i : {i : Fin n // i ∉ selected}, |
| (selectedQuestionMarginal G strategy selected positive i.1).totalVariation G.questions) ≤ |
| Real.sqrt (((n - selected.card : Nat) : ℝ) * |
| Real.log (1 / G.selectedSuccess strategy selected)) := by |
| classical |
| have hcard : Fintype.card {i : Fin n // i ∉ selected} = n - selected.card := by |
| simp |
| simpa only [hcard] using |
| unselectedQuestionMarginal_totalVariation_sum_le_sqrt G strategy selected positive |
|
|
| end BinPackingGames.Foundations.Repetition |
|
|
| end |
|
|
| end OAI |
|
|
