File size: 5,021 Bytes
8df23f4 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 | 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
|