openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /Duality /UniformConditioning.lean
| import OAI.LinearAlgebra.MatrixMultiplication.Completion.ColorLaws | |
| import OAI.LinearAlgebra.MatrixMultiplication.Entropy.IndependentConditioning | |
| import OAI.LinearAlgebra.MatrixMultiplication.Duality.EntropyHelpers | |
| namespace OAI | |
| /-! Dual matrix multiplication exponents and finite rectangular constructions. -/ | |
| noncomputable section | |
| universe uCoord | |
| namespace MatrixMultiplication.DualUniformConditioning | |
| open MatrixMultiplication.Foundation RecursiveCompletion CompletionLabels CompletionColorLaws | |
| open CompletionLaws CompletionProductLaws DualEntropyHelpers | |
| open scoped BigOperators | |
| attribute [local instance 10000] Classical.propDecidable Classical.decEq | |
| attribute [local instance 11000] instDecidableEqFin | |
| variable {A : Type*} {X Y Z : Type uCoord} [Fintype A] [Fintype X] [Fintype Y] [Fintype Z] | |
| theorem eventMass_congr_support (p : FiniteLaw A) (P Q : A → Prop) | |
| (h : ∀ a, p.mass a ≠ 0 → (P a ↔ Q a)) : eventMass p P = eventMass p Q := by | |
| rw [eventMass, eventMass, sum_subtype_indicator, sum_subtype_indicator] | |
| apply Finset.sum_congr rfl | |
| intro a _ | |
| by_cases ha : p.mass a = 0 | |
| · simp [ha] | |
| · rw [h a ha] | |
| theorem condition_map_mass_congr_support (p : FiniteLaw A) (P Q : A → Prop) | |
| (h : ∀ a, p.mass a ≠ 0 → (P a ↔ Q a)) | |
| (hP : 0 < eventMass p P) (hQ : 0 < eventMass p Q) (f : A → X) (x : X) : | |
| ((condition p P hP).map (fun a => f a.val)).mass x = | |
| ((condition p Q hQ).map (fun a => f a.val)).mass x := by | |
| rw [condition_map_mass, condition_map_mass, eventMass_congr_support p P Q h] | |
| congr 1 | |
| rw [sum_subtype_indicator P (fun a => if f a = x then p.mass a else 0), | |
| sum_subtype_indicator Q (fun a => if f a = x then p.mass a else 0)] | |
| apply Finset.sum_congr rfl | |
| intro a _ | |
| by_cases ha : p.mass a = 0 | |
| · simp [ha] | |
| · rw [h a ha] | |
| theorem uniform_coordinate_pred_congr (p : FiniteLaw A) (f : A → X) | |
| (P Q : X → Prop) (h : ∀ x, P x ↔ Q x) (hp : UniformCoordinate p f P) : | |
| UniformCoordinate p f Q := by | |
| have he : P = Q := funext (fun x => propext (h x)) | |
| simpa only [he] using hp | |
| theorem uniform_coordinate_condition_positive (p : FiniteLaw A) (f : A → X) | |
| (P Q : X → Prop) (h : UniformCoordinate p f P) | |
| (hevent : 0 < eventMass p (fun a => Q (f a))) : | |
| UniformCoordinate (condition p (fun a => Q (f a)) hevent) | |
| (fun a => f a.val) (fun x => P x ∧ Q x) := by | |
| have hratio := hevent | |
| rw [uniform_coordinate_eventMass p f P Q h] at hratio | |
| have hPQ : 0 < Fintype.card {x // P x ∧ Q x} := by | |
| by_contra hn | |
| have hz : Fintype.card {x // P x ∧ Q x} = 0 := Nat.eq_zero_of_not_pos hn | |
| simp [hz] at hratio | |
| have hP : 0 < Fintype.card {x // P x} := by | |
| by_contra hn | |
| have hz : Fintype.card {x // P x} = 0 := Nat.eq_zero_of_not_pos hn | |
| simp [hz] at hratio | |
| exact (uniform_coordinate_condition p f P Q h hP hPQ).choose_spec | |
| theorem uniform_coordinate_condition_supported (p : FiniteLaw A) (f : A → X) | |
| (P Q : X → Prop) (E : A → Prop) (h : UniformCoordinate p f P) | |
| (heq : ∀ a, p.mass a ≠ 0 → (E a ↔ Q (f a))) | |
| (hevent : 0 < eventMass p E) : | |
| UniformCoordinate (condition p E hevent) (fun a => f a.val) | |
| (fun x => P x ∧ Q x) := by | |
| have hQ : 0 < eventMass p (fun a => Q (f a)) := by | |
| rwa [← eventMass_congr_support p E (fun a => Q (f a)) heq] | |
| have hu := uniform_coordinate_condition_positive p f P Q h hQ | |
| intro x | |
| rw [condition_map_mass_congr_support p E (fun a => Q (f a)) heq hevent hQ] | |
| exact hu x | |
| theorem conditionalCompletionLaw_X_mass | |
| (S : FlaggedTensor X Y Z) (center output : Color) | |
| (pc : FiniteLaw (ColorSlice S center)) (po : FiniteLaw (ColorSlice S output)) | |
| (m : ℕ) (hm : 0 < m) (α : ℝ) (hα : 0 ≤ α) (hα' : α < 1) | |
| (x : Fin m → X) : | |
| ((conditionalCompletionLaw S center output pc po m hm α hα hα').map | |
| (fun a => a.val.val.1)).mass x = | |
| ((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α')).map | |
| (fun w i => (w.val i).val.1)).mass x := by | |
| unfold conditionalCompletionLaw transport | |
| rw [map_comp_mass] | |
| rfl | |
| theorem iidColorLaw_allowed | |
| (S : FlaggedTensor X Y Z) (center output : Color) | |
| (pc : FiniteLaw (ColorSlice S center)) (po : FiniteLaw (ColorSlice S output)) | |
| (m : ℕ) (α : ℝ) (hα : 0 ≤ α) (hα' : α ≤ 1) | |
| (w : Fin m → Leaf S) | |
| (hw : (iidColorLaw S center output pc po m α hα hα').mass w ≠ 0) : | |
| ∀ i, leafColor S (w i) = center ∨ leafColor S (w i) = output := by | |
| intro i | |
| by_contra h | |
| have hc : leafColor S (w i) ≠ center := fun hc => h (Or.inl hc) | |
| have ho : leafColor S (w i) ≠ output := fun ho => h (Or.inr ho) | |
| have hz := colorMix_mass_zero S center output pc po α hα hα' (w i) hc ho | |
| rw [iidColorLaw, independentProduct_mass] at hw | |
| exact ((Finset.prod_ne_zero_iff.mp hw) i (Finset.mem_univ i)) hz | |
| omit [Fintype X] [Fintype Y] [Fintype Z] in | |
| theorem completionEvent_outputB (S : FlaggedTensor X Y Z) (center : Color) | |
| (m : ℕ) (w : Fin m → Leaf S) | |
| (ha : ∀ i, leafColor S (w i) = center ∨ leafColor S (w i) = .B) : | |
| completionEvent S center .B m w ↔ | |
| (complete S center m).flagB (fun i => (w i).val.1) := by | |
| have heq : (fun i => leafColor S (w i) = .B) = | |
| (fun i => S.flagB (w i).val.1) := by | |
| funext i | |
| exact propext (leafColor_eq_iff S (w i) .B) | |
| simp only [completionEvent, ha, forall_true_iff, and_true, heq] | |
| rfl | |
| omit [Fintype X] [Fintype Y] [Fintype Z] in | |
| theorem completionEvent_centerB (S : FlaggedTensor X Y Z) (output : Color) | |
| (ho : output ≠ .B) (m : ℕ) (w : Fin m → Leaf S) | |
| (ha : ∀ i, leafColor S (w i) = .B ∨ leafColor S (w i) = output) : | |
| completionEvent S .B output m w ↔ | |
| ¬ (complete S .B m).flagB (fun i => (w i).val.1) := by | |
| change (raisedFlag .B output (fun i => leafColor S (w i) = output) ∧ _) ↔ | |
| ¬ raisedFlag .B .B (fun i => S.flagB (w i).val.1) | |
| simp only [raisedFlag, ite_eq_right ho.symm, ite_true, ha, forall_true_iff, and_true] | |
| constructor | |
| · rintro ⟨i, hi⟩ hall | |
| have hb := (leafColor_eq_iff S (w i) .B).mpr (hall i) | |
| exact ho (hi.symm.trans hb) | |
| · intro hn | |
| obtain ⟨i, hi⟩ := not_forall.mp hn | |
| refine ⟨i, (ha i).resolve_left ?_⟩ | |
| exact fun hb => hi ((leafColor_eq_iff S (w i) .B).mp hb) | |
| end MatrixMultiplication.DualUniformConditioning | |
| end | |
| end OAI | |