| import OAI.Computability.BinPacking.Games.Reindexing | |
| namespace OAI | |
| namespace BinPackingGames.Foundations.Games.Game | |
| noncomputable section | |
| variable {Q₁ Q₂ A₁ A₂ R₁ R₂ B₁ B₂ Seed : Type*} | |
| [Fintype Q₁] [Fintype Q₂] [Fintype A₁] [Fintype A₂] | |
| [Fintype R₁] [Fintype R₂] [Fintype B₁] [Fintype B₂] [Fintype Seed] | |
| [Nonempty A₁] [Nonempty A₂] | |
| def localEmbeddingLaw (G : Game Q₁ Q₂ A₁ A₂) | |
| (seedLaw : FiniteDistribution Seed) | |
| (left : Seed → Q₁ → R₁) (right : Seed → Q₂ → R₂) : | |
| FiniteDistribution (R₁ × R₂) := | |
| seedLaw.mixture fun seed => | |
| G.questions.pushforward fun q => (left seed q.1, right seed q.2) | |
| theorem success_le_value_add_embedding_distance | |
| (G : Game Q₁ Q₂ A₁ A₂) (H : Game R₁ R₂ B₁ B₂) | |
| (seedLaw : FiniteDistribution Seed) | |
| (left : Seed → Q₁ → R₁) (right : Seed → Q₂ → R₂) | |
| (answerLeft : Seed → Q₁ → B₁ → A₁) | |
| (answerRight : Seed → Q₂ → B₂ → A₂) | |
| (acceptance : ∀ seed x y a b, | |
| H.accepts (left seed x) (right seed y) a b = true → | |
| G.accepts x y (answerLeft seed x a) (answerRight seed y b) = true) | |
| (strategy : Strategy R₁ R₂ B₁ B₂) : | |
| H.success strategy ≤ G.value + | |
| H.questions.totalVariation (G.localEmbeddingLaw seedLaw left right) := by | |
| have localBound (seed : Seed) : | |
| (G.questions.pushforward (fun q => (left seed q.1, right seed q.2))).probability | |
| (H.wins strategy) ≤ G.value := by | |
| let embedded : Game R₁ R₂ B₁ B₂ := | |
| { questions := G.questions.pushforward fun q => (left seed q.1, right seed q.2) | |
| accepts := H.accepts } | |
| change embedded.success strategy ≤ G.value | |
| exact (G.success_le_of_localSimulation embedded (left seed) (right seed) | |
| (answerLeft seed) (answerRight seed) rfl (acceptance seed) strategy).trans | |
| (G.success_le_value _) | |
| have mixtureBound : | |
| (G.localEmbeddingLaw seedLaw left right).probability (H.wins strategy) ≤ G.value := | |
| seedLaw.probability_mixture_le _ _ _ localBound | |
| exact (H.questions.probability_le_add_totalVariation | |
| (G.localEmbeddingLaw seedLaw left right) (H.wins strategy)).trans | |
| (add_le_add mixtureBound (le_refl _)) | |
| def coordinateGame (G : Game Q₁ Q₂ A₁ A₂) {n : Nat} (coordinate : Fin n) | |
| (law : FiniteDistribution ((Fin n → Q₁) × (Fin n → Q₂))) : | |
| Game (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂) where | |
| questions := law | |
| accepts x y a b := G.accepts (x coordinate) (y coordinate) (a coordinate) (b coordinate) | |
| theorem coordinate_probability_le_value_add_embedding_distance | |
| (G : Game Q₁ Q₂ A₁ A₂) {n : Nat} (coordinate : Fin n) | |
| (law : FiniteDistribution ((Fin n → Q₁) × (Fin n → Q₂))) | |
| (seedLaw : FiniteDistribution Seed) | |
| (left : Seed → Q₁ → Fin n → Q₁) (right : Seed → Q₂ → Fin n → Q₂) | |
| (left_preserves : ∀ seed x, left seed x coordinate = x) | |
| (right_preserves : ∀ seed y, right seed y coordinate = y) | |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) : | |
| law.probability (G.coordinateWin strategy coordinate) ≤ G.value + | |
| law.totalVariation (G.localEmbeddingLaw seedLaw left right) := by | |
| apply G.success_le_value_add_embedding_distance (G.coordinateGame coordinate law) | |
| seedLaw left right (fun _ _ a => a coordinate) (fun _ _ b => b coordinate) | |
| intro seed x y a b h | |
| simpa only [coordinateGame, left_preserves, right_preserves] using h | |
| theorem coordinate_probability_le_value_of_approximate_embeddings | |
| {SeedFamily : Nat → Type*} [∀ t, Fintype (SeedFamily t)] | |
| (G : Game Q₁ Q₂ A₁ A₂) {n : Nat} (coordinate : Fin n) | |
| (law : FiniteDistribution ((Fin n → Q₁) × (Fin n → Q₂))) | |
| (seedLaw : (t : Nat) → FiniteDistribution (SeedFamily t)) | |
| (left : (t : Nat) → SeedFamily t → Q₁ → Fin n → Q₁) | |
| (right : (t : Nat) → SeedFamily t → Q₂ → Fin n → Q₂) | |
| (left_preserves : ∀ t seed x, left t seed x coordinate = x) | |
| (right_preserves : ∀ t seed y, right t seed y coordinate = y) | |
| (strategy : Strategy (Fin n → Q₁) (Fin n → Q₂) (Fin n → A₁) (Fin n → A₂)) | |
| (distance : ℝ) | |
| (close : ∀ η : ℝ, 0 < η → ∃ t, | |
| law.totalVariation (G.localEmbeddingLaw (seedLaw t) (left t) (right t)) ≤ | |
| distance + η) : | |
| law.probability (G.coordinateWin strategy coordinate) ≤ G.value + distance := by | |
| by_contra h | |
| have gap : 0 < law.probability (G.coordinateWin strategy coordinate) - | |
| (G.value + distance) := sub_pos.mpr (lt_of_not_ge h) | |
| obtain ⟨t, ht⟩ := close | |
| ((law.probability (G.coordinateWin strategy coordinate) - (G.value + distance)) / 2) | |
| (by linarith) | |
| have bound := G.coordinate_probability_le_value_add_embedding_distance coordinate law | |
| (seedLaw t) (left t) (right t) (left_preserves t) (right_preserves t) strategy | |
| linarith | |
| end | |
| end BinPackingGames.Foundations.Games.Game | |
| end OAI | |