openAI-math-dataset / lean /OAI /Computability /UniqueGames /Games /SelectedCommonMarginalLemmas.lean
| import OAI.Computability.UniqueGames.Foundations.SamplingLemmas | |
| import OAI.Computability.UniqueGames.Foundations.SharedProfiles | |
| import OAI.Computability.UniqueGames.Foundations.ValueLemmas | |
| import OAI.Computability.UniqueGames.Games.FactorizationLemmas | |
| import OAI.Computability.UniqueGames.Games.Overlap | |
| import OAI.Computability.UniqueGames.Games.PartialRevealLemmas | |
| import OAI.Computability.UniqueGames.Games.SelectedInformationLemmas | |
| namespace OAI | |
| section | |
| /-! The common-data law has exactly the actual selected-event question marginal. | |
| Removing the fair endpoint reveal and regrouping the outside data preserve | |
| the embedded question pair. -/ | |
| namespace UniqueGamesTheorem.Foundations.Repetition | |
| open scoped BigOperators | |
| open Games Information | |
| noncomputable section | |
| theorem pushforward_snd_weight_eq_secondMarginal {A B : Type*} | |
| [Fintype A] [Fintype B] (μ : FiniteDistribution (A × B)) : | |
| (μ.pushforward Prod.snd).weight = secondMarginal μ.weight := by | |
| classical | |
| funext b | |
| simp [FiniteDistribution.pushforward, secondMarginal, Fintype.sum_prod_type] | |
| variable {I T X Y : Type*} [Fintype I] [DecidableEq I] [Fintype T] | |
| [Fintype X] [Fintype Y] [DecidableEq X] [DecidableEq Y] | |
| def revealDataSplitEquiv (j : I) : | |
| (T × (I → X ⊕ Y)) ≃ ((T × ({i : I // i ≠ j} → X ⊕ Y)) × (X ⊕ Y)) where | |
| toFun z := ((z.1, fun i => z.2 i.1), z.2 j) | |
| invFun z := (z.1.1, mergeAt j z.2 z.1.2) | |
| left_inv z := by | |
| apply Prod.ext | |
| · rfl | |
| · funext i | |
| by_cases h : i = j <;> simp [mergeAt, h] | |
| right_inv z := by | |
| apply Prod.ext | |
| · apply Prod.ext | |
| · rfl | |
| · funext i | |
| exact mergeAt_other j z.2 z.1.2 i | |
| · exact mergeAt_self j z.2 z.1.2 | |
| theorem partialRevealMarginal_secondMarginal | |
| (μ : FiniteDistribution (X × Y)) (j : I) | |
| (likelihood : T → (I → X × Y) → ℝ) : | |
| secondMarginal (partialRevealMarginal μ j likelihood) = | |
| secondMarginal (fullRevealMarginal μ j likelihood) := by | |
| classical | |
| funext q | |
| calc | |
| _ = ∑ z : (T × ({i : I // i ≠ j} → X ⊕ Y)) × (X ⊕ Y), | |
| maskedJoint (partialRevealMarginal μ j likelihood) (z,q) := by | |
| simp [secondMarginal, Fintype.sum_prod_type, maskedJoint] | |
| _ = _ := by | |
| apply Fintype.sum_equiv (revealDataSplitEquiv (T := T) j).symm | |
| intro z | |
| exact (fullRevealMarginal_merge μ j likelihood z.1.1 z.1.2 z.2 q).symm | |
| variable {Q₁ Q₂ A₁ A₂ : Type*} | |
| [Fintype Q₁] [Fintype Q₂] [Fintype A₁] [Fintype A₂] | |
| [DecidableEq Q₁] [DecidableEq Q₂] {n : Nat} | |
| def selectedObservationDataEquiv (selected : Finset (Fin n)) : | |
| (SelectedInput Q₁ Q₂ selected × SelectedLabels (A₁ := A₁) (A₂ := A₂) selected) ≃ | |
| (((selected → Q₁ × Q₂) × SelectedLabels (A₁ := A₁) (A₂ := A₂) selected) × | |
| ({i : Fin n // i ∉ selected} → Q₁ ⊕ Q₂)) where | |
| toFun z := ((z.1.1,z.2),z.1.2) | |
| invFun z := ((z.1.1,z.2),z.1.2) | |
| left_inv _ := rfl | |
| right_inv _ := rfl | |
| theorem selectedFullReveal_secondMarginal (G : Game Q₁ Q₂ A₁ A₂) | |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) | |
| (selected : Finset (Fin n)) (j : {i : Fin n // i ∉ selected}) : | |
| secondMarginal (fullRevealMarginal G.questions j | |
| (selectedOutsideLikelihood G strategy selected)) = | |
| secondMarginal (selectedRawMarginal G strategy selected j) := by | |
| classical | |
| funext q | |
| apply Fintype.sum_equiv | |
| (selectedObservationDataEquiv (Q₁ := Q₁) (Q₂ := Q₂) | |
| (A₁ := A₁) (A₂ := A₂) selected).symm | |
| intro z | |
| exact (selectedRawMarginal_fullReveal G strategy selected j (z,q)).symm | |
| theorem selectedRawMarginal_secondMarginal (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) | |
| (j : {i : Fin n // i ∉ selected}) : | |
| secondMarginal (selectedRawMarginal G strategy selected j) = | |
| (selectedQuestionMarginal G strategy selected positive j.1).weight := by | |
| classical | |
| funext q | |
| calc | |
| _ = (selectedJointLaw G strategy selected positive).probability | |
| (fun z => decide (z.2 j = q)) := by | |
| simp only [secondMarginal, selectedRawMarginal, FiniteDistribution.probability, | |
| selectedJointLaw, toGameLaw, Fintype.sum_prod_type, decide_eq_true_eq] | |
| _ = ((G.repetition n).questions.condition (G.selectedWins strategy selected) positive).probability | |
| (fun questions => decide ((questions.1 j.1,questions.2 j.1) = q)) := by | |
| have h := selectedJointLaw_question_probability G strategy selected positive | |
| (fun questions => decide ((questions.1 j.1,questions.2 j.1) = q)) | |
| simpa [selectedQuestionTuple, mergeCoordinates, j.property] using h | |
| _ = _ := by | |
| rw [FiniteDistribution.weight_eq_probability_singleton, selectedQuestionMarginal, | |
| FiniteDistribution.probability_pushforward] | |
| /-- The exact marginal identification needed to use the conditioned-question | |
| information bound in the two local common-data profile errors. -/ | |
| theorem selectedCommonLaw_secondMarginal (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) | |
| (j : {i : Fin n // i ∉ selected}) : | |
| secondMarginal (selectedCommonLaw G strategy selected positive j).weight = | |
| (selectedQuestionMarginal G strategy selected positive j.1).weight := by | |
| change secondMarginal (partialRevealMarginal G.questions j | |
| (selectedOutsideLikelihood G strategy selected)) = _ | |
| rw [partialRevealMarginal_secondMarginal, selectedFullReveal_secondMarginal] | |
| exact selectedRawMarginal_secondMarginal G strategy selected positive j | |
| theorem selectedCommonLaw_questions_pushforward (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) | |
| (j : {i : Fin n // i ∉ selected}) : | |
| (selectedCommonLaw G strategy selected positive j).pushforward Prod.snd = | |
| selectedQuestionMarginal G strategy selected positive j.1 := by | |
| classical | |
| apply FiniteDistribution.eq_of_weight_eq | |
| intro q | |
| exact (congrFun (pushforward_snd_weight_eq_secondMarginal | |
| (selectedCommonLaw G strategy selected positive j)) q).trans | |
| (congrFun (selectedCommonLaw_secondMarginal G strategy selected positive j) q) | |
| end | |
| end UniqueGamesTheorem.Foundations.Repetition | |
| end | |
| section | |
| /-! | |
| Actual local completions of the unused questions, conditioned on common data | |
| and the player's own embedded question. The raw row factors are explicit | |
| finite weights. Their normalization reconstructs the actual selected common | |
| law, including zero rows. The fallback independently samples base marginal | |
| questions and then inserts the local input at the embedded coordinate. | |
| -/ | |
| namespace UniqueGamesTheorem.Foundations.Repetition | |
| open scoped BigOperators | |
| open Games | |
| noncomputable section | |
| section LocalNormalization | |
| variable {I X Y : Type*} [Fintype I] [DecidableEq I] | |
| [Fintype X] [Fintype Y] | |
| def completionTupleEquiv : (I → X × Y) ≃ ((I → X) × (I → Y)) where | |
| toFun u := (fun i => (u i).1, fun i => (u i).2) | |
| invFun z := fun i => (z.1 i, z.2 i) | |
| left_inv u := by funext i; rfl | |
| right_inv z := by cases z; rfl | |
| def updatedTableFallback (μ : FiniteDistribution X) (j : I) (x : X) : | |
| FiniteDistribution (I → X) := | |
| (FiniteDistribution.table (fun _ : I => μ)).pushforward | |
| (fun l => Function.update l j x) | |
| theorem updatedTableFallback_zero (μ : FiniteDistribution X) (j : I) (x : X) | |
| (l : I → X) (hne : l j ≠ x) : | |
| (updatedTableFallback μ j x).weight l = 0 := by | |
| classical | |
| simp only [updatedTableFallback, FiniteDistribution.pushforward] | |
| apply Finset.sum_eq_zero | |
| intro t _ | |
| apply ite_eq_right | |
| intro h | |
| have he := congrFun h j | |
| exact hne (by simpa only [Function.update_self] using he.symm) | |
| theorem normalizeOr_weight_eq_zero_of_zero | |
| (w : X → ℝ) (hw : ∀ x, 0 ≤ w x) (fallback : FiniteDistribution X) | |
| (x : X) (hraw : w x = 0) (hdefault : fallback.weight x = 0) : | |
| (normalizeOr w hw fallback).weight x = 0 := by | |
| classical | |
| unfold normalizeOr | |
| split | |
| · change normalizedWeight w x = 0 | |
| simp only [normalizedWeight, hraw, zero_div] | |
| · exact hdefault | |
| end LocalNormalization | |
| variable {Q₁ Q₂ A₁ A₂ : Type*} | |
| [Fintype Q₁] [Fintype Q₂] [Fintype A₁] [Fintype A₂] | |
| [DecidableEq Q₁] [DecidableEq Q₂] {n : Nat} | |
| def selectedLeftRaw (G : Game Q₁ Q₂ A₁ A₂) | |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) | |
| (selected : Finset (Fin n)) (j : {i : Fin n // i ∉ selected}) | |
| (s : SelectedCommonData (Q₁ := Q₁) (Q₂ := Q₂) (A₁ := A₁) (A₂ := A₂) selected j) | |
| (x : Q₁) (l : {i : Fin n // i ∉ selected} → Q₁) : ℝ := | |
| (if l j = x then 1 else 0) * partialLeftFactor G.questions j s.2 l * | |
| selectedLocalTest strategy.1 selected (fun i => (s.1.1 i).1) s.1.2.1 l | |
| def selectedRightRaw (G : Game Q₁ Q₂ A₁ A₂) | |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) | |
| (selected : Finset (Fin n)) (j : {i : Fin n // i ∉ selected}) | |
| (s : SelectedCommonData (Q₁ := Q₁) (Q₂ := Q₂) (A₁ := A₁) (A₂ := A₂) selected j) | |
| (y : Q₂) (r : {i : Fin n // i ∉ selected} → Q₂) : ℝ := | |
| (if r j = y then 1 else 0) * partialRightFactor G.questions j s.2 r * | |
| selectedLocalTest strategy.2 selected (fun i => (s.1.1 i).2) s.1.2.2 r | |
| omit [DecidableEq Q₂] in | |
| theorem selectedLeftRaw_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)) (j : {i : Fin n // i ∉ selected}) | |
| (s : SelectedCommonData (Q₁ := Q₁) (Q₂ := Q₂) (A₁ := A₁) (A₂ := A₂) selected j) | |
| (x : Q₁) (l : {i : Fin n // i ∉ selected} → Q₁) : | |
| 0 ≤ selectedLeftRaw G strategy selected j s x l := by | |
| apply mul_nonneg | |
| · apply mul_nonneg | |
| · split <;> norm_num | |
| · exact Finset.prod_nonneg (fun i _ => revealLeftFactor_nonnegative G.questions (s.2 i) (l i.1)) | |
| · exact selectedLocalTest_nonnegative _ _ _ _ _ | |
| omit [DecidableEq Q₁] in | |
| theorem selectedRightRaw_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)) (j : {i : Fin n // i ∉ selected}) | |
| (s : SelectedCommonData (Q₁ := Q₁) (Q₂ := Q₂) (A₁ := A₁) (A₂ := A₂) selected j) | |
| (y : Q₂) (r : {i : Fin n // i ∉ selected} → Q₂) : | |
| 0 ≤ selectedRightRaw G strategy selected j s y r := by | |
| apply mul_nonneg | |
| · apply mul_nonneg | |
| · split <;> norm_num | |
| · exact Finset.prod_nonneg (fun i _ => revealRightFactor_nonnegative G.questions (s.2 i) (r i.1)) | |
| · exact selectedLocalTest_nonnegative _ _ _ _ _ | |
| def selectedLeftCompletion (G : Game Q₁ Q₂ A₁ A₂) | |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) | |
| (selected : Finset (Fin n)) (j : {i : Fin n // i ∉ selected}) | |
| (s : SelectedCommonData (Q₁ := Q₁) (Q₂ := Q₂) (A₁ := A₁) (A₂ := A₂) selected j) | |
| (x : Q₁) : FiniteDistribution ({i : Fin n // i ∉ selected} → Q₁) := | |
| normalizeOr (selectedLeftRaw G strategy selected j s x) | |
| (selectedLeftRaw_nonnegative G strategy selected j s x) | |
| (updatedTableFallback (G.questions.pushforward Prod.fst) j x) | |
| def selectedRightCompletion (G : Game Q₁ Q₂ A₁ A₂) | |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) | |
| (selected : Finset (Fin n)) (j : {i : Fin n // i ∉ selected}) | |
| (s : SelectedCommonData (Q₁ := Q₁) (Q₂ := Q₂) (A₁ := A₁) (A₂ := A₂) selected j) | |
| (y : Q₂) : FiniteDistribution ({i : Fin n // i ∉ selected} → Q₂) := | |
| normalizeOr (selectedRightRaw G strategy selected j s y) | |
| (selectedRightRaw_nonnegative G strategy selected j s y) | |
| (updatedTableFallback (G.questions.pushforward Prod.snd) j y) | |
| omit [DecidableEq Q₂] in | |
| theorem selectedLeftCompletion_zero (G : Game Q₁ Q₂ A₁ A₂) | |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) | |
| (selected : Finset (Fin n)) (j : {i : Fin n // i ∉ selected}) | |
| (s : SelectedCommonData (Q₁ := Q₁) (Q₂ := Q₂) (A₁ := A₁) (A₂ := A₂) selected j) | |
| (x : Q₁) (l : {i : Fin n // i ∉ selected} → Q₁) (hne : l j ≠ x) : | |
| (selectedLeftCompletion G strategy selected j s x).weight l = 0 := by | |
| apply normalizeOr_weight_eq_zero_of_zero | |
| · simp only [selectedLeftRaw, ite_eq_right hne, zero_mul] | |
| · exact updatedTableFallback_zero _ j x l hne | |
| omit [DecidableEq Q₁] in | |
| theorem selectedRightCompletion_zero (G : Game Q₁ Q₂ A₁ A₂) | |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) | |
| (selected : Finset (Fin n)) (j : {i : Fin n // i ∉ selected}) | |
| (s : SelectedCommonData (Q₁ := Q₁) (Q₂ := Q₂) (A₁ := A₁) (A₂ := A₂) selected j) | |
| (y : Q₂) (r : {i : Fin n // i ∉ selected} → Q₂) (hne : r j ≠ y) : | |
| (selectedRightCompletion G strategy selected j s y).weight r = 0 := by | |
| apply normalizeOr_weight_eq_zero_of_zero | |
| · simp only [selectedRightRaw, ite_eq_right hne, zero_mul] | |
| · exact updatedTableFallback_zero _ j y r hne | |
| omit [DecidableEq Q₂] in | |
| theorem selectedLeftCompletion_support (G : Game Q₁ Q₂ A₁ A₂) | |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) | |
| (selected : Finset (Fin n)) (j : {i : Fin n // i ∉ selected}) | |
| (s : SelectedCommonData (Q₁ := Q₁) (Q₂ := Q₂) (A₁ := A₁) (A₂ := A₂) selected j) | |
| (x : Q₁) (l : {i : Fin n // i ∉ selected} → Q₁) | |
| (h : (selectedLeftCompletion G strategy selected j s x).weight l ≠ 0) : l j = x := by | |
| by_contra hne | |
| exact h (selectedLeftCompletion_zero G strategy selected j s x l hne) | |
| omit [DecidableEq Q₁] in | |
| theorem selectedRightCompletion_support (G : Game Q₁ Q₂ A₁ A₂) | |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) | |
| (selected : Finset (Fin n)) (j : {i : Fin n // i ∉ selected}) | |
| (s : SelectedCommonData (Q₁ := Q₁) (Q₂ := Q₂) (A₁ := A₁) (A₂ := A₂) selected j) | |
| (y : Q₂) (r : {i : Fin n // i ∉ selected} → Q₂) | |
| (h : (selectedRightCompletion G strategy selected j s y).weight r ≠ 0) : r j = y := by | |
| by_contra hne | |
| exact h (selectedRightCompletion_zero G strategy selected j s y r hne) | |
| def selectedCompletionScale (G : Game Q₁ Q₂ A₁ A₂) | |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) | |
| (selected : Finset (Fin n)) (j : {i : Fin n // i ∉ selected}) | |
| (s : SelectedCommonData (Q₁ := Q₁) (Q₂ := Q₂) (A₁ := A₁) (A₂ := A₂) selected j) | |
| (xy : Q₁ × Q₂) : ℝ := | |
| G.questions.weight xy * (∏ i : selected, G.questions.weight (s.1.1 i)) * | |
| (if selectedLabelAccepts G selected s.1.1 s.1.2 then 1 else 0) / | |
| G.selectedSuccess strategy selected | |
| /-- Pointwise factorization of the actual selected common-data row. -/ | |
| theorem selected_completion_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)) (j : {i : Fin n // i ∉ selected}) | |
| (s : SelectedCommonData (Q₁ := Q₁) (Q₂ := Q₂) (A₁ := A₁) (A₂ := A₂) selected j) | |
| (xy : Q₁ × Q₂) | |
| (l : {i : Fin n // i ∉ selected} → Q₁) | |
| (r : {i : Fin n // i ∉ selected} → Q₂) : | |
| selectedCompletionScale G strategy selected j s xy * | |
| selectedLeftRaw G strategy selected j s xy.1 l * | |
| selectedRightRaw G strategy selected j s xy.2 r = | |
| if (l j, r j) = xy then | |
| partialRevealWeight G.questions j s.2 (fun i => (l i,r i)) * | |
| selectedOutsideLikelihood G strategy selected s.1 (fun i => (l i,r i)) | |
| else 0 := by | |
| rcases xy with ⟨x,y⟩ | |
| by_cases hl : l j = x <;> by_cases hr : r j = y | |
| · rw [ite_eq_left (Prod.ext hl hr), partialRevealWeight_factorization] | |
| cases hacc : selectedLabelAccepts G selected s.1.1 s.1.2 <;> | |
| simp [selectedOutsideLikelihood, selectedLikelihood_factorization, | |
| selectedCompletionScale, selectedLeftRaw, selectedRightRaw, hl, hr, hacc] | |
| ring | |
| · simp [selectedLeftRaw, selectedRightRaw, hl, hr, Prod.mk.injEq] | |
| · simp [selectedLeftRaw, selectedRightRaw, hl, hr, Prod.mk.injEq] | |
| · simp [selectedLeftRaw, selectedRightRaw, hl, hr, Prod.mk.injEq] | |
| theorem selectedCommonLaw_completion_row_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)) (positive : 0 < G.selectedSuccess strategy selected) | |
| (j : {i : Fin n // i ∉ selected}) | |
| (s : SelectedCommonData (Q₁ := Q₁) (Q₂ := Q₂) (A₁ := A₁) (A₂ := A₂) selected j) | |
| (xy : Q₁ × Q₂) : | |
| (selectedCommonLaw G strategy selected positive j).weight (s,xy) = | |
| ∑ lr : ({i : Fin n // i ∉ selected} → Q₁) × | |
| ({i : Fin n // i ∉ selected} → Q₂), | |
| selectedCompletionScale G strategy selected j s xy * | |
| selectedLeftRaw G strategy selected j s xy.1 lr.1 * | |
| selectedRightRaw G strategy selected j s xy.2 lr.2 := by | |
| classical | |
| change (∑ u, if u j = xy then partialRevealWeight G.questions j s.2 u * | |
| selectedOutsideLikelihood G strategy selected s.1 u else 0) = _ | |
| rw [← (completionTupleEquiv (I := {i : Fin n // i ∉ selected}) | |
| (X := Q₁) (Y := Q₂)).sum_comp] | |
| apply Finset.sum_congr rfl | |
| intro u _ | |
| exact (selected_completion_factorization G strategy selected j s xy | |
| (fun i => (u i).1) (fun i => (u i).2)).symm | |
| /-- Actual common-row mass times the two local completion probabilities is | |
| the selected partial-reveal weight with its actual coordinate indicator. -/ | |
| theorem selected_completion_row_recombine (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) | |
| (j : {i : Fin n // i ∉ selected}) | |
| (s : SelectedCommonData (Q₁ := Q₁) (Q₂ := Q₂) (A₁ := A₁) (A₂ := A₂) selected j) | |
| (xy : Q₁ × Q₂) | |
| (l : {i : Fin n // i ∉ selected} → Q₁) | |
| (r : {i : Fin n // i ∉ selected} → Q₂) : | |
| (selectedCommonLaw G strategy selected positive j).weight (s,xy) * | |
| ((selectedLeftCompletion G strategy selected j s xy.1).product | |
| (selectedRightCompletion G strategy selected j s xy.2)).weight (l,r) = | |
| if (l j,r j) = xy then | |
| partialRevealWeight G.questions j s.2 (fun i => (l i,r i)) * | |
| selectedOutsideLikelihood G strategy selected s.1 (fun i => (l i,r i)) | |
| else 0 := by | |
| rw [selectedCommonLaw_completion_row_mass] | |
| calc | |
| _ = selectedCompletionScale G strategy selected j s xy * | |
| selectedLeftRaw G strategy selected j s xy.1 l * | |
| selectedRightRaw G strategy selected j s xy.2 r := | |
| factorized_completion_row | |
| (selectedLeftRaw G strategy selected j s xy.1) | |
| (selectedRightRaw G strategy selected j s xy.2) | |
| (selectedLeftRaw_nonnegative G strategy selected j s xy.1) | |
| (selectedRightRaw_nonnegative G strategy selected j s xy.2) | |
| (updatedTableFallback (G.questions.pushforward Prod.fst) j xy.1) | |
| (updatedTableFallback (G.questions.pushforward Prod.snd) j xy.2) | |
| (selectedCompletionScale G strategy selected j s xy) (l,r) | |
| _ = _ := selected_completion_factorization G strategy selected j s xy l r | |
| end | |
| end UniqueGamesTheorem.Foundations.Repetition | |
| end | |
| section | |
| /-! The actual local completion mixture reproduces the repeated question law | |
| conditioned on the selected wins. All hidden coordinates and reveal variables | |
| are explicitly summed out. -/ | |
| namespace UniqueGamesTheorem.Foundations.Repetition | |
| open scoped BigOperators | |
| open Games | |
| noncomputable section | |
| theorem partialRevealWeight_forget | |
| {I X Y : Type*} [Fintype I] [DecidableEq I] | |
| [Fintype X] [Fintype Y] [DecidableEq X] [DecidableEq Y] | |
| (μ : FiniteDistribution (X × Y)) (j : I) (u : I → X × Y) : | |
| (∑ rest : {i : I // i ≠ j} → X ⊕ Y, partialRevealWeight μ j rest u) = | |
| ∏ i, μ.weight (u i) := by | |
| have h := reveal_product_forget μ (fun i : {i : I // i ≠ j} => u i.1) | |
| simp_rw [reveal_product_factorization] at h | |
| simp only [partialRevealWeight, ← Finset.mul_sum] | |
| rw [h] | |
| exact (Fintype.prod_eq_mul_prod_subtype_ne (fun i => μ.weight (u i)) j).symm | |
| theorem partialReveal_event_forget | |
| {I X Y : Type*} [Fintype I] [DecidableEq I] | |
| [Fintype X] [Fintype Y] [DecidableEq X] [DecidableEq Y] | |
| (μ : FiniteDistribution (X × Y)) (j : I) (f : (I → X × Y) → ℝ) : | |
| (∑ rest : {i : I // i ≠ j} → X ⊕ Y, | |
| ∑ u : I → X × Y, partialRevealWeight μ j rest u * f u) = | |
| ∑ u, (∏ i, μ.weight (u i)) * f u := by | |
| rw [Finset.sum_comm] | |
| apply Finset.sum_congr rfl | |
| intro u _ | |
| rw [← Finset.sum_mul, partialRevealWeight_forget] | |
| variable {Q₁ Q₂ A₁ A₂ : Type*} | |
| [Fintype Q₁] [Fintype Q₂] [Fintype A₁] [Fintype A₂] | |
| [DecidableEq Q₁] [DecidableEq Q₂] {n : Nat} | |
| omit [DecidableEq Q₁] [DecidableEq Q₂] in | |
| theorem selectedOutsideLikelihood_event_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)) | |
| (event : ((Fin n → Q₁) × (Fin n → Q₂)) → Bool) : | |
| (∑ t : (selected → Q₁ × Q₂) × SelectedLabels (A₁ := A₁) (A₂ := A₂) selected, | |
| ∑ u : {i : Fin n // i ∉ selected} → Q₁ × Q₂, | |
| (∏ i, G.questions.weight (u i)) * selectedOutsideLikelihood G strategy selected t u * | |
| (if event (selectedQuestionTuple selected t.1 u) then 1 else 0)) = | |
| (G.repetition n).questions.probability | |
| (fun q => G.selectedWins strategy selected q && event q) / | |
| G.selectedSuccess strategy selected := by | |
| classical | |
| have hlabel (fixed : selected → Q₁ × Q₂) | |
| (u : {i : Fin n // i ∉ selected} → Q₁ × Q₂) : | |
| (∑ label : SelectedLabels (A₁ := A₁) (A₂ := A₂) selected, | |
| (∏ i, G.questions.weight (u i)) * | |
| selectedOutsideLikelihood G strategy selected (fixed,label) u * | |
| (if event (selectedQuestionTuple selected fixed u) then 1 else 0)) = | |
| ((∏ i : selected, G.questions.weight (fixed i)) * (∏ i, G.questions.weight (u i)) * | |
| (if G.selectedWins strategy selected (selectedQuestionTuple selected fixed u) && | |
| event (selectedQuestionTuple selected fixed u) then 1 else 0)) / | |
| G.selectedSuccess strategy selected := by | |
| calc | |
| _ = (∏ i, G.questions.weight (u i)) * | |
| (∏ i : selected, G.questions.weight (fixed i)) * | |
| (∑ label, selectedLikelihood G strategy selected fixed label u) * | |
| (if event (selectedQuestionTuple selected fixed u) then 1 else 0) / | |
| G.selectedSuccess strategy selected := by | |
| simp only [selectedOutsideLikelihood, div_eq_mul_inv, Finset.mul_sum, Finset.sum_mul] | |
| apply Finset.sum_congr rfl | |
| intro label _ | |
| ring | |
| _ = _ := by | |
| rw [selectedLikelihood_sum] | |
| cases hw : G.selectedWins strategy selected (selectedQuestionTuple selected fixed u) <;> | |
| cases he : event (selectedQuestionTuple selected fixed u) <;> simp | |
| ring | |
| calc | |
| _ = ∑ fixed : selected → Q₁ × Q₂, | |
| ∑ u : {i : Fin n // i ∉ selected} → Q₁ × Q₂, | |
| ∑ label : SelectedLabels (A₁ := A₁) (A₂ := A₂) selected, | |
| (∏ i, G.questions.weight (u i)) * | |
| selectedOutsideLikelihood G strategy selected (fixed,label) u * | |
| (if event (selectedQuestionTuple selected fixed u) then 1 else 0) := by | |
| rw [Fintype.sum_prod_type] | |
| apply Finset.sum_congr rfl | |
| intro fixed _ | |
| rw [Finset.sum_comm] | |
| _ = (∑ fixed : selected → Q₁ × Q₂, | |
| ∑ u : {i : Fin n // i ∉ selected} → Q₁ × Q₂, | |
| (∏ i : selected, G.questions.weight (fixed i)) * (∏ i, G.questions.weight (u i)) * | |
| (if G.selectedWins strategy selected (selectedQuestionTuple selected fixed u) && | |
| event (selectedQuestionTuple selected fixed u) then 1 else 0)) / | |
| G.selectedSuccess strategy selected := by | |
| simp_rw [hlabel] | |
| simp only [div_eq_mul_inv, Finset.sum_mul] | |
| _ = _ := by | |
| congr 1 | |
| have h := selectedSplit_question_probability G selected | |
| (fun q => G.selectedWins strategy selected q && event q) | |
| simpa [selectedSplitLaw, FiniteDistribution.probability, FiniteDistribution.product, | |
| FiniteDistribution.table, Fintype.sum_prod_type, mul_ite] using h | |
| theorem selected_partial_event_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)) (j : {i : Fin n // i ∉ selected}) | |
| (event : ((Fin n → Q₁) × (Fin n → Q₂)) → Bool) : | |
| (∑ s : SelectedCommonData (Q₁ := Q₁) (Q₂ := Q₂) (A₁ := A₁) (A₂ := A₂) selected j, | |
| ∑ u : {i : Fin n // i ∉ selected} → Q₁ × Q₂, | |
| partialRevealWeight G.questions j s.2 u * | |
| selectedOutsideLikelihood G strategy selected s.1 u * | |
| (if event (selectedQuestionTuple selected s.1.1 u) then 1 else 0)) = | |
| (G.repetition n).questions.probability | |
| (fun q => G.selectedWins strategy selected q && event q) / | |
| G.selectedSuccess strategy selected := by | |
| have hrest (t : (selected → Q₁ × Q₂) × SelectedLabels (A₁ := A₁) (A₂ := A₂) selected) := | |
| partialReveal_event_forget G.questions j | |
| (fun u => selectedOutsideLikelihood G strategy selected t u * | |
| (if event (selectedQuestionTuple selected t.1 u) then 1 else 0)) | |
| simp only [← mul_assoc] at hrest | |
| rw [Fintype.sum_prod_type] | |
| simp_rw [hrest] | |
| exact selectedOutsideLikelihood_event_sum G strategy selected event | |
| def selectedFullLeftCompletion (G : Game Q₁ Q₂ A₁ A₂) | |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) | |
| (selected : Finset (Fin n)) (j : {i : Fin n // i ∉ selected}) | |
| (q : Q₁ × SelectedCommonData (Q₁ := Q₁) (Q₂ := Q₂) (A₁ := A₁) (A₂ := A₂) selected j) : | |
| FiniteDistribution (Fin n → Q₁) := | |
| (selectedLeftCompletion G strategy selected j q.2 q.1).pushforward | |
| (mergeCoordinates selected (fun i => (q.2.1.1 i).1)) | |
| def selectedFullRightCompletion (G : Game Q₁ Q₂ A₁ A₂) | |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) | |
| (selected : Finset (Fin n)) (j : {i : Fin n // i ∉ selected}) | |
| (q : Q₂ × SelectedCommonData (Q₁ := Q₁) (Q₂ := Q₂) (A₁ := A₁) (A₂ := A₂) selected j) : | |
| FiniteDistribution (Fin n → Q₂) := | |
| (selectedRightCompletion G strategy selected j q.2 q.1).pushforward | |
| (mergeCoordinates selected (fun i => (q.2.1.1 i).2)) | |
| omit [DecidableEq Q₂] in | |
| theorem selectedFullLeftCompletion_support (G : Game Q₁ Q₂ A₁ A₂) | |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) | |
| (selected : Finset (Fin n)) (j : {i : Fin n // i ∉ selected}) | |
| (q : Q₁ × SelectedCommonData (Q₁ := Q₁) (Q₂ := Q₂) (A₁ := A₁) (A₂ := A₂) selected j) | |
| (l : Fin n → Q₁) (h : (selectedFullLeftCompletion G strategy selected j q).weight l ≠ 0) : | |
| l j.1 = q.1 := by | |
| classical | |
| by_contra hne | |
| apply h | |
| simp only [selectedFullLeftCompletion, FiniteDistribution.pushforward] | |
| apply Finset.sum_eq_zero | |
| intro t _ | |
| split | |
| · rename_i he | |
| apply selectedLeftCompletion_zero | |
| intro ht | |
| apply hne | |
| have hcoord := congrFun he j.1 | |
| simpa [mergeCoordinates, j.property, ht] using hcoord.symm | |
| · rfl | |
| omit [DecidableEq Q₁] in | |
| theorem selectedFullRightCompletion_support (G : Game Q₁ Q₂ A₁ A₂) | |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) | |
| (selected : Finset (Fin n)) (j : {i : Fin n // i ∉ selected}) | |
| (q : Q₂ × SelectedCommonData (Q₁ := Q₁) (Q₂ := Q₂) (A₁ := A₁) (A₂ := A₂) selected j) | |
| (r : Fin n → Q₂) (h : (selectedFullRightCompletion G strategy selected j q).weight r ≠ 0) : | |
| r j.1 = q.1 := by | |
| classical | |
| by_contra hne | |
| apply h | |
| simp only [selectedFullRightCompletion, FiniteDistribution.pushforward] | |
| apply Finset.sum_eq_zero | |
| intro t _ | |
| split | |
| · rename_i he | |
| apply selectedRightCompletion_zero | |
| intro ht | |
| apply hne | |
| have hcoord := congrFun he j.1 | |
| simpa [mergeCoordinates, j.property, ht] using hcoord.symm | |
| · rfl | |
| theorem selected_full_completion_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)) (j : {i : Fin n // i ∉ selected}) | |
| (s : SelectedCommonData (Q₁ := Q₁) (Q₂ := Q₂) (A₁ := A₁) (A₂ := A₂) selected j) | |
| (xy : Q₁ × Q₂) (event : ((Fin n → Q₁) × (Fin n → Q₂)) → Bool) : | |
| ((selectedFullLeftCompletion G strategy selected j (xy.1,s)).product | |
| (selectedFullRightCompletion G strategy selected j (xy.2,s))).probability event = | |
| ∑ lr : ({i : Fin n // i ∉ selected} → Q₁) × ({i : Fin n // i ∉ selected} → Q₂), | |
| ((selectedLeftCompletion G strategy selected j s xy.1).product | |
| (selectedRightCompletion G strategy selected j s xy.2)).weight lr * | |
| (if event (selectedQuestionTuple selected s.1.1 (fun i => (lr.1 i,lr.2 i))) | |
| then 1 else 0) := by | |
| rw [selectedFullLeftCompletion, selectedFullRightCompletion, | |
| ← FiniteDistribution.product_pushforward, FiniteDistribution.probability_pushforward] | |
| unfold FiniteDistribution.probability | |
| apply Finset.sum_congr rfl | |
| intro lr _ | |
| have he : selectedQuestionTuple selected s.1.1 (fun i => (lr.1 i,lr.2 i)) = | |
| (mergeCoordinates selected (fun i => (s.1.1 i).1) lr.1, | |
| mergeCoordinates selected (fun i => (s.1.1 i).2) lr.2) := | |
| Prod.ext (selectedQuestionTuple_left selected s.1.1 _) | |
| (selectedQuestionTuple_right selected s.1.1 _) | |
| rw [he] | |
| cases hevent : event (mergeCoordinates selected (fun i => (s.1.1 i).1) lr.1, | |
| mergeCoordinates selected (fun i => (s.1.1 i).2) lr.2) <;> simp [hevent] | |
| theorem selected_completion_event_row (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) | |
| (j : {i : Fin n // i ∉ selected}) | |
| (s : SelectedCommonData (Q₁ := Q₁) (Q₂ := Q₂) (A₁ := A₁) (A₂ := A₂) selected j) | |
| (event : ((Fin n → Q₁) × (Fin n → Q₂)) → Bool) : | |
| (∑ xy : Q₁ × Q₂, (selectedCommonLaw G strategy selected positive j).weight (s,xy) * | |
| ((selectedFullLeftCompletion G strategy selected j (xy.1,s)).product | |
| (selectedFullRightCompletion G strategy selected j (xy.2,s))).probability event) = | |
| ∑ u : {i : Fin n // i ∉ selected} → Q₁ × Q₂, | |
| partialRevealWeight G.questions j s.2 u * | |
| selectedOutsideLikelihood G strategy selected s.1 u * | |
| (if event (selectedQuestionTuple selected s.1.1 u) then 1 else 0) := by | |
| classical | |
| have hpoint (xy : Q₁ × Q₂) | |
| (lr : ({i : Fin n // i ∉ selected} → Q₁) × ({i : Fin n // i ∉ selected} → Q₂)) : | |
| (selectedCommonLaw G strategy selected positive j).weight (s,xy) * | |
| ((selectedLeftCompletion G strategy selected j s xy.1).product | |
| (selectedRightCompletion G strategy selected j s xy.2)).weight lr = | |
| if (lr.1 j,lr.2 j) = xy then | |
| partialRevealWeight G.questions j s.2 (fun i => (lr.1 i,lr.2 i)) * | |
| selectedOutsideLikelihood G strategy selected s.1 (fun i => (lr.1 i,lr.2 i)) else 0 := | |
| selected_completion_row_recombine G strategy selected positive j s xy lr.1 lr.2 | |
| simp_rw [selected_full_completion_probability, Finset.mul_sum, ← mul_assoc, | |
| hpoint] | |
| have hsum (xy : Q₁ × Q₂) : | |
| (∑ lr : ({i : Fin n // i ∉ selected} → Q₁) × ({i : Fin n // i ∉ selected} → Q₂), | |
| (if (lr.1 j,lr.2 j) = xy then | |
| partialRevealWeight G.questions j s.2 (fun i => (lr.1 i,lr.2 i)) * | |
| selectedOutsideLikelihood G strategy selected s.1 (fun i => (lr.1 i,lr.2 i)) else 0) * | |
| (if event (selectedQuestionTuple selected s.1.1 (fun i => (lr.1 i,lr.2 i))) then 1 else 0)) = | |
| ∑ u : {i : Fin n // i ∉ selected} → Q₁ × Q₂, | |
| (if u j = xy then partialRevealWeight G.questions j s.2 u * | |
| selectedOutsideLikelihood G strategy selected s.1 u else 0) * | |
| (if event (selectedQuestionTuple selected s.1.1 u) then 1 else 0) := by | |
| exact ((completionTupleEquiv (I := {i : Fin n // i ∉ selected}) | |
| (X := Q₁) (Y := Q₂)).sum_comp _).symm | |
| simp_rw [hsum] | |
| rw [Finset.sum_comm] | |
| apply Finset.sum_congr rfl | |
| intro u _ | |
| rw [← Finset.sum_mul] | |
| simp | |
| def selectedFullCompletionMixture (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) | |
| (j : {i : Fin n // i ∉ selected}) : | |
| FiniteDistribution ((Fin n → Q₁) × (Fin n → Q₂)) := | |
| ((selectedCommonLaw G strategy selected positive j).transport (Equiv.prodComm _ _)).mixture | |
| (fun z => (selectedFullLeftCompletion G strategy selected j (z.1.1,z.2)).product | |
| (selectedFullRightCompletion G strategy selected j (z.1.2,z.2))) | |
| theorem selectedFullCompletionMixture_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)) (positive : 0 < G.selectedSuccess strategy selected) | |
| (j : {i : Fin n // i ∉ selected}) | |
| (event : ((Fin n → Q₁) × (Fin n → Q₂)) → Bool) : | |
| (selectedFullCompletionMixture G strategy selected positive j).probability event = | |
| ((G.repetition n).questions.condition (G.selectedWins strategy selected) positive).probability event := by | |
| erw [FiniteDistribution.probability_condition] | |
| rw [selectedFullCompletionMixture, FiniteDistribution.probability_mixture] | |
| simp only [FiniteDistribution.transport] | |
| rw [Fintype.sum_prod_type, Finset.sum_comm] | |
| calc | |
| _ = ∑ s : SelectedCommonData (Q₁ := Q₁) (Q₂ := Q₂) (A₁ := A₁) (A₂ := A₂) selected j, | |
| ∑ u : {i : Fin n // i ∉ selected} → Q₁ × Q₂, | |
| partialRevealWeight G.questions j s.2 u * | |
| selectedOutsideLikelihood G strategy selected s.1 u * | |
| (if event (selectedQuestionTuple selected s.1.1 u) then 1 else 0) := by | |
| apply Finset.sum_congr rfl | |
| intro s _ | |
| exact selected_completion_event_row G strategy selected positive j s event | |
| _ = _ := selected_partial_event_total G strategy selected j event | |
| /-- Exact equality with the actual repeated-game question law conditioned on | |
| the selected wins, derived by summing the local completion rows. -/ | |
| theorem selectedFullCompletionMixture_eq_conditionedQuestions (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) | |
| (j : {i : Fin n // i ∉ selected}) : | |
| selectedFullCompletionMixture G strategy selected positive j = | |
| (G.repetition n).questions.condition (G.selectedWins strategy selected) positive := by | |
| classical | |
| apply FiniteDistribution.eq_of_weight_eq | |
| intro q | |
| rw [FiniteDistribution.weight_eq_probability_singleton, | |
| FiniteDistribution.weight_eq_probability_singleton] | |
| exact selectedFullCompletionMixture_probability G strategy selected positive j _ | |
| end | |
| end UniqueGamesTheorem.Foundations.Repetition | |
| end | |
| section | |
| /-! Actual finite shared seed laws for the bounded correlated sampler. -/ | |
| namespace UniqueGamesTheorem.Foundations.Repetition | |
| open scoped BigOperators | |
| open Games | |
| noncomputable section | |
| universe u | |
| def TraceSeed (σ : Type u) : Nat → Type u | |
| | 0 => PUnit | |
| | n + 1 => σ × TraceSeed σ n | |
| instance traceSeedFintype {σ : Type*} [Fintype σ] (n : Nat) : Fintype (TraceSeed σ n) := by | |
| induction n with | |
| | zero => exact inferInstanceAs (Fintype PUnit) | |
| | succ n ih => exact inferInstanceAs (Fintype (σ × TraceSeed σ n)) | |
| instance traceSeedUniqueZero {σ : Type*} : Unique (TraceSeed σ 0) := | |
| inferInstanceAs (Unique PUnit) | |
| def traceList {σ : Type*} : (n : Nat) → TraceSeed σ n → List σ | |
| | 0, _ => [] | |
| | n + 1, seed => seed.1 :: traceList n seed.2 | |
| def traceSeedLaw {σ : Type*} [Fintype σ] (μ : FiniteDistribution σ) : | |
| (n : Nat) → FiniteDistribution (TraceSeed σ n) | |
| | 0 => { weight := fun _ => 1, nonnegative := by intro; norm_num, | |
| normalized := by simp } | |
| | n + 1 => μ.product (traceSeedLaw μ n) | |
| theorem traceSeedLaw_expectation {σ : Type*} [Fintype σ] | |
| (μ : FiniteDistribution σ) (n : Nat) (f : List σ → ℝ) : | |
| (traceSeedLaw μ n).expectation (fun seed => f (traceList n seed)) = | |
| CorrelatedSampling.traceAverage μ.weight n f := by | |
| induction n generalizing f with | |
| | zero => simp [traceSeedLaw, traceList, FiniteDistribution.expectation, | |
| CorrelatedSampling.traceAverage] | |
| | succ n ih => | |
| change (μ.product (traceSeedLaw μ n)).expectation | |
| (fun seed => f (seed.1 :: traceList n seed.2)) = _ | |
| rw [FiniteDistribution.expectation_product] | |
| simp only [CorrelatedSampling.traceAverage, FiniteDistribution.expectation] | |
| apply Finset.sum_congr rfl | |
| intro s _ | |
| congr 1 | |
| exact ih (fun xs => f (s :: xs)) | |
| /-- The law of the two local outputs, driven by a seed chosen independently | |
| of the question pair. Local maps receive only their own question. -/ | |
| def sharedOutputLaw {X Y S Seed : Type*} | |
| [Fintype X] [Fintype Y] [Fintype S] [Fintype Seed] [DecidableEq S] | |
| (μ : FiniteDistribution (X × Y)) (seedLaw : FiniteDistribution Seed) | |
| (left : Seed → X → S) (right : Seed → Y → S) : | |
| FiniteDistribution ((X × Y) × S × S) := | |
| (μ.product seedLaw).pushforward | |
| (fun z => (z.1, left z.2 z.1.1, right z.2 z.1.2)) | |
| theorem sharedOutputLaw_weight {X Y S Seed : Type*} | |
| [Fintype X] [Fintype Y] [Fintype S] [Fintype Seed] [DecidableEq S] | |
| (μ : FiniteDistribution (X × Y)) (seedLaw : FiniteDistribution Seed) | |
| (left : Seed → X → S) (right : Seed → Y → S) (x : X) (y : Y) (a b : S) : | |
| (sharedOutputLaw μ seedLaw left right).weight ((x,y),a,b) = | |
| μ.weight (x,y) * seedLaw.expectation | |
| (fun seed => if left seed x = a ∧ right seed y = b then 1 else 0) := by | |
| classical | |
| simp only [sharedOutputLaw, FiniteDistribution.pushforward, | |
| FiniteDistribution.product, Fintype.sum_prod_type, Prod.mk.injEq] | |
| simp only [and_assoc, ite_and] | |
| simp [FiniteDistribution.expectation, Finset.mul_sum, mul_ite] | |
| section Rectangle | |
| open CorrelatedSampling | |
| variable {X Y S : Type*} [Fintype X] [Fintype Y] [Fintype S] | |
| [Nonempty S] [DecidableEq S] | |
| def samplerLocal (thresholds : List ℝ) (profile : X → FiniteDistribution S) | |
| (fallback : S) (n : Nat) (seed : TraceSeed (RectangleSeed thresholds S) n) | |
| (x : X) : S := | |
| localSample (rectangleAccept thresholds (profile x).weight) Prod.fst fallback | |
| (traceList n seed) | |
| def samplerOutputLaw (thresholds : List ℝ) (μ : FiniteDistribution (X × Y)) | |
| (L : X → FiniteDistribution S) (R : Y → FiniteDistribution S) | |
| (fallback : S) (n : Nat) : FiniteDistribution ((X × Y) × S × S) := | |
| sharedOutputLaw μ (traceSeedLaw (rectangleDistribution thresholds) n) | |
| (samplerLocal thresholds L fallback n) (samplerLocal thresholds R fallback n) | |
| omit [Nonempty S] [DecidableEq S] in | |
| theorem probability_weight_le_one (μ : FiniteDistribution S) (s : S) : μ.weight s ≤ 1 := by | |
| calc | |
| μ.weight s ≤ ∑ t, μ.weight t := | |
| Finset.single_le_sum (fun t _ => μ.nonnegative t) (Finset.mem_univ s) | |
| _ = 1 := μ.normalized | |
| /-- The per-label estimate concerns the actual finite game-law | |
| sampler with a shared seed independent of the input questions. -/ | |
| theorem samplerOutputLaw_diagonal (thresholds : List ℝ) | |
| (μ : FiniteDistribution (X × Y)) | |
| (L : X → FiniteDistribution S) (R : Y → FiniteDistribution S) | |
| (hL : ∀ x s, (L x).weight s ∈ thresholds) | |
| (hR : ∀ y s, (R y).weight s ∈ thresholds) | |
| (fallback : S) (n : Nat) (x : X) (y : Y) (a : S) : | |
| μ.weight (x,y) * min ((L x).weight a) ((R y).weight a) / | |
| (1 + Information.totalVariation (L x).weight (R y).weight) * | |
| (1 - eventMass (rectangleWeight thresholds) | |
| (fun s => !(rectangleAccept thresholds (L x).weight s || | |
| rectangleAccept thresholds (R y).weight s)) ^ n) ≤ | |
| (samplerOutputLaw thresholds μ L R fallback n).weight ((x,y),a,a) := by | |
| have h := rectangle_label_diagonal_bound thresholds (L x).weight (R y).weight | |
| fallback a (hL x) (hR y) (L x).nonnegative (R y).nonnegative | |
| (probability_weight_le_one (L x)) (probability_weight_le_one (R y)) | |
| (L x).normalized (R y).normalized n | |
| rw [samplerOutputLaw, sharedOutputLaw_weight] | |
| have he : (traceSeedLaw (rectangleDistribution (α := S) thresholds) n).expectation | |
| (fun seed => if samplerLocal thresholds L fallback n seed x = a ∧ | |
| samplerLocal thresholds R fallback n seed y = a then 1 else 0) = | |
| traceAverage (rectangleWeight thresholds) n | |
| (localDiagonal (rectangleAccept thresholds (L x).weight) | |
| (rectangleAccept thresholds (R y).weight) Prod.fst fallback a) := by | |
| exact traceSeedLaw_expectation (rectangleDistribution (α := S) thresholds) n | |
| (localDiagonal (rectangleAccept thresholds (L x).weight) | |
| (rectangleAccept thresholds (R y).weight) Prod.fst fallback a) | |
| rw [he] | |
| simp only [Information.totalVariation, CorrelatedSampling.totalVariation] at h ⊢ | |
| simpa only [mul_div_assoc, mul_assoc] using | |
| mul_le_mul_of_nonneg_left h (μ.nonnegative (x,y)) | |
| theorem samplerOutputLaw_uniform_diagonal | |
| (μ : FiniteDistribution (X × Y)) | |
| (L : X → FiniteDistribution S) (R : Y → FiniteDistribution S) | |
| (fallback : S) (n : Nat) (x : X) (y : Y) (a : S) : | |
| μ.weight (x,y) * min ((L x).weight a) ((R y).weight a) / | |
| (1 + Information.totalVariation (L x).weight (R y).weight) * | |
| (1 - uniformRejectionRate S ^ n) ≤ | |
| (samplerOutputLaw (sharedProfileThresholds L R) μ L R fallback n).weight ((x,y),a,a) := by | |
| have hp := pow_le_pow_left₀ (sharedProfileReject_nonnegative L R x y) | |
| (sharedProfile_reject_le_rate L R x y) n | |
| have hco : 0 ≤ μ.weight (x,y) * min ((L x).weight a) ((R y).weight a) / | |
| (1 + Information.totalVariation (L x).weight (R y).weight) := | |
| div_nonneg (mul_nonneg (μ.nonnegative (x,y)) | |
| (le_min ((L x).nonnegative a) ((R y).nonnegative a))) | |
| (by linarith [Information.totalVariation_nonneg (L x).weight (R y).weight]) | |
| have h := samplerOutputLaw_diagonal (sharedProfileThresholds L R) μ L R | |
| (left_mem_sharedProfileThresholds L R) (right_mem_sharedProfileThresholds L R) | |
| fallback n x y a | |
| exact (mul_le_mul_of_nonneg_left (sub_le_sub_left hp 1) hco).trans h | |
| /-- Actual finite shared sampler approximates any prescribed diagonal law. | |
| Its error is derived from the two actual conditional profiles and its uniform | |
| finite exhaustion probability. -/ | |
| theorem samplerOutputLaw_totalVariation | |
| (p : FiniteDistribution ((X × Y) × S)) (μ : FiniteDistribution (X × Y)) | |
| (L : X → FiniteDistribution S) (R : Y → FiniteDistribution S) | |
| (fallback : S) (n : Nat) : | |
| Information.totalVariation | |
| (samplerOutputLaw (sharedProfileThresholds L R) μ L R fallback n).weight | |
| (diagonalWeights p.weight) ≤ | |
| 2 * Information.totalVariation p.weight (fun z => μ.weight z.1 * (L z.1.1).weight z.2) + | |
| 2 * Information.totalVariation p.weight (fun z => μ.weight z.1 * (R z.1.2).weight z.2) + | |
| uniformRejectionRate S ^ n := by | |
| apply diagonal_sampler_totalVariation_le p.weight μ.weight | |
| (fun xy => (L xy.1).weight) (fun xy => (R xy.2).weight) _ | |
| (Information.gameLaw_isProbability p) (Information.gameLaw_isProbability μ) | |
| (fun xy => Information.gameLaw_isProbability (L xy.1)) | |
| (fun xy => Information.gameLaw_isProbability (R xy.2)) | |
| (Information.gameLaw_isProbability _) | |
| (pow_nonneg (uniformRejectionRate_nonnegative S) n) | |
| · exact pow_le_one₀ (uniformRejectionRate_nonnegative S) | |
| (uniformRejectionRate_lt_one S).le | |
| · intro xy a | |
| exact samplerOutputLaw_uniform_diagonal μ L R fallback n xy.1 xy.2 a | |
| theorem samplerOutputLaw_arbitrarily_close | |
| (p : FiniteDistribution ((X × Y) × S)) (μ : FiniteDistribution (X × Y)) | |
| (L : X → FiniteDistribution S) (R : Y → FiniteDistribution S) | |
| (fallback : S) (η : ℝ) (hη : 0 < η) : ∃ n : Nat, | |
| Information.totalVariation | |
| (samplerOutputLaw (sharedProfileThresholds L R) μ L R fallback n).weight | |
| (diagonalWeights p.weight) ≤ | |
| 2 * Information.totalVariation p.weight (fun z => μ.weight z.1 * (L z.1.1).weight z.2) + | |
| 2 * Information.totalVariation p.weight (fun z => μ.weight z.1 * (R z.1.2).weight z.2) + η := by | |
| obtain ⟨n,hn⟩ := exists_uniformRejectionRate_pow_lt S η hη | |
| exact ⟨n, (samplerOutputLaw_totalVariation p μ L R fallback n).trans | |
| (by linarith)⟩ | |
| end Rectangle | |
| end | |
| end UniqueGamesTheorem.Foundations.Repetition | |
| end | |
| end OAI | |