File size: 10,183 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 | import OAI.LinearAlgebra.MatrixMultiplication.Duality.CompletionIndependence
import OAI.LinearAlgebra.MatrixMultiplication.Duality.InformationLabelConditioning
import OAI.LinearAlgebra.MatrixMultiplication.Duality.UniformMixtures
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 DualUniformProducts
open DualInformation DualInformationTransport DualUniformMixtures TopologicalFlatten
open scoped BigOperators
theorem rootColor_inj_before_three {i j : ℕ} (hi : i < 3) (hj : j < 3) :
rootColor i = rootColor j ↔ i = j := by
interval_cases i <;> interval_cases j <;> simp [rootColor]
private theorem completion_index_decomposition {n m depth : ℕ}
(hn : n < 3 + m * depth) (hn3 : ¬ n < 3) :
0 < depth ∧ n - 3 < m * depth ∧
n = 3 + ((n - 3) / depth * depth + (n - 3) % depth) := by
have hd : 0 < depth := by
by_contra h
have hz : depth = 0 := by omega
simp only [hz, mul_zero, add_zero] at hn
omega
refine ⟨hd, by omega, ?_⟩
have h : (n - 3) / depth * depth + (n - 3) % depth = n - 3 := by
simpa only [Nat.mul_comm] using Nat.div_add_mod (n - 3) depth
omega
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 : ℕ}
theorem conditionalCompletionLaw_pattern_factorization (S : FlaggedTensor X Y Z)
(center output : Color)
(pc : FiniteLaw (ColorSlice S center)) (po : FiniteLaw (ColorSlice S output))
(α : ℝ) (hα : 0 ≤ α) (hα' : α < 1) (hm : 0 < m)
(hcommon : ∀ x, (pc.map (fun a => a.val.val.1)).mass x =
(po.map (fun a => a.val.val.1)).mass x) :
ConditionalMassFactorization
(conditionalCompletionLaw S center output pc po m hm α hα hα')
(fun _ => (PUnit.unit : PUnit.{1})) (fun a => pattern S center m a.val)
(fun a => a.val.val.1) := by
let mix := colorMix S center output pc po α hα hα'.le
have hs (c : Color) (x : X) :
(mix.map (fun a => (leafColor S a, a.val.1))).mass (c, x) =
(mix.map (leafColor S)).mass c * (mix.map (fun a => a.val.1)).mass x := by
have h := colorMix_independent_common S center output pc po α hα hα'.le
(fun a => a.val.1) hcommon x c
simpa only [FiniteLaw.map_mass, Prod.mk.injEq, and_comm, mul_comm] using h
have hw : ConditionalMassFactorization (iidColorLaw S center output pc po m α hα hα'.le)
(fun _ => (PUnit.unit : PUnit.{1})) (fun a j => leafColor S (a j)) (fun a j => (a j).val.1) := by
apply (mass_factorization_const_iff _ _ _).mpr
exact independentProduct_independent (fun _ : Fin m => mix)
(fun _ => leafColor S) (fun _ a => a.val.1) (fun _ => hs)
let Q : (Fin m → Color) → Prop := fun c =>
raisedFlag center output (fun j => c j = output) ∧
∀ j, c j = center ∨ c j = output
have hcondition := conditionalMassFactorization_condition_label
(iidColorLaw S center output pc po m α hα hα'.le)
(fun a j => leafColor S (a j)) (fun a j => (a j).val.1) Q
(completionEvent_mass_pos S center output pc po m hm α hα hα') hw
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 _ => (PUnit.unit : PUnit.{1}))
(fun a j => leafColor S (a.val j)) (fun a j => (a.val j).val.1)
· intro a b
rfl
· intro a b
rfl
· intro a b
rfl
· exact hcondition
theorem conditionalCompletionLaw_root_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) (hm : 0 < m)
(n : ℕ) (hn : n < 3)
(hcommon : ownerPair center output = .yz → ∀ x,
(pc.map (fun a => a.val.val.1)).mass x =
(po.map (fun a => a.val.val.1)).mass x)
(hpair : (completionLocalProgram S center m p context_eq view_eq).pair n = .yz) :
ConditionalMassFactorization
(conditionalCompletionLaw S center output pc po m hm α hα hα')
(fun a => labelRecordOf
(completionLocalProgram S center m p context_eq view_eq).labels n a.val)
(fun a => (completionLocalProgram S center m p context_eq view_eq).labels n a.val)
(fun a => a.val.val.1) := by
let law := conditionalCompletionLaw S center output pc po m hm α hα hα'
let cp := completionLocalProgram S center m p context_eq view_eq
have hroot (j : ℕ) (hj : j < 3) (a : ColorSlice (complete S center m) output) :
cp.labels j a.val = encodePattern
(if output = rootColor j then some (pattern S center m a.val) else none) := by
rw [completionLocalProgram_label_root S center m p context_eq view_eq j hj, a.property]
split_ifs <;> rfl
by_cases hactive : output = rootColor n
· have hp : ownerPair center output = .yz := by
rw [completionLocalProgram_pair_root S center m p context_eq view_eq n hn,
← hactive] at hpair
exact hpair
have hprev (a b : ColorSlice (complete S center m) output) :
labelRecordOf cp.labels n a.val = labelRecordOf cp.labels n b.val := by
apply (labelRecordOf_eq_iff _ _ _ _).mpr
intro j hj
have hj3 : j < 3 := lt_trans hj hn
have hne : output ≠ rootColor j := by
intro he
have hnj : n = j := (rootColor_inj_before_three hn hj3).mp (hactive.symm.trans he)
exact (Nat.ne_of_lt hj) hnj.symm
rw [hroot j hj3 a, hroot j hj3 b, ite_eq_right hne, ite_eq_right hne]
apply mass_factorization_of_same_partitions law (fun _ => (PUnit.unit : PUnit.{1}))
(fun a => pattern S center m a.val) (fun a => a.val.val.1)
· intro a b
exact iff_of_true rfl (hprev a b)
· intro a b
rw [hroot n hn a, hroot n hn b, ite_eq_left hactive, ite_eq_left hactive]
simp only [encodePattern, Option.some.injEq, Sum.inl.injEq]
· intro a b
rfl
· exact conditionalCompletionLaw_pattern_factorization S center output pc po α hα hα' hm
(hcommon hp)
· have hlabel : (fun a : ColorSlice (complete S center m) output => cp.labels n a.val) =
(fun _ => encodePattern (Code := Code) none) := by
funext a
rw [hroot n hn a, ite_eq_right hactive]
change ConditionalMassFactorization law _ _ _
rw [hlabel]
exact factorization_constant_label law _ _ _
theorem conditionalCompletionLaw_program_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)
(hcommon : ownerPair center output = .yz → ∀ x,
(pc.map (fun a => a.val.val.1)).mass x =
(po.map (fun a => a.val.val.1)).mass x)
(hc : ∀ n : Fin depth, p.pair n.val = .yz →
ConditionalMassFactorization pc (fun a => labelRecordOf p.labels n.val a.val)
(fun a => p.labels n.val a.val) (fun a => a.val.val.1))
(ho : ∀ n : Fin depth, p.pair n.val = .yz →
ConditionalMassFactorization po (fun a => labelRecordOf p.labels n.val a.val)
(fun a => p.labels n.val a.val) (fun a => a.val.val.1))
(n : Fin (3 + m * depth))
(hpair : (completionLocalProgram S center m p context_eq view_eq).pair n.val = .yz) :
ConditionalMassFactorization
(conditionalCompletionLaw S center output pc po m hm α hα hα')
(fun a => labelRecordOf
(completionLocalProgram S center m p context_eq view_eq).labels n.val a.val)
(fun a => (completionLocalProgram S center m p context_eq view_eq).labels n.val a.val)
(fun a => a.val.val.1) := by
by_cases hn : n.val < 3
· exact conditionalCompletionLaw_root_factorization S p context_eq view_eq
center output pc po α hα hα' hm n.val hn hcommon hpair
· obtain ⟨hd, hnm, hdecomp⟩ := completion_index_decomposition n.isLt hn
let i : Fin m := ⟨(n.val - 3) / depth, (Nat.div_lt_iff_lt_mul hd).mpr hnm⟩
let k : ℕ := (n.val - 3) % depth
have hk : k < depth := Nat.mod_lt _ hd
have hsplit : n.val = 3 + (i.val * depth + k) := hdecomp
rw [hsplit, completionLocalProgram_pair_slot S center m p context_eq view_eq i k hk] at hpair
apply mass_factorization_of_same_partitions
(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)
· intro a b
simp only [labelRecordOf_eq_iff, ← hsplit]
· intro a b
simp only [← hsplit]
· intro a b
rfl
· exact conditionalCompletionLaw_inherited_factorization
S p context_eq view_eq center output pc po α hα hα' hbranch hm i k hk
(hc ⟨k, hk⟩ hpair) (ho ⟨k, hk⟩ hpair)
end MatrixMultiplication.DualProgramIndependence
end
end OAI
|