openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /Duality /RootIndependence.lean
| 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 | |