introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
30.7 kB
import Mathlib
import OAI.Computability.DirectedFeedback.Games.SharedSampling
namespace OAI
namespace DFVSGames.Repetition
open DFVSGames.Foundations.Games
open scoped BigOperators
noncomputable section
structure ProjectionKernel (Q₁ Qβ‚‚ A₁ Aβ‚‚ : Type*)
[Fintype Q₁] [Fintype Qβ‚‚] [Fintype A₁] [Fintype Aβ‚‚] where
outer : FiniteDistribution Qβ‚‚
inner : Qβ‚‚ β†’ FiniteDistribution Q₁
accepts : Q₁ β†’ Qβ‚‚ β†’ A₁ β†’ Aβ‚‚ β†’ Bool
projection : βˆ€ x y a b b', accepts x y a b = true β†’
accepts x y a b' = true β†’ b = b'
namespace ProjectionKernel
variable {Q₁ Qβ‚‚ A₁ Aβ‚‚ Ξ© : Type*}
[Fintype Q₁] [Fintype Qβ‚‚] [Fintype A₁] [Fintype Aβ‚‚] [Fintype Ξ©]
def toGame (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚) : Game Q₁ Qβ‚‚ A₁ Aβ‚‚ where
questions :=
{ weight := fun q => K.outer.weight q.2 * (K.inner q.2).weight q.1
nonnegative := fun q => mul_nonneg (K.outer.nonnegative _) ((K.inner _).nonnegative _)
normalized := by
rw [Fintype.sum_prod_type, Finset.sum_comm]
simp_rw [← Finset.mul_sum, FiniteDistribution.normalized, mul_one]
exact K.outer.normalized }
accepts := K.accepts
theorem toGame_isProjection (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚) :
IsProjection K.toGame := K.projection
def apply (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(f : Q₁ β†’ A₁ β†’ ℝ) (y : Qβ‚‚) (b : Aβ‚‚) : ℝ :=
βˆ‘ x, (K.inner y).weight x * βˆ‘ a, if K.accepts x y a b then f x a else 0
def energy (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚) (f : Q₁ β†’ A₁ β†’ ℝ) : ℝ :=
βˆ‘ y, K.outer.weight y * βˆ‘ b, K.apply f y b ^ 2
def assignment (labels : Q₁ β†’ A₁) (x : Q₁) (a : A₁) : ℝ := by
classical
exact if labels x = a then 1 else 0
def assignmentEnergy (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(labels : Q₁ β†’ A₁) : ℝ := K.energy (assignment labels)
def collisionValue [Nonempty A₁] (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚) : ℝ := by
classical
exact Finset.univ.sup' Finset.univ_nonempty K.assignmentEnergy
def vectorEnergy (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(f : Ξ© β†’ Q₁ β†’ A₁ β†’ ℝ) : ℝ := βˆ‘ Ο‰, K.energy (f Ο‰)
def vectorMass (f : Ξ© β†’ Q₁ β†’ A₁ β†’ ℝ) (x : Q₁) : ℝ :=
βˆ‘ Ο‰, (βˆ‘ a, f Ο‰ x a) ^ 2
theorem energy_nonneg (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(f : Q₁ β†’ A₁ β†’ ℝ) : 0 ≀ K.energy f := by
exact Finset.sum_nonneg fun y _ => mul_nonneg (K.outer.nonnegative y)
(Finset.sum_nonneg fun b _ => sq_nonneg _)
theorem assignmentEnergy_le_collisionValue [Nonempty A₁]
(K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚) (labels : Q₁ β†’ A₁) :
K.assignmentEnergy labels ≀ K.collisionValue := by
classical
exact Finset.le_sup' _ (Finset.mem_univ labels)
theorem collisionValue_le_iff [Nonempty A₁]
(K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚) (bound : ℝ) :
K.collisionValue ≀ bound ↔ βˆ€ labels, K.assignmentEnergy labels ≀ bound := by
classical
simp [collisionValue, Finset.sup'_le_iff]
theorem exists_optimal_assignment [Nonempty A₁]
(K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚) :
βˆƒ labels, K.assignmentEnergy labels = K.collisionValue := by
classical
obtain ⟨labels, _, h⟩ := Finset.exists_mem_eq_sup'
(s := (Finset.univ : Finset (Q₁ β†’ A₁))) Finset.univ_nonempty K.assignmentEnergy
exact ⟨labels, h.symm⟩
theorem collisionValue_nonneg [Nonempty A₁]
(K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚) : 0 ≀ K.collisionValue := by
obtain ⟨labels, h⟩ := K.exists_optimal_assignment
rw [← h]
exact K.energy_nonneg _
@[simp] theorem apply_assignment (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(labels : Q₁ β†’ A₁) (y : Qβ‚‚) (b : Aβ‚‚) :
K.apply (assignment labels) y b =
βˆ‘ x, if K.accepts x y (labels x) b then (K.inner y).weight x else 0 := by
classical
unfold apply assignment
apply Finset.sum_congr rfl
intro x _
have hsum : (βˆ‘ a, if K.accepts x y a b then
(if labels x = a then (1 : ℝ) else 0) else 0) =
if K.accepts x y (labels x) b then (1 : ℝ) else 0 := by
have hpoint (a : A₁) :
(if K.accepts x y a b then (if labels x = a then (1 : ℝ) else 0) else 0) =
(if a = labels x then (if K.accepts x y a b then (1 : ℝ) else 0) else 0) := by
by_cases h : a = labels x
Β· subst a
simp
Β· simp [h, Ne.symm h]
simp_rw [hpoint]
simp
rw [hsum]
by_cases h : K.accepts x y (labels x) b = true <;> simp [h]
end ProjectionKernel
end
end DFVSGames.Repetition
namespace DFVSGames.Repetition.ProjectionKernel
open Foundations.Games
open scoped BigOperators
noncomputable section
attribute [local instance] Classical.propDecidable
variable {Q₁ Qβ‚‚ A₁ Aβ‚‚ Ξ© : Type*}
[Fintype Q₁] [Fintype Qβ‚‚] [Fintype A₁] [Fintype Aβ‚‚] [Fintype Ξ©]
abbrev SymmetricEdge (Q₁ Qβ‚‚ : Type*) := Qβ‚‚ Γ— Q₁ Γ— Q₁
def symmetricLeft (e : SymmetricEdge Q₁ Qβ‚‚) : Q₁ := e.2.1
def symmetricRight (e : SymmetricEdge Q₁ Qβ‚‚) : Q₁ := e.2.2
def symmetricDistribution (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚) :
FiniteDistribution (SymmetricEdge Q₁ Qβ‚‚) where
weight e := K.outer.weight e.1 * (K.inner e.1).weight e.2.1 *
(K.inner e.1).weight e.2.2
nonnegative e := mul_nonneg
(mul_nonneg (K.outer.nonnegative _) ((K.inner _).nonnegative _))
((K.inner _).nonnegative _)
normalized := by
rw [Fintype.sum_prod_type]
calc
_ = βˆ‘ y, K.outer.weight y := by
apply Finset.sum_congr rfl
intro y _
rw [Fintype.sum_prod_type]
calc
_ = βˆ‘ x, K.outer.weight y * (K.inner y).weight x := by
apply Finset.sum_congr rfl
intro x _
dsimp only
rw [← Finset.mul_sum, (K.inner y).normalized, mul_one]
_ = K.outer.weight y := by
rw [← Finset.mul_sum, (K.inner y).normalized, mul_one]
_ = 1 := K.outer.normalized
def symmetricAccept (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(e : SymmetricEdge Q₁ Qβ‚‚) (a a' : A₁) : Bool := by
classical
exact decide (βˆƒ b, K.accepts e.2.1 e.1 a b = true ∧
K.accepts e.2.2 e.1 a' b = true)
def singleLabelVector (a : Q₁ β†’ Ξ© β†’ A₁) (f : Q₁ β†’ Ξ© β†’ ℝ)
(Ο‰ : Ξ©) (x : Q₁) (b : A₁) : ℝ := by
classical
exact if a x Ο‰ = b then f x Ο‰ else 0
theorem sum_projection_gates (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(y : Qβ‚‚) (x x' : Q₁) (a a' : A₁) (r s : ℝ) :
(βˆ‘ b, (if K.accepts x y a b then r else 0) *
(if K.accepts x' y a' b then s else 0)) =
if K.symmetricAccept (y, x, x') a a' then r * s else 0 := by
classical
by_cases hex : βˆƒ b, K.accepts x y a b = true ∧ K.accepts x' y a' b = true
Β· obtain ⟨bβ‚€, hbβ‚€, hbβ‚€'⟩ := hex
have hex' : βˆƒ b, K.accepts x y a b = true ∧ K.accepts x' y a' b = true :=
⟨bβ‚€, hbβ‚€, hbβ‚€'⟩
simp only [symmetricAccept, hex', decide_true, ite_true]
calc
_ = (if K.accepts x y a bβ‚€ then r else 0) *
(if K.accepts x' y a' bβ‚€ then s else 0) := by
apply Finset.sum_eq_single bβ‚€
Β· intro b _ hne
have hb : K.accepts x y a b β‰  true := by
intro hb
exact hne (K.projection x y a b bβ‚€ hb hbβ‚€)
simp [hb]
Β· simp
_ = r * s := by simp [hbβ‚€, hbβ‚€']
Β· simp only [symmetricAccept, hex, decide_false, Bool.false_eq_true, ite_false]
apply Finset.sum_eq_zero
intro b _
by_cases hb : K.accepts x y a b = true
Β· have hb' : K.accepts x' y a' b β‰  true := fun hb' => hex ⟨b, hb, hb'⟩
simp [hb']
Β· simp [hb]
theorem apply_single_label (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(labels : Q₁ β†’ A₁) (f : Q₁ β†’ ℝ) (y : Qβ‚‚) (b : Aβ‚‚) :
K.apply (fun x a => if labels x = a then f x else 0) y b =
βˆ‘ x, (K.inner y).weight x * (if K.accepts x y (labels x) b then f x else 0) := by
classical
unfold apply
apply Finset.sum_congr rfl
intro x _
congr 1
calc
_ = βˆ‘ a, if labels x = a then
(if K.accepts x y (labels x) b then f x else 0) else 0 := by
apply Finset.sum_congr rfl
intro a _
by_cases ha : labels x = a
Β· subst a
simp
Β· simp [ha]
_ = _ := by simp
theorem energy_single_label (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(labels : Q₁ β†’ A₁) (f : Q₁ β†’ ℝ) :
K.energy (fun x a => if labels x = a then f x else 0) =
K.symmetricDistribution.expectation (fun e =>
if K.symmetricAccept e (labels (symmetricLeft e)) (labels (symmetricRight e))
then f (symmetricLeft e) * f (symmetricRight e) else 0) := by
classical
have hexpand (y : Qβ‚‚) :
(βˆ‘ b, (βˆ‘ x, (K.inner y).weight x *
(if K.accepts x y (labels x) b then f x else 0)) ^ 2) =
βˆ‘ x, βˆ‘ x', (K.inner y).weight x * (K.inner y).weight x' *
(if K.symmetricAccept (y, x, x') (labels x) (labels x')
then f x * f x' else 0) := by
simp only [pow_two, Finset.sum_mul, Finset.mul_sum]
rw [Finset.sum_comm]
apply Finset.sum_congr rfl
intro x _
rw [Finset.sum_comm]
apply Finset.sum_congr rfl
intro x' _
calc
_ = (K.inner y).weight x * (K.inner y).weight x' *
βˆ‘ b, (if K.accepts x y (labels x) b then f x else 0) *
(if K.accepts x' y (labels x') b then f x' else 0) := by
rw [Finset.mul_sum]
apply Finset.sum_congr rfl
intro b _
ring
_ = _ := by rw [K.sum_projection_gates]
unfold energy
simp_rw [K.apply_single_label, hexpand]
simp only [FiniteDistribution.expectation, symmetricDistribution,
Fintype.sum_prod_type, symmetricLeft, symmetricRight, Finset.mul_sum]
apply Finset.sum_congr rfl
intro y _
apply Finset.sum_congr rfl
intro x _
apply Finset.sum_congr rfl
intro x' _
simp only [mul_assoc]
rfl
theorem vectorEnergy_singleLabelVector (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(a : Q₁ β†’ Ξ© β†’ A₁) (f : Q₁ β†’ Ξ© β†’ ℝ) :
K.vectorEnergy (singleLabelVector a f) =
pairEnergy K.symmetricDistribution symmetricLeft symmetricRight K.symmetricAccept a f := by
classical
unfold vectorEnergy singleLabelVector
simp_rw [K.energy_single_label]
unfold pairEnergy FiniteDistribution.expectation
rw [Finset.sum_comm]
apply Finset.sum_congr rfl
intro e _
rw [Finset.mul_sum]
theorem symmetric_probability_eq_assignmentEnergy (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(labels : Q₁ β†’ A₁) :
K.symmetricDistribution.probability (fun e =>
K.symmetricAccept e (labels (symmetricLeft e)) (labels (symmetricRight e))) =
K.assignmentEnergy labels := by
classical
change _ = K.energy (fun x a => if labels x = a then (1 : ℝ) else 0)
rw [K.energy_single_label]
simp only [FiniteDistribution.probability, FiniteDistribution.expectation,
mul_ite, mul_one, mul_zero]
end
end DFVSGames.Repetition.ProjectionKernel
namespace DFVSGames.Repetition.ProjectionKernel
open scoped BigOperators
noncomputable section
attribute [local instance] Classical.propDecidable
variable {Q₁ Qβ‚‚ A₁ Aβ‚‚ Ξ© : Type*}
[Fintype Q₁] [Fintype Qβ‚‚] [Fintype A₁] [Fintype Aβ‚‚] [Fintype Ξ©]
def linearCoefficient (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(t : Qβ‚‚ Γ— Aβ‚‚) (x : Q₁) (a : A₁) : ℝ :=
(K.inner t.1).weight x * (if K.accepts x t.1 a t.2 then 1 else 0)
theorem apply_eq_linearCoefficient_sum (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(h : Q₁ β†’ A₁ β†’ ℝ) (y : Qβ‚‚) (b : Aβ‚‚) :
K.apply h y b = βˆ‘ x, βˆ‘ a, K.linearCoefficient (y, b) x a * h x a := by
unfold apply
simp_rw [Finset.mul_sum]
apply Finset.sum_congr rfl
intro x _
apply Finset.sum_congr rfl
intro a _
by_cases ha : K.accepts x y a b = true <;> simp [linearCoefficient, ha]
theorem energy_eq_linearCoefficient_sum (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(h : Q₁ β†’ A₁ β†’ ℝ) :
K.energy h = βˆ‘ t : Qβ‚‚ Γ— Aβ‚‚, K.outer.weight t.1 *
(βˆ‘ x, βˆ‘ a, K.linearCoefficient t x a * h x a) ^ 2 := by
rw [Fintype.sum_prod_type]
simp_rw [← K.apply_eq_linearCoefficient_sum, ← Finset.mul_sum]
rfl
theorem exists_energy_le_deterministicVector [Nonempty A₁]
(K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(h : Q₁ β†’ A₁ β†’ ℝ) (hh : βˆ€ x a, 0 ≀ h x a) :
βˆƒ labels : Q₁ β†’ A₁,
K.energy h ≀ K.energy (deterministicVector h labels) := by
classical
obtain ⟨labels, _, _, hlabels⟩ := exists_deterministic_vector h hh
(fun t : Qβ‚‚ Γ— Aβ‚‚ => K.outer.weight t.1)
(fun t => K.outer.nonnegative t.1) K.linearCoefficient
refine ⟨labels, ?_⟩
rw [K.energy_eq_linearCoefficient_sum, K.energy_eq_linearCoefficient_sum]
exact hlabels
def vectorAmplitude (h : Ξ© β†’ Q₁ β†’ A₁ β†’ ℝ) (x : Q₁) (Ο‰ : Ξ©) : ℝ :=
rowMass (h Ο‰) x
omit [Fintype Ξ©] in
omit [Fintype Q₁] in
theorem vectorAmplitude_nonnegative (h : Ξ© β†’ Q₁ β†’ A₁ β†’ ℝ)
(hh : βˆ€ Ο‰ x a, 0 ≀ h Ο‰ x a) (x : Q₁) (Ο‰ : Ξ©) :
0 ≀ vectorAmplitude h x Ο‰ :=
rowMass_nonnegative (h Ο‰) (hh Ο‰) x
omit [Fintype Q₁] in
@[simp] theorem rowSquareMass_vectorAmplitude (h : Ξ© β†’ Q₁ β†’ A₁ β†’ ℝ) (x : Q₁) :
rowSquareMass (vectorAmplitude h) x = vectorMass h x := rfl
theorem exists_vectorEnergy_le_singleLabelVector [Nonempty A₁]
(K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(h : Ξ© β†’ Q₁ β†’ A₁ β†’ ℝ) (hh : βˆ€ Ο‰ x a, 0 ≀ h Ο‰ x a) :
βˆƒ labels : Q₁ β†’ Ξ© β†’ A₁,
K.vectorEnergy h ≀ K.vectorEnergy (singleLabelVector labels (vectorAmplitude h)) := by
classical
have hex (Ο‰ : Ξ©) := K.exists_energy_le_deterministicVector (h Ο‰) (hh Ο‰)
let labels (Ο‰ : Ξ©) : Q₁ β†’ A₁ := Classical.choose (hex Ο‰)
have hlabels (Ο‰ : Ξ©) : K.energy (h Ο‰) ≀
K.energy (deterministicVector (h Ο‰) (labels Ο‰)) := Classical.choose_spec (hex Ο‰)
refine ⟨fun x Ο‰ => labels Ο‰ x, ?_⟩
apply Finset.sum_le_sum
intro Ο‰ _
have heq : deterministicVector (h Ο‰) (labels Ο‰) =
singleLabelVector (fun x Ο‰ => labels Ο‰ x) (vectorAmplitude h) Ο‰ := by
funext x a
by_cases ha : a = labels Ο‰ x
Β· simp [deterministicVector, singleLabelVector, vectorAmplitude, ha]
Β· simp [deterministicVector, singleLabelVector, ha, Ne.symm ha]
exact heq β–Έ hlabels Ο‰
theorem exists_mass_preserving_singleLabelVector [Nonempty A₁]
(K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(h : Ξ© β†’ Q₁ β†’ A₁ β†’ ℝ) (hh : βˆ€ Ο‰ x a, 0 ≀ h Ο‰ x a) :
βˆƒ (labels : Q₁ β†’ Ξ© β†’ A₁) (f : Q₁ β†’ Ξ© β†’ ℝ),
(βˆ€ x Ο‰, 0 ≀ f x Ο‰) ∧
(βˆ€ x, rowSquareMass f x = vectorMass h x) ∧
K.vectorEnergy h ≀ K.vectorEnergy (singleLabelVector labels f) := by
obtain ⟨labels, hlabels⟩ := K.exists_vectorEnergy_le_singleLabelVector h hh
exact ⟨labels, vectorAmplitude h, vectorAmplitude_nonnegative h hh,
rowSquareMass_vectorAmplitude h, hlabels⟩
end
end DFVSGames.Repetition.ProjectionKernel
namespace DFVSGames.Repetition
open DFVSGames.Foundations.Games
open scoped BigOperators
noncomputable section
namespace ProjectionKernel
variable {Q₁ Qβ‚‚ A₁ Aβ‚‚ : Type*}
[Fintype Q₁] [Fintype Qβ‚‚] [Fintype A₁] [Fintype Aβ‚‚]
theorem sq_expectation_le_expectation_sq {Ξ© : Type*} [Fintype Ξ©]
(ΞΌ : FiniteDistribution Ξ©) (f : Ξ© β†’ ℝ) :
ΞΌ.expectation f ^ 2 ≀ ΞΌ.expectation (fun x => f x ^ 2) := by
have h := Finset.sum_sq_le_sum_mul_sum_of_sq_le_mul
(s := (Finset.univ : Finset Ξ©))
(r := fun x => ΞΌ.weight x * f x)
(f := ΞΌ.weight) (g := fun x => ΞΌ.weight x * f x ^ 2)
(fun x _ => ΞΌ.nonnegative x)
(fun x _ => mul_nonneg (ΞΌ.nonnegative x) (sq_nonneg _))
(fun x _ => by ring_nf; exact le_rfl)
simpa only [ΞΌ.normalized, one_mul, FiniteDistribution.expectation] using h
theorem apply_assignment_nonneg (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(labels : Q₁ β†’ A₁) (y : Qβ‚‚) (b : Aβ‚‚) :
0 ≀ K.apply (assignment labels) y b := by
rw [apply_assignment]
exact (K.inner y).probability_nonnegative (fun x => K.accepts x y (labels x) b)
theorem sum_apply_assignment_le_one (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(labels : Q₁ β†’ A₁) (y : Qβ‚‚) :
(βˆ‘ b, K.apply (assignment labels) y b) ≀ 1 := by
classical
simp only [apply_assignment]
rw [Finset.sum_comm, ← (K.inner y).normalized]
apply Finset.sum_le_sum
intro x _
by_cases hex : βˆƒ b, K.accepts x y (labels x) b = true
Β· obtain ⟨bβ‚€, hbβ‚€βŸ© := hex
have hiff : βˆ€ b, K.accepts x y (labels x) b = true ↔ b = bβ‚€ := by
intro b
constructor
Β· intro hb
exact K.projection x y (labels x) b bβ‚€ hb hbβ‚€
Β· rintro rfl
exact hbβ‚€
simp only [hiff]
simp
Β· have hnone : βˆ€ b, K.accepts x y (labels x) b β‰  true := by
intro b hb
exact hex ⟨b, hb⟩
simpa [hnone] using (K.inner y).nonnegative x
theorem success_eq_outer_apply (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(s : Strategy Q₁ Qβ‚‚ A₁ Aβ‚‚) :
K.toGame.success s =
K.outer.expectation (fun y => K.apply (assignment s.1) y (s.2 y)) := by
classical
simp only [Game.success, Game.wins, toGame, FiniteDistribution.probability,
FiniteDistribution.expectation, apply_assignment, Fintype.sum_prod_type]
rw [Finset.sum_comm]
apply Finset.sum_congr rfl
intro y _
rw [Finset.mul_sum]
apply Finset.sum_congr rfl
intro x _
by_cases h : K.accepts x y (s.1 x) (s.2 y) = true <;> simp [h]
theorem success_sq_le_assignmentEnergy (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(s : Strategy Q₁ Qβ‚‚ A₁ Aβ‚‚) :
K.toGame.success s ^ 2 ≀ K.assignmentEnergy s.1 := by
rw [success_eq_outer_apply]
calc
_ ≀ K.outer.expectation
(fun y => K.apply (assignment s.1) y (s.2 y) ^ 2) :=
sq_expectation_le_expectation_sq K.outer _
_ ≀ K.assignmentEnergy s.1 := by
apply Finset.sum_le_sum
intro y _
apply mul_le_mul_of_nonneg_left _ (K.outer.nonnegative y)
exact Finset.single_le_sum (fun b _ => sq_nonneg _) (Finset.mem_univ (s.2 y))
theorem value_sq_le_collisionValue [Nonempty A₁] [Nonempty Aβ‚‚]
(K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚) :
K.toGame.value ^ 2 ≀ K.collisionValue := by
obtain ⟨s, hs⟩ := K.toGame.exists_optimal_strategy
rw [← hs]
exact (K.success_sq_le_assignmentEnergy s).trans (K.assignmentEnergy_le_collisionValue s.1)
theorem exists_best_response [Nonempty Aβ‚‚]
(K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚) (labels : Q₁ β†’ A₁) :
βˆƒ answers : Qβ‚‚ β†’ Aβ‚‚, βˆ€ y b,
K.apply (assignment labels) y b ≀ K.apply (assignment labels) y (answers y) := by
classical
have h : βˆ€ y, βˆƒ b : Aβ‚‚, βˆ€ b',
K.apply (assignment labels) y b' ≀ K.apply (assignment labels) y b := by
intro y
obtain ⟨b, _, hb⟩ := Finset.exists_mem_eq_sup'
(s := (Finset.univ : Finset Aβ‚‚)) Finset.univ_nonempty
(fun b => K.apply (assignment labels) y b)
refine ⟨b, fun b' => ?_⟩
rw [← hb]
exact Finset.le_sup' _ (Finset.mem_univ b')
exact ⟨fun y => Classical.choose (h y), fun y b => Classical.choose_spec (h y) b⟩
theorem assignmentEnergy_le_value [Nonempty A₁] [Nonempty Aβ‚‚]
(K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚) (labels : Q₁ β†’ A₁) :
K.assignmentEnergy labels ≀ K.toGame.value := by
obtain ⟨answers, hanswers⟩ := K.exists_best_response labels
calc
_ ≀ K.toGame.success (labels, answers) := by
rw [success_eq_outer_apply]
apply Finset.sum_le_sum
intro y _
apply mul_le_mul_of_nonneg_left _ (K.outer.nonnegative y)
calc
_ ≀ βˆ‘ b, K.apply (assignment labels) y b *
K.apply (assignment labels) y (answers y) := by
apply Finset.sum_le_sum
intro b _
rw [pow_two]
exact mul_le_mul_of_nonneg_left (hanswers y b)
(K.apply_assignment_nonneg labels y b)
_ = (βˆ‘ b, K.apply (assignment labels) y b) *
K.apply (assignment labels) y (answers y) := (Finset.sum_mul _ _ _).symm
_ ≀ 1 * K.apply (assignment labels) y (answers y) :=
mul_le_mul_of_nonneg_right (K.sum_apply_assignment_le_one labels y)
(K.apply_assignment_nonneg labels y (answers y))
_ = _ := one_mul _
_ ≀ K.toGame.value := K.toGame.success_le_value _
theorem collisionValue_le_value [Nonempty A₁] [Nonempty Aβ‚‚]
(K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚) :
K.collisionValue ≀ K.toGame.value :=
(K.collisionValue_le_iff _).mpr K.assignmentEnergy_le_value
theorem collisionValue_le_one [Nonempty A₁] [Nonempty Aβ‚‚]
(K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚) : K.collisionValue ≀ 1 :=
K.collisionValue_le_value.trans K.toGame.value_le_one
end ProjectionKernel
end
end DFVSGames.Repetition
namespace DFVSGames.Repetition.ProjectionKernel
open scoped BigOperators
open Foundations.Games
noncomputable section
variable {Q₁ Qβ‚‚ A₁ Aβ‚‚ Ξ© : Type*}
[Fintype Q₁] [Fintype Qβ‚‚] [Fintype A₁] [Fintype Aβ‚‚] [Fintype Ξ©]
private theorem distribution_nonempty_inline_RoundingKernel {T : Type*} [Fintype T]
(ΞΌ : FiniteDistribution T) : Nonempty T := by
by_contra h
have : IsEmpty T := not_nonempty_iff.mp h
have hz : (βˆ‘ t, ΞΌ.weight t) = 0 := by simp
linarith [ΞΌ.normalized]
theorem vectorEnergy_le_gap_rate [Nonempty A₁] [Nonempty Aβ‚‚]
(K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚) (f : Ξ© β†’ Q₁ β†’ A₁ β†’ ℝ)
(hf : βˆ€ Ο‰ x a, 0 ≀ f Ο‰ x a) (hmass : βˆ€ x, vectorMass f x ≀ 1)
{g : ℝ} (hg0 : 0 ≀ g) (hg1 : g ≀ 1)
(hvalue : K.toGame.value ≀ 1 - g) :
K.vectorEnergy f ≀ 1 - g ^ 2 / 8 := by
classical
let : Nonempty Qβ‚‚ := distribution_nonempty_inline_RoundingKernel K.outer
let : Nonempty Q₁ := distribution_nonempty_inline_RoundingKernel
(K.inner (Classical.choice (inferInstance : Nonempty Qβ‚‚)))
rcases isEmpty_or_nonempty Ξ© with hΞ© | hΞ©
Β· let : IsEmpty Ξ© := hΞ©
have hzero : K.vectorEnergy f = 0 := by simp [vectorEnergy]
rw [hzero]
have hsq : g * g ≀ (1 : ℝ) * 1 := mul_le_mul hg1 hg1 hg0 (by norm_num)
nlinarith
Β· let : Nonempty Ξ© := hΞ©
obtain ⟨labels, hdet⟩ := K.exists_vectorEnergy_le_singleLabelVector f hf
have hnonneg := vectorAmplitude_nonnegative f hf
have hrow : βˆ€ x, rowSquareMass (vectorAmplitude f) x ≀ 1 := by
intro x
rw [rowSquareMass_vectorAmplitude]
exact hmass x
rw [K.vectorEnergy_singleLabelVector] at hdet
by_cases hg : g = 0
Β· subst g
simp only [zero_pow (by decide : 2 β‰  0), zero_div, sub_zero]
let fallback : A₁ := Classical.choice inferInstance
have hpad := pairEnergy_le_padded K.symmetricDistribution symmetricLeft
symmetricRight K.symmetricAccept labels (vectorAmplitude f) hnonneg fallback
have hone := pairEnergy_le_one_of_unit_rows K.symmetricDistribution
symmetricLeft symmetricRight K.symmetricAccept
(paddedLabel labels fallback) (paddedAmplitude (vectorAmplitude f))
(paddedAmplitude_row (vectorAmplitude f) hrow)
exact hdet.trans (hpad.trans hone)
Β· have hgpos : 0 < g := lt_of_le_of_ne hg0 (Ne.symm hg)
have hscore (a : Q₁ β†’ A₁) :
partialLabelScore K.symmetricDistribution symmetricLeft symmetricRight
K.symmetricAccept a ≀ 1 - g := by
unfold partialLabelScore
rw [K.symmetric_probability_eq_assignmentEnergy]
exact (K.assignmentEnergy_le_collisionValue a).trans
(K.collisionValue_le_value.trans hvalue)
exact hdet.trans (pairEnergy_le_of_labeling_gap K.symmetricDistribution
symmetricLeft symmetricRight K.symmetricAccept labels (vectorAmplitude f)
hnonneg hrow hgpos hscore)
end
end DFVSGames.Repetition.ProjectionKernel
namespace DFVSGames.Repetition
open scoped BigOperators
noncomputable section
variable {X A Y B U D Z C I : Type*}
[Fintype X] [Fintype A] [Fintype U] [Fintype D] [Fintype I]
def kernelApply (K : Y β†’ B β†’ X β†’ A β†’ ℝ) (f : X β†’ A β†’ ℝ) (y : Y) (b : B) : ℝ :=
βˆ‘ x, βˆ‘ a, K y b x a * f x a
def tensorKernel (K : Y β†’ B β†’ X β†’ A β†’ ℝ) (L : Z β†’ C β†’ U β†’ D β†’ ℝ)
(yz : Y Γ— Z) (bc : B Γ— C) (xu : X Γ— U) (ad : A Γ— D) : ℝ :=
K yz.1 bc.1 xu.1 ad.1 * L yz.2 bc.2 xu.2 ad.2
theorem kernelApply_tensor
(K : Y β†’ B β†’ X β†’ A β†’ ℝ) (L : Z β†’ C β†’ U β†’ D β†’ ℝ)
(f : (X Γ— U) β†’ (A Γ— D) β†’ ℝ) (y : Y) (z : Z) (b : B) (c : C) :
kernelApply (tensorKernel K L) f (y,z) (b,c) =
kernelApply K (fun x a => kernelApply L (fun u d => f (x,u) (a,d)) z c) y b := by
classical
simp only [kernelApply, tensorKernel, Fintype.sum_prod_type]
apply Finset.sum_congr rfl
intro x _
rw [Finset.sum_comm]
apply Finset.sum_congr rfl
intro a _
simp only [Finset.mul_sum, mul_assoc]
theorem kernelApply_nonnegative
(K : Y β†’ B β†’ X β†’ A β†’ ℝ) (f : X β†’ A β†’ ℝ)
(hK : βˆ€ y b x a, 0 ≀ K y b x a) (hf : βˆ€ x a, 0 ≀ f x a)
(y : Y) (b : B) : 0 ≀ kernelApply K f y b := by
apply Finset.sum_nonneg
intro x _
apply Finset.sum_nonneg
intro a _
exact mul_nonneg (hK y b x a) (hf x a)
theorem kernelApply_sum
(K : Y β†’ B β†’ X β†’ A β†’ ℝ) (f : I β†’ X β†’ A β†’ ℝ) (y : Y) (b : B) :
kernelApply K (fun x a => βˆ‘ i, f i x a) y b =
βˆ‘ i, kernelApply K (f i) y b := by
classical
simp only [kernelApply, Finset.mul_sum]
calc
(βˆ‘ x, βˆ‘ a, βˆ‘ i, K y b x a * f i x a) =
βˆ‘ x, βˆ‘ i, βˆ‘ a, K y b x a * f i x a := by
apply Finset.sum_congr rfl
intro x _
rw [Finset.sum_comm]
_ = _ := by rw [Finset.sum_comm]
theorem kernelApply_smul
(K : Y β†’ B β†’ X β†’ A β†’ ℝ) (f : X β†’ A β†’ ℝ) (r : ℝ) (y : Y) (b : B) :
kernelApply K (fun x a => r * f x a) y b = r * kernelApply K f y b := by
simp only [kernelApply, Finset.mul_sum]
apply Finset.sum_congr rfl
intro x _
apply Finset.sum_congr rfl
intro a _
exact mul_left_comm _ _ _
omit [Fintype X] in
theorem kernelApply_slice_mass
(L : Z β†’ C β†’ U β†’ D β†’ ℝ) (f : (X Γ— U) β†’ (A Γ— D) β†’ ℝ)
(x : X) (z : Z) (c : C) :
(βˆ‘ a, kernelApply L (fun u d => f (x,u) (a,d)) z c) =
kernelApply L (fun u d => βˆ‘ a, f (x,u) (a,d)) z c := by
symm
exact kernelApply_sum L (fun a u d => f (x,u) (a,d)) z c
end
end DFVSGames.Repetition
namespace DFVSGames.Repetition
open DFVSGames.Foundations.Games
open scoped BigOperators
noncomputable section
namespace ProjectionKernel
variable {Q₁ Qβ‚‚ A₁ Aβ‚‚ R₁ Rβ‚‚ B₁ Bβ‚‚ I : Type*}
[Fintype Q₁] [Fintype Qβ‚‚] [Fintype A₁] [Fintype Aβ‚‚]
[Fintype R₁] [Fintype Rβ‚‚] [Fintype B₁] [Fintype Bβ‚‚] [Fintype I]
def coefficients (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(y : Qβ‚‚) (b : Aβ‚‚) (x : Q₁) (a : A₁) : ℝ :=
(K.inner y).weight x * if K.accepts x y a b then 1 else 0
theorem apply_eq_kernelApply (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(f : Q₁ β†’ A₁ β†’ ℝ) (y : Qβ‚‚) (b : Aβ‚‚) :
K.apply f y b = kernelApply K.coefficients f y b := by
classical
unfold apply kernelApply coefficients
apply Finset.sum_congr rfl
intro x _
rw [Finset.mul_sum]
apply Finset.sum_congr rfl
intro a _
by_cases h : K.accepts x y a b = true <;> simp [h]
theorem apply_nonnegative (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(f : Q₁ β†’ A₁ β†’ ℝ) (hf : βˆ€ x a, 0 ≀ f x a) (y : Qβ‚‚) (b : Aβ‚‚) :
0 ≀ K.apply f y b := by
apply Finset.sum_nonneg
intro x _
apply mul_nonneg ((K.inner y).nonnegative x)
apply Finset.sum_nonneg
intro a _
split
Β· exact hf x a
Β· exact le_rfl
theorem apply_sum (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(f : I β†’ Q₁ β†’ A₁ β†’ ℝ) (y : Qβ‚‚) (b : Aβ‚‚) :
K.apply (fun x a => βˆ‘ i, f i x a) y b = βˆ‘ i, K.apply (f i) y b := by
simp_rw [apply_eq_kernelApply]
exact kernelApply_sum _ _ _ _
theorem apply_smul (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(f : Q₁ β†’ A₁ β†’ ℝ) (r : ℝ) (y : Qβ‚‚) (b : Aβ‚‚) :
K.apply (fun x a => r * f x a) y b = r * K.apply f y b := by
simp_rw [apply_eq_kernelApply]
exact kernelApply_smul _ _ _ _ _
def product (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(H : ProjectionKernel R₁ Rβ‚‚ B₁ Bβ‚‚) :
ProjectionKernel (Q₁ Γ— R₁) (Qβ‚‚ Γ— Rβ‚‚) (A₁ Γ— B₁) (Aβ‚‚ Γ— Bβ‚‚) where
outer := K.outer.product H.outer
inner q := (K.inner q.1).product (H.inner q.2)
accepts x y a b := K.accepts x.1 y.1 a.1 b.1 && H.accepts x.2 y.2 a.2 b.2
projection x y a b b' hb hb' := by
have h₁ := Bool.and_eq_true_iff.mp hb
have hβ‚‚ := Bool.and_eq_true_iff.mp hb'
exact Prod.ext (K.projection _ _ _ _ _ h₁.1 hβ‚‚.1)
(H.projection _ _ _ _ _ h₁.2 hβ‚‚.2)
theorem coefficients_product (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(H : ProjectionKernel R₁ Rβ‚‚ B₁ Bβ‚‚) :
(K.product H).coefficients = tensorKernel K.coefficients H.coefficients := by
funext yz bc xu ad
unfold coefficients product tensorKernel FiniteDistribution.product
by_cases hk : K.accepts xu.1 yz.1 ad.1 bc.1 = true <;>
by_cases hh : H.accepts xu.2 yz.2 ad.2 bc.2 = true <;> simp [hk, hh]
theorem apply_product (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(H : ProjectionKernel R₁ Rβ‚‚ B₁ Bβ‚‚)
(f : (Q₁ Γ— R₁) β†’ (A₁ Γ— B₁) β†’ ℝ)
(y : Qβ‚‚) (z : Rβ‚‚) (b : Aβ‚‚) (c : Bβ‚‚) :
(K.product H).apply f (y,z) (b,c) =
K.apply (fun x a => H.apply (fun u d => f (x,u) (a,d)) z c) y b := by
simp_rw [apply_eq_kernelApply]
rw [coefficients_product]
exact kernelApply_tensor _ _ _ _ _ _ _
theorem toGame_product (K : ProjectionKernel Q₁ Qβ‚‚ A₁ Aβ‚‚)
(H : ProjectionKernel R₁ Rβ‚‚ B₁ Bβ‚‚) :
(K.product H).toGame = DFVSGames.Repetition.product K.toGame H.toGame := by
have hquestions : (K.product H).toGame.questions =
(DFVSGames.Repetition.product K.toGame H.toGame).questions := by
apply FiniteDistribution.eq_of_weight_eq
intro q
change (K.outer.weight q.2.1 * H.outer.weight q.2.2) *
((K.inner q.2.1).weight q.1.1 * (H.inner q.2.2).weight q.1.2) =
(K.outer.weight q.2.1 * (K.inner q.2.1).weight q.1.1) *
(H.outer.weight q.2.2 * (H.inner q.2.2).weight q.1.2)
ring
exact congrArg
(fun questions : FiniteDistribution ((Q₁ Γ— R₁) Γ— (Qβ‚‚ Γ— Rβ‚‚)) =>
({ questions := questions
accepts := fun x y a b =>
K.accepts x.1 y.1 a.1 b.1 && H.accepts x.2 y.2 a.2 b.2 } :
Game (Q₁ Γ— R₁) (Qβ‚‚ Γ— Rβ‚‚) (A₁ Γ— B₁) (Aβ‚‚ Γ— Bβ‚‚))) hquestions
end ProjectionKernel
end
end DFVSGames.Repetition
end OAI