File size: 7,828 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 | import OAI.Computability.PerfectCompleteness.Construction.HiddenBucketBias
import OAI.Computability.PerfectCompleteness.Sampling.PreliminarySampler
import OAI.Computability.PerfectCompleteness.Sampling.RationalFiniteLawLemmas
import OAI.Computability.PerfectCompleteness.Sampling.SourceChildKernelMarginalLemmas
namespace OAI
section
namespace PerfectCompleteness.SourceChildQuestionLaw
open RecursiveSpaces TreeSourceSpaces HierarchicalArrays SourceQuestionReconstruction
open UniqueGamesTheorem.Foundations.Games
open scoped Classical
noncomputable section
variable {branch : Nat → Nat} {n m t v : Nat}
def sourceLaw (m t : Nat) [NeZero m] (designated : Fin (branch n) → Slots branch n) :
FiniteDistribution (SourceChildKernel.Sources (m := m) (t := t) designated) :=
FiniteProduct.law (fun i => (SourceOddLists.tupleLaw m t).product
(FiniteProduct.law (fun _ : {leaf : Slots branch n // leaf ≠ designated i} =>
SourceOddLists.tupleLaw m t)))
def assembleEquiv (designated : Fin (branch n) → Slots branch n) :
SourceChildKernel.Sources (m := m) (t := t) designated ≃
(Slots branch (n + 1) → SourceTuple m t) where
toFun sources leaf := CleanSourceRecord.assemble designated leaf.1
(sources leaf.1).1 (sources leaf.1).2 leaf.2
invFun tree i := (Equiv.piSplitAt (designated i) (fun _ : Slots branch n => SourceTuple m t))
(fun leaf => tree (i, leaf))
left_inv sources := by
funext i
exact (Equiv.piSplitAt (designated i) (fun _ : Slots branch n => SourceTuple m t)).apply_symm_apply
(sources i)
right_inv tree := by
funext leaf
exact congrFun
((Equiv.piSplitAt (designated leaf.1) (fun _ : Slots branch n => SourceTuple m t)).symm_apply_apply
(fun s => tree (leaf.1, s))) leaf.2
theorem assemble_child_law (designated : Fin (branch n) → Slots branch n)
(μ : FiniteDistribution (SourceTuple m t)) (i : Fin (branch n)) :
(μ.product (FiniteProduct.law
(fun _ : {leaf : Slots branch n // leaf ≠ designated i} => μ))).pushforward
(fun source => CleanSourceRecord.assemble designated i source.1 source.2) =
FiniteProduct.law (fun _ : Slots branch n => μ) := by
let split := Equiv.piSplitAt (designated i) (fun _ : Slots branch n => SourceTuple m t)
have hsplit : (FiniteProduct.law (fun _ : Slots branch n => μ)).pushforward split =
μ.product (FiniteProduct.law
(fun _ : {leaf : Slots branch n // leaf ≠ designated i} => μ)) :=
SourceCoordinateSplit.coordinate_split_pushforward (fun _ : Slots branch n => μ) (designated i)
change (μ.product (FiniteProduct.law
(fun _ : {leaf : Slots branch n // leaf ≠ designated i} => μ))).pushforward split.symm = _
rw [← hsplit, FiniteDistribution.pushforward_comp]
simp only [Equiv.symm_apply_apply]
exact UniqueGamesTheorem.Foundations.Games.FiniteDistribution.pushforward_id
(FiniteProduct.law (fun _ : Slots branch n => μ))
private theorem uniform_product {A B : Type*} [Fintype A] [Fintype B]
[Nonempty A] [Nonempty B] :
(FiniteDistribution.uniform A).product (FiniteDistribution.uniform B) =
FiniteDistribution.uniform (A × B) := by
apply FiniteDistribution.eq_of_weight_eq
intro x
simp only [FiniteDistribution.product, FiniteDistribution.uniform,
Fintype.card_prod, Nat.cast_mul, one_div_mul_one_div]
private theorem uniform_equiv {A B : Type*} [Fintype A] [Fintype B]
[Nonempty A] [Nonempty B] (e : A ≃ B) :
(FiniteDistribution.uniform A).pushforward e = FiniteDistribution.uniform B := by
rw [FiniteDistribution.pushforward_equiv]
apply FiniteDistribution.eq_of_weight_eq
intro x
change 1 / (Fintype.card A : ℝ) = 1 / (Fintype.card B : ℝ)
rw [Fintype.card_congr e]
theorem sourceLaw_uniform [NeZero m] (designated : Fin (branch n) → Slots branch n) :
sourceLaw m t designated =
FiniteDistribution.uniform (SourceChildKernel.Sources (m := m) (t := t) designated) := by
simp only [sourceLaw, SourceOddLists.tupleLaw, FiniteDistribution.iid_uniform,
UniformLinearImage.law_uniform, uniform_product]
theorem assemble_law [NeZero m] (designated : Fin (branch n) → Slots branch n) :
(sourceLaw m t designated).pushforward (assembleEquiv (m := m) (t := t) designated) =
FiniteDistribution.uniform (Slots branch (n + 1) → SourceTuple m t) := by
rw [sourceLaw_uniform]
exact uniform_equiv _
def questions (designated : Fin (branch n) → Slots branch n)
(sources : SourceChildKernel.Sources (m := m) (t := t) designated) :
PreliminarySampler.Questions branch (n + 1) t m :=
fun leaf k => (assembleEquiv designated sources leaf k).1
private def splitPositions :
(Slots branch (n + 1) → SourceTuple m t) ≃
(PreliminarySampler.Questions branch (n + 1) t m ×
(Slots branch (n + 1) → Fin t → Fin 3)) where
toFun tree := (fun leaf k => (tree leaf k).1, fun leaf k => (tree leaf k).2)
invFun parts leaf k := (parts.1 leaf k, parts.2 leaf k)
left_inv _ := rfl
right_inv _ := rfl
theorem questions_law [NeZero m] (designated : Fin (branch n) → Slots branch n) :
(sourceLaw m t designated).pushforward (questions designated) =
PreliminarySampler.questionsLaw (branch := branch) (n := n + 1) (t := t) (m := m) := by
let e := splitPositions (branch := branch) (n := n) (m := m) (t := t)
calc
_ = (((sourceLaw m t designated).pushforward
(assembleEquiv (m := m) (t := t) designated)).pushforward e).pushforward Prod.fst := by
rw [FiniteDistribution.pushforward_comp, FiniteDistribution.pushforward_comp]; rfl
_ = ((FiniteDistribution.uniform (Slots branch (n + 1) → SourceTuple m t)).pushforward e).pushforward
Prod.fst := by rw [assemble_law]
_ = (FiniteDistribution.uniform
(PreliminarySampler.Questions branch (n + 1) t m ×
(Slots branch (n + 1) → Fin t → Fin 3))).pushforward Prod.fst := by
rw [uniform_equiv]
_ = _ := by
rw [← uniform_product, HiddenBucketBias.product_fst]; rfl
theorem parentLeftSlots_eq (clauses : Fin m → SourceClause.NormalizedClause v)
(designated : Fin (branch n) → Slots branch n)
(sources : SourceChildKernel.Sources (m := m) (t := t) designated) :
SourceChildKernel.parentLeftSlots clauses designated sources =
HierarchicalArrays.sourceSlots clauses (PreliminarySampler.endpoints (questions designated sources)) := rfl
theorem originalLaw_sources {C : Type*} [Fintype C] [NeZero m]
(rows : Nat → Nat) (clauses : Fin m → SourceClause.NormalizedClause v)
(designated : Fin (branch n) → Slots branch n)
(flag : Fin (branch n) → FiniteDistribution Bool) :
(SourceChildKernel.originalLaw (C := C) (t := t) rows clauses designated flag).pushforward
(SourceChildKernelMarginal.sources rows clauses designated) = sourceLaw m t designated :=
SourceChildKernelMarginal.originalLaw_sources rows clauses designated flag
theorem originalLaw_questions {C : Type*} [Fintype C] [NeZero m]
(rows : Nat → Nat) (clauses : Fin m → SourceClause.NormalizedClause v)
(designated : Fin (branch n) → Slots branch n)
(flag : Fin (branch n) → FiniteDistribution Bool) :
(SourceChildKernel.originalLaw (C := C) (t := t) rows clauses designated flag).pushforward
(fun sample => questions designated (SourceChildKernelMarginal.sources rows clauses designated sample)) =
PreliminarySampler.questionsLaw (branch := branch) (n := n + 1) (t := t) (m := m) := by
rw [← FiniteDistribution.pushforward_comp
(SourceChildKernel.originalLaw (C := C) (t := t) rows clauses designated flag)
(SourceChildKernelMarginal.sources rows clauses designated) (questions designated), originalLaw_sources]
exact questions_law designated
end
end PerfectCompleteness.SourceChildQuestionLaw
end
end OAI
|