File size: 7,290 Bytes
2f887db | 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 | import OAI.Computability.PerfectCompleteness.Foundations.DependentPredictionDifferenceLemmas
import OAI.Computability.PerfectCompleteness.Foundations.FiniteProduct
import OAI.Computability.PerfectCompleteness.Sampling.RationalFiniteLawLemmas
namespace OAI
section
namespace PerfectCompleteness.BucketDescriptorLaw
open UniqueGamesTheorem.Foundations.Games
open scoped BigOperators Classical
noncomputable section
abbrev Buckets (D V : Type*) := D → V
abbrev Record (E D V : Type*) := Σ _ : E, D × (Buckets D V × V)
variable {D E T V : Type*} [Fintype D] [Fintype E] [Fintype T] [Fintype V]
def bucketLaw (D : Type*) [Fintype D] (ρ : FiniteDistribution V) :
FiniteDistribution (Buckets D V) :=
FiniteProduct.law (fun _ : D => ρ)
def sampleLaw (δ : FiniteDistribution D) (ρ : FiniteDistribution V) :
FiniteDistribution (D × (Buckets D V × V)) :=
δ.product ((bucketLaw D ρ).product ρ)
def observe (read : T → E × Buckets D V) (z : D × (T × V)) : Record E D V :=
⟨(read z.2.1).1, (z.1, ((read z.2.1).2, z.2.2))⟩
private def reorder (D E B V : Type*) :
D × ((E × B) × V) ≃ Σ _ : E, D × (B × V) where
toFun z := ⟨z.2.1.1, (z.1, (z.2.1.2, z.2.2))⟩
invFun z := (z.2.1, ((z.1, z.2.2.1), z.2.2.2))
left_inv _ := rfl
right_inv _ := rfl
theorem reorder_law {B : Type*} [Fintype B]
(δ : FiniteDistribution D) (ν : FiniteDistribution E)
(κ : FiniteDistribution B) (ρ : FiniteDistribution V) :
(δ.product ((ν.product κ).product ρ)).pushforward
(fun z => (⟨z.2.1.1, (z.1, (z.2.1.2, z.2.2))⟩ : Σ _ : E, D × (B × V))) =
CompletionSoundness.sigmaLaw ν (fun _ => δ.product (κ.product ρ)) := by
change (δ.product ((ν.product κ).product ρ)).pushforward (reorder D E B V) = _
rw [← FiniteDistribution.transport_eq_pushforward]
apply FiniteDistribution.eq_of_weight_eq
intro z
change δ.weight z.2.1 * ((ν.weight z.1 * κ.weight z.2.2.1) * ρ.weight z.2.2.2) =
ν.weight z.1 * (δ.weight z.2.1 * (κ.weight z.2.2.1 * ρ.weight z.2.2.2))
rw [mul_assoc]
exact mul_left_comm _ _ _
theorem observe_law (μ : FiniteDistribution T) (ν : FiniteDistribution E)
(ρ : FiniteDistribution V) (δ : FiniteDistribution D)
(read : T → E × Buckets D V)
(hread : μ.pushforward read = ν.product (bucketLaw D ρ)) :
(δ.product (μ.product ρ)).pushforward (observe read) =
CompletionSoundness.sigmaLaw ν (fun _ => sampleLaw δ ρ) := by
have hinner : (μ.product ρ).pushforward (fun z => (read z.1, z.2)) =
(ν.product (bucketLaw D ρ)).product ρ := by
simpa only [id_eq, FiniteDistribution.pushforward_id, hread] using
FiniteDistribution.product_pushforward μ ρ read (id : V → V)
have houter : (δ.product (μ.product ρ)).pushforward
(fun z => (z.1, (read z.2.1, z.2.2))) =
δ.product ((ν.product (bucketLaw D ρ)).product ρ) := by
simpa only [id_eq, FiniteDistribution.pushforward_id, hinner] using
FiniteDistribution.product_pushforward δ (μ.product ρ) (id : D → D)
(fun z : T × V => (read z.1, z.2))
calc
_ = ((δ.product (μ.product ρ)).pushforward
(fun z => (z.1, (read z.2.1, z.2.2)))).pushforward
(reorder D E (Buckets D V) V) :=
(FiniteDistribution.pushforward_comp _ _ _).symm
_ = (δ.product ((ν.product (bucketLaw D ρ)).product ρ)).pushforward
(reorder D E (Buckets D V) V) :=
congrArg (fun η : FiniteDistribution (D × ((E × Buckets D V) × V)) =>
η.pushforward (reorder D E (Buckets D V) V)) houter
_ = _ := reorder_law δ ν (bucketLaw D ρ) ρ
variable {D' V' : Type*} [Fintype D'] [Fintype V']
def sampleEquiv (eD : D ≃ D') (eV : V ≃ V') :
(D × (Buckets D V × V)) ≃ (D' × (Buckets D' V' × V')) :=
Equiv.prodCongr eD (Equiv.prodCongr (Equiv.arrowCongr eD eV) eV)
def recordEquiv (eD : D ≃ D') (eV : V ≃ V') : Record E D V ≃ Record E D' V' :=
Equiv.sigmaCongrRight (fun _ => sampleEquiv eD eV)
theorem bucketLaw_equiv (ρ : FiniteDistribution V) (eD : D ≃ D') (eV : V ≃ V') :
(bucketLaw D ρ).pushforward (Equiv.arrowCongr eD eV) =
bucketLaw D' (ρ.pushforward eV) := by
rw [← FiniteDistribution.transport_eq_pushforward (bucketLaw D ρ) (Equiv.arrowCongr eD eV),
← FiniteDistribution.transport_eq_pushforward ρ eV]
apply FiniteDistribution.eq_of_weight_eq
intro buckets
change (∏ d : D, ρ.weight (eV.symm (buckets (eD d)))) =
∏ d : D', ρ.weight (eV.symm (buckets d))
exact eD.prod_comp (fun d => ρ.weight (eV.symm (buckets d)))
theorem sampleLaw_equiv (δ : FiniteDistribution D) (ρ : FiniteDistribution V)
(eD : D ≃ D') (eV : V ≃ V') :
(sampleLaw δ ρ).pushforward (sampleEquiv eD eV) =
sampleLaw (δ.pushforward eD) (ρ.pushforward eV) := by
have hinner : ((bucketLaw D ρ).product ρ).pushforward
(Equiv.prodCongr (Equiv.arrowCongr eD eV) eV) =
(bucketLaw D' (ρ.pushforward eV)).product (ρ.pushforward eV) := by
exact (FiniteDistribution.product_pushforward (bucketLaw D ρ) ρ
(Equiv.arrowCongr eD eV) eV).trans
(congrArg (fun η : FiniteDistribution (Buckets D' V') => η.product (ρ.pushforward eV))
(bucketLaw_equiv ρ eD eV))
exact (FiniteDistribution.product_pushforward δ ((bucketLaw D ρ).product ρ)
eD (Equiv.prodCongr (Equiv.arrowCongr eD eV) eV)).trans
(congrArg (fun η : FiniteDistribution (Buckets D' V' × V') =>
(δ.pushforward eD).product η) hinner)
theorem reference_equiv (ν : FiniteDistribution E) (δ : FiniteDistribution D)
(ρ : FiniteDistribution V) (eD : D ≃ D') (eV : V ≃ V') :
(CompletionSoundness.sigmaLaw ν (fun _ => sampleLaw δ ρ)).pushforward
(recordEquiv (E := E) eD eV) =
CompletionSoundness.sigmaLaw ν
(fun _ => sampleLaw (δ.pushforward eD) (ρ.pushforward eV)) := by
have hmap : (⇑(recordEquiv (E := E) eD eV) : Record E D V → Record E D' V') =
(fun z => ⟨z.1, sampleEquiv eD eV z.2⟩) := by
funext z
cases z
rfl
rw [hmap]
have h := SigmaObservation.pushforward_fiber ν (fun _ => sampleLaw δ ρ)
(fun _ => ⇑(sampleEquiv eD eV))
simpa only [sampleLaw_equiv] using h
theorem observe_equiv_law (μ : FiniteDistribution T) (ν : FiniteDistribution E)
(ρ : FiniteDistribution V) (δ : FiniteDistribution D)
(read : T → E × Buckets D V)
(hread : μ.pushforward read = ν.product (bucketLaw D ρ))
(eD : D ≃ D') (eV : V ≃ V') :
(δ.product (μ.product ρ)).pushforward
(fun z => recordEquiv (E := E) eD eV (observe read z)) =
CompletionSoundness.sigmaLaw ν
(fun _ => sampleLaw (δ.pushforward eD) (ρ.pushforward eV)) := by
calc
_ = ((δ.product (μ.product ρ)).pushforward (observe read)).pushforward
(recordEquiv (E := E) eD eV) :=
(FiniteDistribution.pushforward_comp _ _ _).symm
_ = (CompletionSoundness.sigmaLaw ν (fun _ => sampleLaw δ ρ)).pushforward
(recordEquiv (E := E) eD eV) :=
congrArg (fun η : FiniteDistribution (Record E D V) =>
η.pushforward (recordEquiv (E := E) eD eV)) (observe_law μ ν ρ δ read hread)
_ = _ := reference_equiv ν δ ρ eD eV
end
end PerfectCompleteness.BucketDescriptorLaw
end
end OAI
|