| import OAI.LinearAlgebra.MatrixMultiplication.Duality.CompletionLaws |
| import OAI.LinearAlgebra.MatrixMultiplication.Duality.UniformUpdates |
| import OAI.LinearAlgebra.MatrixMultiplication.Duality.UniformMixtures |
| import OAI.LinearAlgebra.MatrixMultiplication.Completion.Partitions |
|
|
| namespace OAI |
|
|
| /-! Dual matrix multiplication exponents and finite rectangular constructions. -/ |
|
|
| noncomputable section |
| universe uCoord |
| namespace MatrixMultiplication.DualUniform |
|
|
| open MatrixMultiplication.Foundation RecursiveCompletion CompletionLabels CompletionColorLaws |
| open CompletionLaws DualCompletionLaws DualUniformConditioning DualUniformUpdates |
| open DualUniformMixtures CompletionPartitions |
| open scoped BigOperators |
| attribute [local instance 10000] Classical.propDecidable Classical.decEq |
| attribute [local instance 11000] instDecidableEqFin |
|
|
| variable {X Y Z : Type uCoord} [Fintype X] [Fintype Y] [Fintype Z] |
|
|
| structure UniformLaws (S : FlaggedTensor X Y Z) (p : Laws S) : Prop where |
| B : UniformCoordinate (p .B) (fun a => a.val.val.1) S.flagB |
| A : UniformCoordinate (p .A) (fun a => a.val.val.1) (fun x => ¬ S.flagB x) |
| C : UniformCoordinate (p .C) (fun a => a.val.val.1) (fun x => ¬ S.flagB x) |
|
|
| theorem UniformLaws.color (S : FlaggedTensor X Y Z) (p : Laws S) |
| (h : UniformLaws S p) (c : Color) : |
| UniformCoordinate (p c) (fun a => a.val.val.1) |
| (fun x => if c = .B then S.flagB x else ¬ S.flagB x) := by |
| cases c |
| · simpa using h.B |
| · simpa using h.A |
| · simpa using h.C |
|
|
| theorem UniformLaws.entropy_B (S : FlaggedTensor X Y Z) (p : Laws S) |
| (h : UniformLaws S p) : |
| finiteEntropy ((p .B).map (fun a => a.val.val.1)).mass = Real.log (activeCount S) := |
| uniform_coordinate_entropy (p .B) _ _ h.B |
|
|
| theorem UniformLaws.entropy_A (S : FlaggedTensor X Y Z) (p : Laws S) |
| (h : UniformLaws S p) : |
| finiteEntropy ((p .A).map (fun a => a.val.val.1)).mass = Real.log (inactiveCount S) := |
| uniform_coordinate_entropy (p .A) _ _ h.A |
|
|
| theorem UniformLaws.entropy_C (S : FlaggedTensor X Y Z) (p : Laws S) |
| (h : UniformLaws S p) : |
| finiteEntropy ((p .C).map (fun a => a.val.val.1)).mass = Real.log (inactiveCount S) := |
| uniform_coordinate_entropy (p .C) _ _ h.C |
|
|
| theorem conditionalCompletionLaw_uniform_common |
| (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) |
| (P : X → Prop) |
| (hc : UniformCoordinate pc (fun a => a.val.val.1) P) |
| (ho : UniformCoordinate po (fun a => a.val.val.1) P) : |
| UniformCoordinate |
| (conditionalCompletionLaw S center output pc po m hm α hα hα') |
| (fun a => a.val.val.1) (fun x => ∀ i, P (x i)) := |
| conditionalCompletionLaw_uniform_independent S center output pc po m hm α hα hα' P |
| (colorMix_uniform_common S center output pc po α hα hα'.le P hc ho) |
| (colorMix_independent_uniform S center output pc po α hα hα'.le P hc ho) |
| |
| private theorem inactive_uniform_update |
| (S : FlaggedTensor X Y Z) (center output : Color) (hcenter : center ≠ .B) |
| (pc : FiniteLaw (ColorSlice S center)) (po : FiniteLaw (ColorSlice S output)) |
| (m : ℕ) (hm : 0 < m) (α : ℝ) (hα : 0 ≤ α) (hα' : α < 1) |
| (hc : UniformCoordinate pc (fun a => a.val.val.1) (fun x => ¬ S.flagB x)) |
| (ho : UniformCoordinate po (fun a => a.val.val.1) (fun x => ¬ S.flagB x)) : |
| UniformCoordinate |
| (conditionalCompletionLaw S center output pc po m hm α hα hα') |
| (fun a => a.val.val.1) (fun x => ¬ (complete S center m).flagB x) := by |
| apply uniform_coordinate_pred_congr _ _ (fun x => ∀ i, ¬ S.flagB (x i)) |
| · intro x |
| change (∀ i, ¬ S.flagB (x i)) ↔ ¬ raisedFlag center .B (fun i => S.flagB (x i)) |
| simp [raisedFlag, hcenter] |
| · exact conditionalCompletionLaw_uniform_common S center output pc po m hm α hα hα' |
| (fun x => ¬ S.flagB x) hc ho |
|
|
| theorem minusLaws_uniform (S : FlaggedTensor X Y Z) (p : Laws S) |
| (m : ℕ) (hm : 0 < m) (rho : ℝ) (hrho0 : 0 < rho) (hrho1 : rho < 1) |
| (h : UniformLaws S p) (hrho : rho = activeFraction S) : |
| UniformLaws (complete S .B m) (minusLaws S p m hm rho hrho0 hrho1) := by |
| constructor |
| · exact conditionalCompletionLaw_uniform_common S .B .B (p .B) (p .B) m hm 0 |
| (by norm_num) (by norm_num) S.flagB h.B h.B |
| · have hu := conditionalCompletionLaw_uniform_incident S .B .A (Or.inl rfl) |
| (p .B) (p .A) m hm rho hrho0.le hrho1 |
| (colorMix_uniform_complement S .B .A (p .B) (p .A) rho hrho0.le hrho1.le |
| S.flagB h.B h.A hrho) |
| simpa only [minusLaws, reduceCtorEq, ite_false] using hu |
| · have hu := conditionalCompletionLaw_uniform_incident S .B .C (Or.inl rfl) |
| (p .B) (p .C) m hm rho hrho0.le hrho1 |
| (colorMix_uniform_complement S .B .C (p .B) (p .C) rho hrho0.le hrho1.le |
| S.flagB h.B h.C hrho) |
| simpa only [minusLaws, reduceCtorEq, ite_false] using hu |
|
|
| theorem plusALaws_uniform (S : FlaggedTensor X Y Z) (p : Laws S) |
| (m : ℕ) (hm : 0 < m) (rho hA hC : ℝ) (hrho0 : 0 < rho) (hrho1 : rho < 1) |
| (h : UniformLaws S p) (hrho : rho = activeFraction S) : |
| UniformLaws (complete S .A m) (plusALaws S p m hm rho hA hC hrho0 hrho1) := by |
| constructor |
| · have hu := conditionalCompletionLaw_uniform_incident S .A .B (Or.inr rfl) |
| (p .A) (p .B) m hm (1-rho) (sub_nonneg.mpr hrho1.le) (by linarith) |
| (colorMix_uniform_complement_reverse S .A .B (p .A) (p .B) rho |
| (sub_nonneg.mpr hrho1.le) (by linarith) S.flagB h.A h.B hrho) |
| simpa only [plusALaws, ite_eq_left rfl, ite_true] using hu |
| · exact inactive_uniform_update S .A .A (by intro h; cases h) (p .A) (p .A) m hm 0 |
| (by norm_num) (by norm_num) h.A h.A |
| · exact inactive_uniform_update S .A .C (by intro h; cases h) (p .A) (p .C) m hm |
| (gibbsWeight hA hC) (gibbsWeight_nonneg hA hC) (gibbsWeight_lt_one hA hC) h.A h.C |
|
|
| theorem plusCLaws_uniform (S : FlaggedTensor X Y Z) (p : Laws S) |
| (m : ℕ) (hm : 0 < m) (rho hA hC : ℝ) (hrho0 : 0 < rho) (hrho1 : rho < 1) |
| (h : UniformLaws S p) (hrho : rho = activeFraction S) : |
| UniformLaws (complete S .C m) (plusCLaws S p m hm rho hA hC hrho0 hrho1) := by |
| constructor |
| · have hu := conditionalCompletionLaw_uniform_incident S .C .B (Or.inr rfl) |
| (p .C) (p .B) m hm (1-rho) (sub_nonneg.mpr hrho1.le) (by linarith) |
| (colorMix_uniform_complement_reverse S .C .B (p .C) (p .B) rho |
| (sub_nonneg.mpr hrho1.le) (by linarith) S.flagB h.C h.B hrho) |
| simpa only [plusCLaws, ite_eq_left rfl, ite_true] using hu |
| · exact inactive_uniform_update S .C .A (by intro h; cases h) (p .C) (p .A) m hm |
| (gibbsWeight hC hA) (gibbsWeight_nonneg hC hA) (gibbsWeight_lt_one hC hA) h.C h.A |
| · exact inactive_uniform_update S .C .C (by intro h; cases h) (p .C) (p .C) m hm 0 |
| (by norm_num) (by norm_num) h.C h.C |
|
|
| private theorem pure_map_mass {A U : Type*} [Fintype A] [Fintype U] |
| (a : A) (f : A → U) (x : U) : |
| ((FiniteLaw.pure a).map f).mass x = if f a = x then 1 else 0 := by |
| rw [FiniteLaw.map_mass, Finset.sum_eq_single a] |
| · simp [FiniteLaw.pure] |
| · intro b _ hb |
| simp [FiniteLaw.pure, hb] |
| · simp |
|
|
| theorem baseLaws_uniform : UniformLaws BaseTwo.flagged baseLaws := by |
| have hc : Fintype.card {x |
| exact @Fintype.card_subtype_eq (Fin 2) 1 |
| (inferInstanceAs (Fintype {x |
| constructor <;> intro x <;> rw [baseLaws, pure_map_mass] <;> |
| fin_cases x <;> |
| norm_num [baseLeaf, BaseTwo.flagged, BaseTwo.flagB, Fintype.card_subtype_compl] |
| all_goals rw [hc] |
|
|
| end MatrixMultiplication.DualUniform |
|
|
| end |
|
|
| end OAI |
|
|
