| import OAI.LinearAlgebra.MatrixMultiplication.Completion.ColorLaws |
| import OAI.LinearAlgebra.MatrixMultiplication.Tensor.UniformCoordinate |
| import OAI.LinearAlgebra.MatrixMultiplication.Duality.EntropyHelpers |
|
|
| namespace OAI |
|
|
| /-! Dual matrix multiplication exponents and finite rectangular constructions. -/ |
|
|
| noncomputable section |
|
|
| universe uCoord |
|
|
| namespace MatrixMultiplication.DualUniformMixtures |
|
|
| open MatrixMultiplication.Foundation RecursiveCompletion CompletionLabels CompletionColorLaws |
| open CompletionLaws DualEntropyHelpers |
| open scoped BigOperators |
| attribute [local instance 10000] Classical.propDecidable Classical.decEq |
| attribute [local instance 11000] instDecidableEqFin |
|
|
| variable {X Y Z : Type uCoord} {U A : Type*} [Fintype X] [Fintype Y] [Fintype Z] |
| [Fintype U] [Fintype A] |
|
|
| theorem uniform_coordinate_card_pos (p : FiniteLaw A) (f : A → U) |
| (P : U → Prop) (h : UniformCoordinate p f P) : |
| 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 |
| have ht := (p.map f).total |
| have hmass : ∀ x, (p.map f).mass x = |
| if P x then (Fintype.card {x // P x} : ℝ)⁻¹ else 0 := h |
| simp_rw [hmass] at ht |
| simp [hz] at ht |
|
|
| theorem colorMix_map_comp_mass (S : FlaggedTensor X Y Z) (center output : Color) |
| (pc : FiniteLaw (ColorSlice S center)) (po : FiniteLaw (ColorSlice S output)) |
| (α : ℝ) (hα : 0 ≤ α) (hα' : α ≤ 1) (f : Leaf S → U) (x : U) : |
| ((colorMix S center output pc po α hα hα').map f).mass x = |
| α * (pc.map (fun a => f a.val)).mass x + |
| (1 - α) * (po.map (fun a => f a.val)).mass x := by |
| rw [colorMix_map_mass, map_comp_mass, map_comp_mass] |
|
|
| theorem colorMix_map_of_common (S : FlaggedTensor X Y Z) (center output : Color) |
| (pc : FiniteLaw (ColorSlice S center)) (po : FiniteLaw (ColorSlice S output)) |
| (α : ℝ) (hα : 0 ≤ α) (hα' : α ≤ 1) (f : Leaf S → U) |
| (hcommon : ∀ x, (pc.map (fun a => f a.val)).mass x = |
| (po.map (fun a => f a.val)).mass x) (x : U) : |
| ((colorMix S center output pc po α hα hα').map f).mass x = |
| (pc.map (fun a => f a.val)).mass x := by |
| rw [colorMix_map_comp_mass, ← hcommon x] |
| ring |
|
|
| theorem colorMix_uniform_common (S : FlaggedTensor X Y Z) (center output : Color) |
| (pc : FiniteLaw (ColorSlice S center)) (po : FiniteLaw (ColorSlice S output)) |
| (α : ℝ) (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 (colorMix S center output pc po α hα hα') |
| (fun a => a.val.1) P := by |
| intro x |
| rw [colorMix_map_of_common S center output pc po α hα hα' (fun a => a.val.1) |
| (fun x => (hc x).trans (ho x).symm)] |
| exact hc x |
|
|
| theorem colorMix_uniform_complement (S : FlaggedTensor X Y Z) (center output : Color) |
| (pc : FiniteLaw (ColorSlice S center)) (po : FiniteLaw (ColorSlice S output)) |
| (α : ℝ) (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) (fun x => ¬ P x)) |
| (hweight : α = (Fintype.card {x // P x} : ℝ) / Fintype.card X) : |
| UniformCoordinate (colorMix S center output pc po α hα hα') |
| (fun a => a.val.1) (fun _ => True) := by |
| have hp : (Fintype.card {x // P x} : ℝ) ≠ 0 := |
| (Nat.cast_pos.mpr (uniform_coordinate_card_pos pc _ P hc)).ne' |
| have hn : (Fintype.card {x // ¬ P x} : ℝ) ≠ 0 := |
| (Nat.cast_pos.mpr (uniform_coordinate_card_pos po _ _ ho)).ne' |
| have hsumNat : Fintype.card {x // P x} + Fintype.card {x // ¬ P x} = |
| Fintype.card X := by |
| rw [Fintype.card_subtype_compl] |
| exact Nat.add_sub_of_le (Fintype.card_subtype_le P) |
| have hsum : (Fintype.card {x // P x} : ℝ) + Fintype.card {x // ¬ P x} = |
| Fintype.card X := by exact_mod_cast hsumNat |
| have hX : (Fintype.card X : ℝ) ≠ 0 := by |
| have : 0 < Fintype.card X := lt_of_lt_of_le |
| (uniform_coordinate_card_pos pc _ P hc) (Fintype.card_subtype_le P) |
| exact (Nat.cast_pos.mpr this).ne' |
| have hrest : 1 - α = |
| (Fintype.card {x // ¬ P x} : ℝ) / Fintype.card X := by |
| rw [hweight, one_sub_div hX, show (Fintype.card X : ℝ) - |
| Fintype.card {x // P x} = Fintype.card {x // ¬ P x} by linarith] |
| intro x |
| rw [colorMix_map_comp_mass, hc x, ho x, hrest, hweight] |
| simp only [ite_true, Fintype.card_subtype_true] |
| by_cases hx : P x <;> simp only [hx, not_true_eq_false, not_false_eq_true, |
| ite_true, ite_false, mul_zero, zero_add, add_zero] |
| · rw [div_eq_mul_inv, mul_right_comm, mul_inv_cancel₀ hp, one_mul] |
| · rw [div_eq_mul_inv, mul_right_comm, mul_inv_cancel₀ hn, one_mul] |
|
|
| theorem colorMix_uniform_complement_reverse |
| (S : FlaggedTensor X Y Z) (center output : Color) |
| (pc : FiniteLaw (ColorSlice S center)) (po : FiniteLaw (ColorSlice S output)) |
| (rho : ℝ) (hα : 0 ≤ 1 - rho) (hα' : 1 - rho ≤ 1) (P : X → Prop) |
| (hc : UniformCoordinate pc (fun a => a.val.val.1) (fun x => ¬ P x)) |
| (ho : UniformCoordinate po (fun a => a.val.val.1) P) |
| (hweight : rho = (Fintype.card {x // P x} : ℝ) / Fintype.card X) : |
| UniformCoordinate (colorMix S center output pc po (1 - rho) hα hα') |
| (fun a => a.val.1) (fun _ => True) := by |
| apply colorMix_uniform_complement S center output pc po (1 - rho) hα hα' |
| (fun x => ¬ P x) hc |
| · simpa only [not_not] using ho |
| · have hsumNat : Fintype.card {x // P x} + Fintype.card {x // ¬ P x} = |
| Fintype.card X := by |
| rw [Fintype.card_subtype_compl] |
| exact Nat.add_sub_of_le (Fintype.card_subtype_le P) |
| have hsum : (Fintype.card {x // P x} : ℝ) + Fintype.card {x // ¬ P x} = |
| Fintype.card X := by exact_mod_cast hsumNat |
| have hX : (Fintype.card X : ℝ) ≠ 0 := by |
| have : 0 < Fintype.card X := lt_of_lt_of_le |
| (uniform_coordinate_card_pos po _ P ho) (Fintype.card_subtype_le P) |
| exact (Nat.cast_pos.mpr this).ne' |
| rw [hweight, one_sub_div hX, show (Fintype.card X : ℝ) - |
| Fintype.card {x // P x} = Fintype.card {x // ¬ P x} by linarith] |
|
|
| theorem colorSlice_color_mass (S : FlaggedTensor X Y Z) (c : Color) |
| (p : FiniteLaw (ColorSlice S c)) (b : Color) : |
| ((p.map Subtype.val).map (leafColor S)).mass b = if c = b then 1 else 0 := by |
| rw [map_comp_mass, FiniteLaw.map_mass] |
| have hc : ∀ a : ColorSlice S c, leafColor S a.val = c := fun a => a.property |
| simp_rw [hc] |
| by_cases h : c = b <;> simp [h, p.total] |
|
|
| theorem colorSlice_pair_mass (S : FlaggedTensor X Y Z) (c : Color) |
| (p : FiniteLaw (ColorSlice S c)) (f : Leaf S → U) (x : U) (b : Color) : |
| ((p.map Subtype.val).map (fun a => (f a, leafColor S a))).mass (x, b) = |
| if c = b then (p.map (fun a => f a.val)).mass x else 0 := by |
| rw [map_comp_mass, FiniteLaw.map_mass] |
| have hc : ∀ a : ColorSlice S c, leafColor S a.val = c := fun a => a.property |
| simp_rw [hc] |
| by_cases h : c = b <;> simp [h, FiniteLaw.map_mass] |
|
|
| theorem colorMix_independent_common (S : FlaggedTensor X Y Z) (center output : Color) |
| (pc : FiniteLaw (ColorSlice S center)) (po : FiniteLaw (ColorSlice S output)) |
| (α : ℝ) (hα : 0 ≤ α) (hα' : α ≤ 1) (f : Leaf S → U) |
| (hcommon : ∀ x, (pc.map (fun a => f a.val)).mass x = |
| (po.map (fun a => f a.val)).mass x) (x : U) (b : Color) : |
| ((colorMix S center output pc po α hα hα').map |
| (fun a => (f a, leafColor S a))).mass (x, b) = |
| ((colorMix S center output pc po α hα hα').map f).mass x * |
| ((colorMix S center output pc po α hα hα').map (leafColor S)).mass b := by |
| rw [colorMix_map_of_common S center output pc po α hα hα' f hcommon x] |
| rw [colorMix_map_mass, colorMix_map_mass, |
| colorSlice_pair_mass, colorSlice_pair_mass, |
| colorSlice_color_mass, colorSlice_color_mass, ← hcommon x] |
| by_cases hc : center = b <;> by_cases ho : output = b <;> simp [hc, ho] <;> ring |
|
|
| theorem colorMix_independent_uniform (S : FlaggedTensor X Y Z) (center output : Color) |
| (pc : FiniteLaw (ColorSlice S center)) (po : FiniteLaw (ColorSlice S output)) |
| (α : ℝ) (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) (x : X) (b : Color) : |
| ((colorMix S center output pc po α hα hα').map |
| (fun a => (a.val.1, leafColor S a))).mass (x, b) = |
| ((colorMix S center output pc po α hα hα').map (fun a => a.val.1)).mass x * |
| ((colorMix S center output pc po α hα hα').map (leafColor S)).mass b := |
| colorMix_independent_common S center output pc po α hα hα' (fun a => a.val.1) |
| (fun x => (hc x).trans (ho x).symm) x b |
|
|
| theorem colorMix_independent_same (S : FlaggedTensor X Y Z) (c : Color) |
| (pc po : FiniteLaw (ColorSlice S c)) |
| (α : ℝ) (hα : 0 ≤ α) (hα' : α ≤ 1) (f : Leaf S → U) (x : U) (b : Color) : |
| ((colorMix S c c pc po α hα hα').map |
| (fun a => (f a, leafColor S a))).mass (x, b) = |
| ((colorMix S c c pc po α hα hα').map f).mass x * |
| ((colorMix S c c pc po α hα hα').map (leafColor S)).mass b := by |
| rw [colorMix_map_comp_mass S c c pc po α hα hα' f x] |
| rw [colorMix_map_mass, colorMix_map_mass, |
| colorSlice_pair_mass, colorSlice_pair_mass, |
| colorSlice_color_mass, colorSlice_color_mass] |
| by_cases hc : c = b <;> simp [hc] |
|
|
| end MatrixMultiplication.DualUniformMixtures |
|
|
| end |
|
|
| end OAI |
|
|
