File size: 9,196 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 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 | import OAI.Computability.PerfectCompleteness.Sampling.OriginalUniformCutBase
namespace OAI
section
namespace PerfectCompleteness.OriginalUniformCut
open RecursiveSpaces DescendantSpaces TreeSourceSpaces HierarchicalArrays
open OriginalWholeCut OriginalWholeCutTape
open UniqueGamesTheorem.Foundations.Games
open scoped Classical
noncomputable section
attribute [local instance 2000] OriginalUniformCutBase.valuesChildrenFintype
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.transport_eq_pushforward]
exact UniformConditioning.uniform_transport e
private theorem uniform_map_product {A B C D : Type*}
[Fintype A] [Fintype B] [Fintype C] [Fintype D]
[Nonempty A] [Nonempty B] [Nonempty C] [Nonempty D]
(f : A → C) (g : B → D)
(hf : (FiniteDistribution.uniform A).pushforward f = FiniteDistribution.uniform C)
(hg : (FiniteDistribution.uniform B).pushforward g = FiniteDistribution.uniform D) :
(FiniteDistribution.uniform (A × B)).pushforward
(fun x => (f x.1, g x.2)) = FiniteDistribution.uniform (C × D) := by
rw [← WholeCutSampler.uniform_product, FiniteDistribution.product_pushforward,
hf, hg, WholeCutSampler.uniform_product]
variable {branch : Nat → Nat} {n m t : Nat}
def recordStepEquiv (rows repeats : Nat → Nat) (i : Fin (branch n))
(p : Path branch n (m + 1))
(slots : Slots branch (n + 1) → Fin t → MixedSupport.Slot) :
Record rows repeats (.step i p) slots ≃
WholeArraySampler.RootTape rows repeats (.step i p) slots ×
(Record rows repeats p (childSlots slots i) ×
((j : RecursiveSampler.OffPath i) → Arrays (childSlots slots j.val) rows)) :=
(OriginalWholeCutTape.regroupStep
(D := BucketSampler.Direction (rows (n + 1)))
(T := TerminalCalls.TerminalIndex repeats (.step i p))
(C := OriginalCutCalls.Index rows repeats p)
(S := H (cutSlots (.step i p) slots))
(E := OriginalTerminalSplit.ExteriorTape F2 repeats (.step i p) (LeafDomain slots))
(L := Exterior rows repeats p (childSlots slots i))
(O := (j : RecursiveSampler.OffPath i) → Arrays (childSlots slots j.val) rows)
(B := BelowArrays rows p (childSlots slots i))).symm.trans
(Equiv.prodCongr
(Equiv.piCongrRight (fun _ : BucketSampler.Direction (rows (n + 1)) =>
(OriginalScalarReconstruction.prefixSplit F2 repeats (.step i p)
(LeafDomain slots)).symm))
(Equiv.refl _))
def toStoppedTape (rows repeats : Nat → Nat) :
{n m : Nat} → (p : Path branch n (m + 1)) →
(slots : Slots branch n → Fin t → MixedSupport.Slot) →
Record rows repeats p slots → WholeArraySampler.Tape rows repeats p slots
| _, _, .refl _, slots, record =>
reconstructRecord rows repeats (.refl _) slots record
| _, _, .step i p, slots, record =>
let split := recordStepEquiv rows repeats i p slots record
WholeCutSampler.stepEquiv i
(WholeArraySampler.RootTape rows repeats (.step i p) slots)
(WholeArraySampler.Tape rows repeats p (childSlots slots i))
(fun j => Arrays (childSlots slots j.val) rows)
(split.1, (toStoppedTape rows repeats p (childSlots slots i) split.2.1,
split.2.2))
theorem evaluate_toStoppedTape (rows repeats : Nat → Nat) :
∀ {n m : Nat} (p : Path branch n (m + 1))
(slots : Slots branch n → Fin t → MixedSupport.Slot)
(record : Record rows repeats p slots),
WholeArraySampler.evaluate rows repeats p slots
(toStoppedTape rows repeats p slots record) =
reconstructRecord rows repeats p slots record := by
intro n
induction n with
| zero => intro m p; cases p
| succ n ih =>
intro m p slots record
cases p with
| refl => rfl
| step i p =>
exact congrArg₂ (WholeArraySampler.assemble slots rows) rfl
(congrArg (fun selected : Arrays (childSlots slots i) rows =>
WholeArraySampler.childrenAt slots rows i selected record.1.2.2)
(ih p (childSlots slots i)
(record.1.2.1, ((fun call => record.2.1 (.inr call)), record.2.2))))
theorem uniform_toStoppedTape (rows repeats : Nat → Nat) :
∀ {n m : Nat} (p : Path branch n (m + 1))
(slots : Slots branch n → Fin t → MixedSupport.Slot),
(FiniteDistribution.uniform (Record rows repeats p slots)).pushforward
(toStoppedTape rows repeats p slots) =
FiniteDistribution.uniform (WholeArraySampler.Tape rows repeats p slots) := by
intro n
induction n with
| zero => intro m p; cases p
| succ n ih =>
intro m p slots
cases p with
| refl =>
exact OriginalUniformCutBase.uniform_reconstructRecord_refl rows repeats slots
| step i p =>
let R := WholeArraySampler.RootTape rows repeats (.step i p) slots
let L := Record rows repeats p (childSlots slots i)
let S := WholeArraySampler.Tape rows repeats p (childSlots slots i)
let O := (j : RecursiveSampler.OffPath i) → Arrays (childSlots slots j.val) rows
let e := recordStepEquiv rows repeats i p slots
let finish := WholeCutSampler.stepEquiv i R S
(fun j => Arrays (childSlots slots j.val) rows)
let : Fintype (WholeArraySampler.StepTape (i := i) R S
(fun j => Arrays (childSlots slots j.val) rows)) :=
WholeArraySampler.tapeFintype rows repeats (.step i p) slots
let : Nonempty (WholeArraySampler.StepTape (i := i) R S
(fun j => Arrays (childSlots slots j.val) rows)) :=
⟨WholeArraySampler.zeroTape rows repeats (.step i p) slots⟩
let middle : R × (L × O) → R × (S × O) :=
fun z => (z.1,
(toStoppedTape rows repeats p (childSlots slots i) z.2.1, z.2.2))
have hinner : (FiniteDistribution.uniform (L × O)).pushforward
(fun z => (toStoppedTape rows repeats p (childSlots slots i) z.1, z.2)) =
FiniteDistribution.uniform (S × O) :=
uniform_map_product (toStoppedTape rows repeats p (childSlots slots i))
(id : O → O) (ih p (childSlots slots i))
(FiniteDistribution.pushforward_id _)
have hmiddle : (FiniteDistribution.uniform (R × (L × O))).pushforward middle =
FiniteDistribution.uniform (R × (S × O)) :=
uniform_map_product (id : R → R)
(fun z : L × O =>
(toStoppedTape rows repeats p (childSlots slots i) z.1, z.2))
(FiniteDistribution.pushforward_id _) hinner
calc
_ = (((FiniteDistribution.uniform (Record rows repeats (.step i p) slots)).pushforward
e).pushforward middle).pushforward finish := by
rw [FiniteDistribution.pushforward_comp, FiniteDistribution.pushforward_comp]
rfl
_ = (FiniteDistribution.uniform (R × (S × O))).pushforward finish := by
rw [uniform_equiv e, hmiddle]
_ = _ := uniform_equiv finish
def referenceLaw (rows repeats : Nat → Nat) (p : Path branch n (m + 1))
(slots : Slots branch n → Fin t → MixedSupport.Slot) :
FiniteDistribution (Record rows repeats p slots) :=
(exteriorLaw rows repeats p slots).product
((FiniteProduct.law (fun _ : OriginalCutCalls.Index rows repeats p =>
FiniteDistribution.uniform (H (cutSlots p slots)))).product
(FiniteProduct.law (fun child : Fin (branch m) =>
FiniteDistribution.uniform (Arrays (childSlots (cutSlots p slots) child) rows))))
theorem referenceLaw_uniform (rows repeats : Nat → Nat) (p : Path branch n (m + 1))
(slots : Slots branch n → Fin t → MixedSupport.Slot) :
referenceLaw rows repeats p slots = FiniteDistribution.uniform (Record rows repeats p slots) := by
unfold referenceLaw exteriorLaw
rw [UniformLinearImage.law_uniform, UniformLinearImage.law_uniform,
WholeCutSampler.uniform_product, WholeCutSampler.uniform_product]
theorem reconstruct_referenceLaw (rows repeats : Nat → Nat) (p : Path branch n (m + 1))
(slots : Slots branch n → Fin t → MixedSupport.Slot) :
(referenceLaw rows repeats p slots).pushforward (reconstructRecord rows repeats p slots) =
WholeArraySampler.law rows repeats p slots := by
rw [referenceLaw_uniform]
calc
_ = ((FiniteDistribution.uniform (Record rows repeats p slots)).pushforward
(toStoppedTape rows repeats p slots)).pushforward
(WholeArraySampler.evaluate rows repeats p slots) := by
rw [FiniteDistribution.pushforward_comp]
congr 1
funext record
exact (evaluate_toStoppedTape rows repeats p slots record).symm
_ = (FiniteDistribution.uniform (WholeArraySampler.Tape rows repeats p slots)).pushforward
(WholeArraySampler.evaluate rows repeats p slots) := by rw [uniform_toStoppedTape]
_ = _ := by rw [← WholeArraySubtreeSplit.tapeLaw_eq_uniform]; rfl
end
end PerfectCompleteness.OriginalUniformCut
end
end OAI
|