File size: 6,487 Bytes
c270adf | 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 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 | import Mathlib
import OAI.Combinatorics.IndependentSets.Repetition.Value
namespace OAI
namespace IndependentSetsGames.Foundations.Games
open scoped BigOperators
noncomputable section
namespace FiniteDistribution
theorem pushforward_eq_of_agree_on_support
{Ω Γ : Type*} [Fintype Ω] [Fintype Γ]
(μ : FiniteDistribution Ω) (f g : Ω → Γ)
(h : ∀ x, μ.weight x ≠ 0 → f x = g x) :
μ.pushforward f = μ.pushforward g := by
classical
apply eq_of_weight_eq
intro y
simp only [pushforward]
apply Finset.sum_congr rfl
intro x _
by_cases hx : μ.weight x = 0
· simp [hx]
· rw [h x hx]
theorem product_pushforward
{Ω Γ A B : Type*} [Fintype Ω] [Fintype Γ] [Fintype A] [Fintype B]
(μ : FiniteDistribution Ω) (ν : FiniteDistribution Γ)
(f : Ω → A) (g : Γ → B) :
(μ.product ν).pushforward (fun z => (f z.1, g z.2)) =
(μ.pushforward f).product (ν.pushforward g) := by
classical
apply eq_of_weight_eq
rintro ⟨a, b⟩
simp only [pushforward, product]
rw [Fintype.sum_prod_type, Finset.sum_mul_sum]
apply Finset.sum_congr rfl
intro x _
apply Finset.sum_congr rfl
intro y _
by_cases hx : f x = a <;> by_cases hy : g y = b <;> simp [hx, hy]
theorem table_row_weight_ne_zero
{Q A : Type*} [Fintype Q] [Fintype A] [DecidableEq Q]
(responses : Q → FiniteDistribution A) (answers : Q → A)
(h : (table responses).weight answers ≠ 0) (q : Q) :
(responses q).weight (answers q) ≠ 0 := by
intro hq
apply h
change (∏ r, (responses r).weight (answers r)) = 0
exact Finset.prod_eq_zero (Finset.mem_univ q) hq
theorem table_repair_pushforward
{Q A : Type*} [Fintype Q] [Fintype A] [DecidableEq Q]
(responses : Q → FiniteDistribution A) (repair : Q → A → A)
(hrepair : ∀ q a, (responses q).weight a ≠ 0 → repair q a = a) (q : Q) :
(table responses).pushforward (fun answers => repair q (answers q)) =
responses q := by
calc
_ = (table responses).pushforward (fun answers => answers q) := by
apply pushforward_eq_of_agree_on_support
intro answers h
exact hrepair q (answers q) (table_row_weight_ne_zero responses answers h q)
_ = responses q := table_eval_pushforward responses q
end FiniteDistribution
namespace KernelSampling
abbrev Seed (Q₁ Q₂ A B : Type*) := (Q₁ → A) × (Q₂ → B)
def readLeft {Q₁ Q₂ A B : Type*} (seed : Seed Q₁ Q₂ A B) (q : Q₁) : A := seed.1 q
def readRight {Q₁ Q₂ A B : Type*} (seed : Seed Q₁ Q₂ A B) (q : Q₂) : B := seed.2 q
def seedLaw {Q₁ Q₂ A B : Type*}
[Fintype Q₁] [Fintype Q₂] [Fintype A] [Fintype B]
[DecidableEq Q₁] [DecidableEq Q₂]
(left : Q₁ → FiniteDistribution A) (right : Q₂ → FiniteDistribution B) :
FiniteDistribution (Seed Q₁ Q₂ A B) :=
(FiniteDistribution.table left).product (FiniteDistribution.table right)
theorem read_joint_pushforward {Q₁ Q₂ A B : Type*}
[Fintype Q₁] [Fintype Q₂] [Fintype A] [Fintype B]
[DecidableEq Q₁] [DecidableEq Q₂]
(left : Q₁ → FiniteDistribution A) (right : Q₂ → FiniteDistribution B)
(x : Q₁) (y : Q₂) :
(seedLaw left right).pushforward (fun seed => (readLeft seed x, readRight seed y)) =
(left x).product (right y) := by
unfold seedLaw readLeft readRight
rw [FiniteDistribution.product_pushforward
(FiniteDistribution.table left) (FiniteDistribution.table right)
(fun answers => answers x) (fun answers => answers y),
FiniteDistribution.table_eval_pushforward, FiniteDistribution.table_eval_pushforward]
theorem repaired_joint_pushforward {Q₁ Q₂ A B : Type*}
[Fintype Q₁] [Fintype Q₂] [Fintype A] [Fintype B]
[DecidableEq Q₁] [DecidableEq Q₂]
(left : Q₁ → FiniteDistribution A) (right : Q₂ → FiniteDistribution B)
(repairLeft : Q₁ → A → A) (repairRight : Q₂ → B → B)
(hleft : ∀ x a, (left x).weight a ≠ 0 → repairLeft x a = a)
(hright : ∀ y b, (right y).weight b ≠ 0 → repairRight y b = b)
(x : Q₁) (y : Q₂) :
(seedLaw left right).pushforward (fun seed =>
(repairLeft x (readLeft seed x), repairRight y (readRight seed y))) =
(left x).product (right y) := by
unfold seedLaw readLeft readRight
rw [FiniteDistribution.product_pushforward
(FiniteDistribution.table left) (FiniteDistribution.table right)
(fun answers => repairLeft x (answers x)) (fun answers => repairRight y (answers y)),
FiniteDistribution.table_repair_pushforward left repairLeft hleft,
FiniteDistribution.table_repair_pushforward right repairRight hright]
variable {I A B S : Type*} [DecidableEq I]
def completedLeft (j : I)
(seed : Seed (A × S) (B × S) (I → A) (I → B)) (q : A × S) : I → A :=
Function.update (readLeft seed q) j q.1
def completedRight (j : I)
(seed : Seed (A × S) (B × S) (I → A) (I → B)) (q : B × S) : I → B :=
Function.update (readRight seed q) j q.1
@[simp] theorem completedLeft_coordinate (j : I)
(seed : Seed (A × S) (B × S) (I → A) (I → B)) (q : A × S) :
completedLeft j seed q j = q.1 := by simp [completedLeft]
@[simp] theorem completedRight_coordinate (j : I)
(seed : Seed (A × S) (B × S) (I → A) (I → B)) (q : B × S) :
completedRight j seed q j = q.1 := by simp [completedRight]
private theorem update_eq_of_coordinate (xs : I → A) (j : I) (a : A)
(h : xs j = a) : Function.update xs j a = xs := by
funext i
by_cases hi : i = j <;> simp [Function.update, hi, h]
theorem completed_joint_pushforward
[Fintype I] [Fintype A] [Fintype B] [Fintype S]
[DecidableEq A] [DecidableEq B] [DecidableEq S]
(left : (A × S) → FiniteDistribution (I → A))
(right : (B × S) → FiniteDistribution (I → B)) (j : I)
(hleft : ∀ q xs, (left q).weight xs ≠ 0 → xs j = q.1)
(hright : ∀ q ys, (right q).weight ys ≠ 0 → ys j = q.1)
(x : A × S) (y : B × S) :
(seedLaw left right).pushforward
(fun seed => (completedLeft j seed x, completedRight j seed y)) =
(left x).product (right y) := by
apply repaired_joint_pushforward left right
(fun q xs => Function.update xs j q.1) (fun q ys => Function.update ys j q.1)
· intro q xs h
exact update_eq_of_coordinate xs j q.1 (hleft q xs h)
· intro q ys h
exact update_eq_of_coordinate ys j q.1 (hright q ys h)
end KernelSampling
end
end IndependentSetsGames.Foundations.Games
end OAI
|