| import OAI.LinearAlgebra.MatrixMultiplication.Completion.Laws |
|
|
| namespace OAI |
|
|
| /-! Readable tensor completion and its finite arithmetic realization. -/ |
|
|
| noncomputable section |
|
|
| namespace MatrixMultiplication.CompletionLaws |
|
|
| open MatrixMultiplication.Foundation |
| open scoped BigOperators |
| attribute [local instance] Classical.propDecidable Classical.decEq |
|
|
| variable {A X : Type*} [Fintype A] [Fintype X] |
|
|
| theorem sum_subtype_indicator (P : A → Prop) (f : A → ℝ) : |
| (∑ a : {a // P a}, f a.val) = ∑ a, if P a then f a else 0 := by |
| rw [← Finset.sum_filter] |
| exact (Finset.sum_subtype _ (by simp) f).symm |
|
|
| def eventMass (p : FiniteLaw A) (P : A → Prop) : ℝ := |
| ∑ a : {a // P a}, p.mass a.val |
|
|
| theorem eventMass_nonneg (p : FiniteLaw A) (P : A → Prop) : 0 ≤ eventMass p P := |
| Finset.sum_nonneg fun a _ => p.nonneg a.val |
|
|
| def condition (p : FiniteLaw A) (P : A → Prop) (h : 0 < eventMass p P) : |
| FiniteLaw {a // P a} where |
| mass a := p.mass a.val / eventMass p P |
| nonneg a := div_nonneg (p.nonneg a.val) h.le |
| total := by rw [← Finset.sum_div]; exact div_self h.ne' |
|
|
| theorem condition_mass (p : FiniteLaw A) (P : A → Prop) |
| (h : 0 < eventMass p P) (a : {a // P a}) : |
| (condition p P h).mass a = p.mass a.val / eventMass p P := rfl |
|
|
| theorem condition_coordinate_mass (p : FiniteLaw A) (f : A → X) (Q : X → Prop) |
| (h : 0 < eventMass p (fun a => Q (f a))) (x : X) : |
| ((condition p (fun a => Q (f a)) h).map (fun a => f a.val)).mass x = |
| if Q x then (p.map f).mass x / eventMass p (fun a => Q (f a)) else 0 := by |
| rw [FiniteLaw.map_mass] |
| simp only [condition_mass] |
| have hsum : |
| (∑ a : {a // Q (f a)}, if f a.val = x then |
| p.mass a.val / eventMass p (fun a => Q (f a)) else 0) = |
| ∑ a, if Q (f a) then |
| (if f a = x then p.mass a / eventMass p (fun a => Q (f a)) else 0) else 0 := |
| sum_subtype_indicator (fun a => Q (f a)) |
| (fun a => if f a = x then p.mass a / eventMass p (fun a => Q (f a)) else 0) |
| rw [hsum] |
| by_cases hx : Q x |
| · rw [ite_eq_left hx, FiniteLaw.map_mass, Finset.sum_div] |
| apply Finset.sum_congr rfl |
| intro a _ |
| by_cases ha : f a = x |
| · simp [ha, hx] |
| · simp [ha] |
| · rw [ite_eq_right hx] |
| apply Finset.sum_eq_zero |
| intro a _ |
| by_cases ha : f a = x |
| · simp [ha, hx] |
| · simp [ha] |
|
|
| theorem eventMass_coordinate (p : FiniteLaw A) (f : A → X) (Q : X → Prop) : |
| eventMass p (fun a => Q (f a)) = eventMass (p.map f) Q := by |
| rw [eventMass, eventMass, sum_subtype_indicator, sum_subtype_indicator] |
| simp only [FiniteLaw.map_mass] |
| calc |
| (∑ a, if Q (f a) then p.mass a else 0) = |
| ∑ a, ∑ x, if Q x then (if f a = x then p.mass a else 0) else 0 := by |
| apply Finset.sum_congr rfl |
| intro a _ |
| rw [Finset.sum_eq_single (f a)] |
| · simp |
| · intro x _ hne |
| simp [Ne.symm hne] |
| · simp |
| _ = ∑ x, ∑ a, if Q x then (if f a = x then p.mass a else 0) else 0 := |
| Finset.sum_comm |
| _ = ∑ x, if Q x then ∑ a, if f a = x then p.mass a else 0 else 0 := by |
| apply Finset.sum_congr rfl |
| intro x _ |
| split_ifs <;> simp |
|
|
| def transport {B : Type*} [Fintype B] (e : A ≃ B) (p : FiniteLaw A) : FiniteLaw B := |
| p.map e |
|
|
| theorem transport_mass {B : Type*} [Fintype B] (e : A ≃ B) (p : FiniteLaw A) (a : A) : |
| (transport e p).mass (e a) = p.mass a := p.map_mass_apply e e.injective a |
|
|
| theorem transport_entropy {B : Type*} [Fintype B] (e : A ≃ B) (p : FiniteLaw A) : |
| finiteEntropy (transport e p).mass = finiteEntropy p.mass := |
| p.map_entropy_of_injective e e.injective |
|
|
| end MatrixMultiplication.CompletionLaws |
|
|
| end |
|
|
| end OAI |
|
|
