openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /Duality /TerminationIndependence.lean
| import OAI.LinearAlgebra.MatrixMultiplication.Duality.ProgramIndependence | |
| import OAI.LinearAlgebra.MatrixMultiplication.Completion.ProgramPrefixes | |
| import OAI.LinearAlgebra.MatrixMultiplication.Completion.TerminationLaw | |
| import OAI.LinearAlgebra.MatrixMultiplication.Duality.InformationTransport | |
| namespace OAI | |
| /-! Dual matrix multiplication exponents and finite rectangular constructions. -/ | |
| noncomputable section | |
| namespace MatrixMultiplication.DualProgramIndependence | |
| open MatrixMultiplication.Foundation CompletionLabels CompletionLabels.TopologicalFlatten | |
| open CompletionColorLaws DualInformation DualInformationTransport | |
| attribute [local instance 10000] Classical.propDecidable Classical.decEq | |
| attribute [local instance 11000] instDecidableEqFin | |
| universe u w | |
| variable {X Y Z : Type u} [Fintype X] [Fintype Y] [Fintype Z] | |
| {Code : Type w} [Fintype Code] [Inhabited Code] {depth : ℕ} | |
| omit [Fintype X] [Fintype Y] [Fintype Z] [Fintype Code] in | |
| theorem termination_label_succ (S : FlaggedTensor X Y Z) (first second : Color) | |
| (hne : first ≠ second) | |
| (p : Program (Leaf S) (Coordinate X Y Z) Color Code depth) | |
| (hcontext : ∀ a, p.context a = leafColor S a) | |
| (hview : ∀ c a, p.view c a = coordinate a.val c) | |
| (k : ℕ) (a : RetainedLeaf S first second) : | |
| (terminationProgram S first second hne p hcontext hview).labels (1 + k) a = | |
| Sum.inr (p.labels k a.val) := by | |
| exact Program.append_labels_right _ _ _ _ _ k a | |
| omit [Fintype X] [Fintype Y] [Fintype Z] [Fintype Code] in | |
| theorem termination_pair_succ (S : FlaggedTensor X Y Z) (first second : Color) | |
| (hne : first ≠ second) | |
| (p : Program (Leaf S) (Coordinate X Y Z) Color Code depth) | |
| (hcontext : ∀ a, p.context a = leafColor S a) | |
| (hview : ∀ c a, p.view c a = coordinate a.val c) (k : ℕ) : | |
| (terminationProgram S first second hne p hcontext hview).pair (1 + k) = p.pair k := by | |
| simp [terminationProgram, Program.append, Program.recode, terminationInherited, | |
| Program.pullback] | |
| omit [Fintype X] [Fintype Y] [Fintype Z] [Fintype Code] in | |
| theorem termination_record_eq_iff (S : FlaggedTensor X Y Z) (first second : Color) | |
| (hne : first ≠ second) | |
| (p : Program (Leaf S) (Coordinate X Y Z) Color Code depth) | |
| (hcontext : ∀ a, p.context a = leafColor S a) | |
| (hview : ∀ c a, p.view c a = coordinate a.val c) | |
| (k : ℕ) (a b : RetainedLeaf S first second) : | |
| labelRecordOf (terminationProgram S first second hne p hcontext hview).labels (1 + k) a = | |
| labelRecordOf (terminationProgram S first second hne p hcontext hview).labels (1 + k) b ↔ | |
| leafColor S a.val = leafColor S b.val ∧ | |
| labelRecordOf p.labels k a.val = labelRecordOf p.labels k b.val := by | |
| trans | |
| (labelRecordOf (terminationRoot S first second hne).labels 1 a = | |
| labelRecordOf (terminationRoot S first second hne).labels 1 b ∧ | |
| labelRecordOf (terminationInherited S first second p hview).labels k a = | |
| labelRecordOf (terminationInherited S first second p hview).labels k b) | |
| · exact (Program.append_record_eq_iff _ _ _ _ _ k a b).trans | |
| (and_congr | |
| (Program.recode_record_eq_iff _ _ _ _ 1 a b) | |
| (Program.recode_record_eq_iff _ _ _ _ k a b)) | |
| simp only [terminationRoot, Program.single, labelRecordOf, | |
| terminationInherited, Program.pullback] | |
| have hpull (v : RetainedLeaf S first second) : | |
| labelRecordOf (fun n (b : RetainedLeaf S first second) => p.labels n b.val) k v = | |
| labelRecordOf p.labels k v.val := by | |
| induction k with | |
| | zero => rfl | |
| | succ k ih => simp only [labelRecordOf, ih]; rfl | |
| rw [hpull a, hpull b] | |
| constructor | |
| · rintro ⟨he, hr⟩ | |
| exact ⟨congrArg Prod.snd he, hr⟩ | |
| · rintro ⟨he, hr⟩ | |
| refine ⟨?_, hr⟩ | |
| rw [he] | |
| theorem termination_factorization (S : FlaggedTensor X Y Z) (r : ReadableTensor S) | |
| (p : ∀ c, FiniteLaw (ColorSlice S c)) (a : ℝ) (ha : 0 ≤ a) (ha' : a ≤ 1) | |
| (h : ProgramLawsIndependent S r p) (k : Fin r.depth) | |
| (hk : r.program.pair k.val = .yz) : | |
| ConditionalMassFactorization | |
| (CompletionTerminationLaw.law S .B .C (p .B) (p .C) a ha ha') | |
| (labelRecordOf (terminationProgram S .B .C (by intro h; cases h) | |
| r.program r.context_eq r.view_eq).labels (1 + k.val)) | |
| ((terminationProgram S .B .C (by intro h; cases h) | |
| r.program r.context_eq r.view_eq).labels (1 + k.val)) | |
| (fun w => w.val.val.1) := by | |
| let μ := CompletionTerminationLaw.law S .B .C (p .B) (p .C) a ha ha' | |
| let q := colorMix S .B .C (p .B) (p .C) a ha ha' | |
| let prior := labelRecordOf r.program.labels k.val | |
| let label := r.program.labels k.val | |
| let xx : Leaf S → X := fun w => w.val.1 | |
| have hq : ConditionalMassFactorization q (fun w => (leafColor S w, prior w)) label xx := | |
| colorMix_factorization S .B .C (by intro h; cases h) (p .B) (p .C) a ha ha' | |
| prior label xx (h .B k hk) (h .C k hk) | |
| have hmass : (μ.map Subtype.val).mass = q.mass := by | |
| funext w | |
| exact (CompletionTerminationLaw.law_map_mass S .B .C (p .B) (p .C) | |
| a ha ha' id w).trans (q.map_mass_apply id Function.injective_id w) | |
| have hmapped : ConditionalMassFactorization (μ.map Subtype.val) | |
| (fun w => (leafColor S w, prior w)) label xx := | |
| (mass_factorization_congr_mass_iff (μ.map Subtype.val) q hmass _ _ _).mpr hq | |
| have hμ := (mass_factorization_map_iff μ Subtype.val | |
| (fun w => (leafColor S w, prior w)) label xx).mp hmapped | |
| apply mass_factorization_of_same_partitions μ | |
| (fun w => (leafColor S w.val, prior w.val)) | |
| (fun w => label w.val) (fun w => xx w.val) | |
| (labelRecordOf (terminationProgram S .B .C (by intro h; cases h) | |
| r.program r.context_eq r.view_eq).labels (1 + k.val)) | |
| ((terminationProgram S .B .C (by intro h; cases h) | |
| r.program r.context_eq r.view_eq).labels (1 + k.val)) | |
| (fun w => w.val.val.1) ?_ ?_ ?_ hμ | |
| · intro u v | |
| simp only [Prod.mk.injEq] | |
| exact (termination_record_eq_iff S .B .C (by intro h; cases h) | |
| r.program r.context_eq r.view_eq k.val u v).symm | |
| · intro u v | |
| simp only [termination_label_succ, Sum.inr.injEq] | |
| rfl | |
| · intro u v | |
| rfl | |
| theorem termination_independent (S : FlaggedTensor X Y Z) (r : ReadableTensor S) | |
| (p : ∀ c, FiniteLaw (ColorSlice S c)) (a : ℝ) (ha : 0 ≤ a) (ha' : a ≤ 1) | |
| (h : ProgramLawsIndependent S r p) | |
| (n : Fin (1 + r.depth)) | |
| (hn : (terminationProgram S .B .C (by intro h; cases h) | |
| r.program r.context_eq r.view_eq).pair n.val = .yz) : | |
| ConditionalIndependent | |
| (CompletionTerminationLaw.law S .B .C (p .B) (p .C) a ha ha') | |
| (labelRecordOf (terminationProgram S .B .C (by intro h; cases h) | |
| r.program r.context_eq r.view_eq).labels n.val) | |
| ((terminationProgram S .B .C (by intro h; cases h) | |
| r.program r.context_eq r.view_eq).labels n.val) | |
| (fun w => w.val.val.1) := by | |
| rcases n with ⟨n, hnd⟩ | |
| cases n with | |
| | zero => | |
| simp [terminationProgram, Program.append, Program.recode, | |
| terminationRoot, Program.single, ownerPair] at hn | |
| | succ k => | |
| have hkd : k < r.depth := Nat.lt_of_succ_lt_succ | |
| (by simpa only [Nat.one_add] using hnd) | |
| simp only [Fin.val_mk] at hn ⊢ | |
| simp only [Nat.add_comm k 1] at hn | |
| have hk : r.program.pair k = .yz := | |
| (termination_pair_succ S .B .C (by intro h; cases h) | |
| r.program r.context_eq r.view_eq k).symm.trans hn | |
| apply conditionalIndependent_of_mass_factorization | |
| let labels := (terminationProgram S .B .C (by intro h; cases h) | |
| r.program r.context_eq r.view_eq).labels | |
| have hf := termination_factorization S r p a ha ha' h ⟨k, hkd⟩ hk | |
| exact Eq.mp | |
| (congrArg | |
| (fun n : ℕ => ConditionalMassFactorization | |
| (CompletionTerminationLaw.law S .B .C (p .B) (p .C) a ha ha') | |
| (labelRecordOf labels n) (labels n) (fun w => w.val.val.1)) | |
| (Nat.one_add k)) | |
| hf | |
| end MatrixMultiplication.DualProgramIndependence | |
| end | |
| end OAI | |