File size: 10,201 Bytes
cdec422 | 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 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 | import OAI.LinearAlgebra.MatrixMultiplication.Duality.ProgramIndependence
import OAI.LinearAlgebra.MatrixMultiplication.Duality.InformationConditioning
import OAI.LinearAlgebra.MatrixMultiplication.Duality.InformationTransport
import OAI.LinearAlgebra.MatrixMultiplication.Completion.ProgramPrefixes
namespace OAI
/-! Dual matrix multiplication exponents and finite rectangular constructions. -/
noncomputable section
namespace MatrixMultiplication.DualProgramIndependence
universe u w
open MatrixMultiplication.Foundation RecursiveCompletion CompletionLabels
open CompletionLaws CompletionColorLaws CompletionProductLaws
open DualInformation DualInformationTransport TopologicalFlatten
open scoped BigOperators
attribute [local instance 10000] Classical.propDecidable Classical.decEq
attribute [local instance 11000] instDecidableEqFin
variable {X Y Z : Type u} {Code : Type w} [Fintype X] [Fintype Y] [Fintype Z]
[Fintype Code] [Inhabited Code] {depth m : ℕ}
def slotCut (depth k : ℕ) (i j : Fin m) : ℕ :=
if j.val < i.val then depth else if j = i then k else 0
def slotPrior (S : FlaggedTensor X Y Z)
(p : Program (Leaf S) (Coordinate X Y Z) Color Code depth)
(i : Fin m) (k : ℕ) (j : Fin m) (a : Leaf S) :
Color × LabelRecord (fun _ => Code) (slotCut depth k i j) :=
(leafColor S a, labelRecordOf p.labels (slotCut depth k i j) a)
def slotLabel (S : FlaggedTensor X Y Z)
(p : Program (Leaf S) (Coordinate X Y Z) Color Code depth)
(i : Fin m) (k : ℕ) (j : Fin m) (a : Leaf S) : Code :=
if j = i then p.labels k a else default
omit [Fintype X] [Fintype Y] [Fintype Z] [Fintype Code] [Inhabited Code] in
theorem slotPrior_word_eq_iff (S : FlaggedTensor X Y Z)
(p : Program (Leaf S) (Coordinate X Y Z) Color Code depth)
(i : Fin m) (k : ℕ) (a b : Fin m → Leaf S) :
(fun j => slotPrior S p i k j (a j)) = (fun j => slotPrior S p i k j (b j)) ↔
(∀ j, leafColor S (a j) = leafColor S (b j)) ∧
((∀ j : Fin m, j.val < i.val →
labelRecordOf p.labels depth (a j) = labelRecordOf p.labels depth (b j)) ∧
labelRecordOf p.labels k (a i) = labelRecordOf p.labels k (b i)) := by
constructor
· intro h
refine ⟨fun j => congrArg Prod.fst (congrFun h j), ?_, ?_⟩
· intro j hj
have hs := congrArg Prod.snd (congrFun h j)
change labelRecordOf p.labels (slotCut depth k i j) (a j) =
labelRecordOf p.labels (slotCut depth k i j) (b j) at hs
rw [labelRecordOf_eq_iff] at hs ⊢
simpa only [slotCut, ite_eq_left hj] using hs
· have hs := congrArg Prod.snd (congrFun h i)
change labelRecordOf p.labels (slotCut depth k i i) (a i) =
labelRecordOf p.labels (slotCut depth k i i) (b i) at hs
rw [labelRecordOf_eq_iff] at hs ⊢
simpa [slotCut] using hs
· rintro ⟨hc, hp, hi⟩
funext j
apply Prod.ext (hc j)
change labelRecordOf p.labels (slotCut depth k i j) (a j) =
labelRecordOf p.labels (slotCut depth k i j) (b j)
rw [labelRecordOf_eq_iff]
intro n hn
by_cases hj : j.val < i.val
· have hn' : n < depth := by simpa only [slotCut, ite_eq_left hj] using hn
exact label_eq_of_record_eq p.labels (hp j hj) hn'
· by_cases hji : j = i
· subst j
have hn' : n < k := by simpa [slotCut] using hn
exact label_eq_of_record_eq p.labels hi hn'
· simp only [slotCut, ite_eq_right hj, ite_eq_right hji] at hn
exact (Nat.not_lt_zero n hn).elim
omit [Fintype X] [Fintype Y] [Fintype Z] [Fintype Code] in
theorem slotLabel_word_eq_iff (S : FlaggedTensor X Y Z)
(p : Program (Leaf S) (Coordinate X Y Z) Color Code depth)
(i : Fin m) (k : ℕ) (a b : Fin m → Leaf S) :
(fun j => slotLabel S p i k j (a j)) = (fun j => slotLabel S p i k j (b j)) ↔
p.labels k (a i) = p.labels k (b i) := by
constructor
· intro h
simpa only [slotLabel, ite_eq_left rfl, ite_true] using congrFun h i
· intro h
funext j
by_cases hji : j = i
· subst j
simpa only [slotLabel, ite_eq_left rfl, ite_true] using h
· simp only [slotLabel, ite_eq_right hji]
theorem iidColorLaw_slot_factorization (S : FlaggedTensor X Y Z)
(p : Program (Leaf S) (Coordinate X Y Z) Color Code depth)
(center output : Color)
(pc : FiniteLaw (ColorSlice S center)) (po : FiniteLaw (ColorSlice S output))
(α : ℝ) (hα : 0 ≤ α) (hα' : α ≤ 1) (hbranch : center ≠ output ∨ α = 0)
(i : Fin m) (k : ℕ)
(hc : ConditionalMassFactorization pc (fun a => labelRecordOf p.labels k a.val)
(fun a => p.labels k a.val) (fun a => a.val.val.1))
(ho : ConditionalMassFactorization po (fun a => labelRecordOf p.labels k a.val)
(fun a => p.labels k a.val) (fun a => a.val.val.1)) :
ConditionalMassFactorization (iidColorLaw S center output pc po m α hα hα')
(fun a j => slotPrior S p i k j (a j))
(fun a j => slotLabel S p i k j (a j)) (fun a j => (a j).val.1) := by
apply independentProduct_factorization
(fun _ : Fin m => colorMix S center output pc po α hα hα')
(slotPrior S p i k) (slotLabel S p i k) (fun _ a => a.val.1)
intro j
by_cases hji : j = i
· subst j
apply mass_factorization_of_same_partitions (colorMix S center output pc po α hα hα')
(fun a => (leafColor S a, labelRecordOf p.labels k a)) (p.labels k) (fun a => a.val.1)
· intro a b
simp only [slotPrior, Prod.mk.injEq, labelRecordOf_eq_iff]
simp [slotCut]
· intro a b
simp [slotLabel]
· intro a b
rfl
· exact colorMix_recorded_factorization S center output pc po α hα hα' hbranch
(labelRecordOf p.labels k) (p.labels k) (fun a => a.val.1) hc ho
· have hl : slotLabel S p i k j = (fun _ => (default : Code)) := by
funext a
simp [slotLabel, hji]
rw [hl]
exact factorization_constant_label (colorMix S center output pc po α hα hα')
(slotPrior S p i k j) (default : Code) (fun a => a.val.1)
def slotCompletionEvent (center output : Color) (i : Fin m) (k : ℕ)
(r : ∀ j : Fin m, Color × LabelRecord (fun _ => Code) (slotCut depth k i j)) : Prop :=
raisedFlag center output (fun j => (r j).1 = output) ∧
∀ j, (r j).1 = center ∨ (r j).1 = output
theorem condition_slot_factorization (S : FlaggedTensor X Y Z)
(p : Program (Leaf S) (Coordinate X Y Z) Color Code depth)
(center output : Color)
(pc : FiniteLaw (ColorSlice S center)) (po : FiniteLaw (ColorSlice S output))
(α : ℝ) (hα : 0 ≤ α) (hα' : α < 1) (hbranch : center ≠ output ∨ α = 0)
(hm : 0 < m) (i : Fin m) (k : ℕ)
(hc : ConditionalMassFactorization pc (fun a => labelRecordOf p.labels k a.val)
(fun a => p.labels k a.val) (fun a => a.val.val.1))
(ho : ConditionalMassFactorization po (fun a => labelRecordOf p.labels k a.val)
(fun a => p.labels k a.val) (fun a => a.val.val.1)) :
ConditionalMassFactorization
(condition (iidColorLaw S center output pc po m α hα hα'.le)
(completionEvent S center output m)
(completionEvent_mass_pos S center output pc po m hm α hα hα'))
(fun a j => slotPrior S p i k j (a.val j))
(fun a j => slotLabel S p i k j (a.val j)) (fun a j => (a.val j).val.1) := by
exact conditionalMassFactorization_condition
(iidColorLaw S center output pc po m α hα hα'.le)
(fun a j => slotPrior S p i k j (a j))
(fun a j => slotLabel S p i k j (a j)) (fun a j => (a j).val.1)
(slotCompletionEvent center output i k)
(completionEvent_mass_pos S center output pc po m hm α hα hα')
(iidColorLaw_slot_factorization S p center output pc po α hα hα'.le hbranch i k hc ho)
theorem conditionalCompletionLaw_inherited_factorization (S : FlaggedTensor X Y Z)
(p : Program (Leaf S) (Coordinate X Y Z) Color Code depth)
(context_eq : ∀ a, p.context a = leafColor S a)
(view_eq : ∀ side a, p.view side a = coordinate a.val side)
(center output : Color)
(pc : FiniteLaw (ColorSlice S center)) (po : FiniteLaw (ColorSlice S output))
(α : ℝ) (hα : 0 ≤ α) (hα' : α < 1) (hbranch : center ≠ output ∨ α = 0)
(hm : 0 < m) (i : Fin m) (k : ℕ) (hk : k < depth)
(hc : ConditionalMassFactorization pc (fun a => labelRecordOf p.labels k a.val)
(fun a => p.labels k a.val) (fun a => a.val.val.1))
(ho : ConditionalMassFactorization po (fun a => labelRecordOf p.labels k a.val)
(fun a => p.labels k a.val) (fun a => a.val.val.1)) :
ConditionalMassFactorization
(conditionalCompletionLaw S center output pc po m hm α hα hα')
(fun a => labelRecordOf
(completionLocalProgram S center m p context_eq view_eq).labels
(3 + (i.val * depth + k)) a.val)
(fun a => (completionLocalProgram S center m p context_eq view_eq).labels
(3 + (i.val * depth + k)) a.val)
(fun a => a.val.val.1) := by
let e := conditionalLeafEquiv S center output m
let q := condition (iidColorLaw S center output pc po m α hα hα'.le)
(completionEvent S center output m)
(completionEvent_mass_pos S center output pc po m hm α hα hα')
have hslot (a : {w : Fin m → Leaf S // completionEvent S center output m w}) :
slot S center m (e.symm a).val = a.val :=
congrArg Subtype.val (e.apply_symm_apply a)
change ConditionalMassFactorization (q.map e.symm) _ _ _
rw [mass_factorization_map_iff]
apply mass_factorization_of_same_partitions q
(fun a j => slotPrior S p i k j (a.val j))
(fun a j => slotLabel S p i k j (a.val j)) (fun a j => (a.val j).val.1)
· intro a b
rw [slotPrior_word_eq_iff, completionProgram_record_eq_iff _ _ _ _ _ _ i k hk.le]
simp only [(e.symm a).property, (e.symm b).property, true_and, pattern,
hslot, funext_iff]
· intro a b
rw [slotLabel_word_eq_iff,
completionLocalProgram_label_slot _ _ _ _ _ _ i k hk,
completionLocalProgram_label_slot _ _ _ _ _ _ i k hk, hslot, hslot]
simp only [encodeOld, Option.some.injEq, Sum.inr.injEq]
· intro a b
rfl
· exact condition_slot_factorization S p center output pc po α hα hα' hbranch hm i k hc ho
end MatrixMultiplication.DualProgramIndependence
end
end OAI
|