| import OAI.LinearAlgebra.MatrixMultiplication.FieldParameters.Weights | |
| namespace OAI | |
| /-! Fixed rational distributions and their entropy and capacity formulas. -/ | |
| namespace MatrixMultiplication.AllFieldParameters | |
| open scoped BigOperators | |
| theorem assigned_mem_or_zero {α : Type} [BEq α] (keys : List α) (data : List ℤ) (key : α) : | |
| assigned keys data key = 0 ∨ assigned keys data key ∈ data := by | |
| unfold assigned | |
| cases h : (keys.zip data).find? (fun e => e.1 == key) with | |
| | none => simp | |
| | some pair => | |
| right | |
| exact (List.of_mem_zip (List.mem_of_find?_eq_some h)).2 | |
| theorem assigned_argument_bound {α : Type} [BEq α] (keys : List α) (data : List ℤ) | |
| (hd : ∀ n ∈ data, |n| ≤ 160000) (key : α) : |assigned keys data key| ≤ 160000 := by | |
| rcases assigned_mem_or_zero keys data key with h | h | |
| · rw [h]; norm_num | |
| · exact hd _ h | |
| theorem splitWeight_positive (parents : List Shape) (data : List ℤ) | |
| (hd : ∀ n ∈ data, |n| ≤ 160000) (s u : Shape) : | |
| 0 < splitWeight parents data s u := by | |
| apply Finset.prod_pos | |
| intro i _ | |
| apply weight_positive_of_argument_bound | |
| exact assigned_argument_bound _ data hd _ | |
| theorem list_sum_map_nonnegative {α : Type} (xs : List α) (f : α → ℚ) | |
| (hf : ∀ x ∈ xs, 0 ≤ f x) : 0 ≤ (xs.map f).sum := by | |
| induction xs with | |
| | nil => simp | |
| | cons x xs ih => | |
| simp only [List.map_cons, List.sum_cons] | |
| exact add_nonneg (hf x (by simp)) (ih (fun y hy => hf y (by simp [hy]))) | |
| theorem list_sum_map_positive {α : Type} (xs : List α) (f : α → ℚ) | |
| (hne : xs ≠ []) (hf : ∀ x ∈ xs, 0 < f x) : 0 < (xs.map f).sum := by | |
| cases xs with | |
| | nil => contradiction | |
| | cons x xs => | |
| simp only [List.map_cons, List.sum_cons] | |
| exact add_pos_of_pos_of_nonneg (hf x (by simp)) | |
| (list_sum_map_nonnegative xs f (fun y hy => (hf y (by simp [hy])).le)) | |
| theorem list_sum_map_div {α : Type} (xs : List α) (f : α → ℚ) (d : ℚ) : | |
| (xs.map (fun x => f x / d)).sum = (xs.map f).sum / d := by | |
| induction xs with | |
| | nil => simp | |
| | cons x xs ih => simp [ih, add_div] | |
| theorem splitLaw_positive (parents : List Shape) (data : List ℤ) | |
| (hd : ∀ n ∈ data, |n| ≤ 160000) (s u : Shape) (hu : u ∈ below s) : | |
| 0 < splitLaw parents data s u := by | |
| rw [splitLaw, ite_eq_left hu] | |
| apply div_pos (splitWeight_positive parents data hd s u) | |
| apply list_sum_map_positive | |
| · intro he | |
| simp only [he, List.not_mem_nil] at hu | |
| · intro v _ | |
| exact splitWeight_positive parents data hd s v | |
| theorem splitLaw_normalized (parents : List Shape) (data : List ℤ) | |
| (hd : ∀ n ∈ data, |n| ≤ 160000) (s : Shape) (hne : below s ≠ []) : | |
| ((below s).map (splitLaw parents data s)).sum = 1 := by | |
| have he : (below s).map (splitLaw parents data s) = | |
| (below s).map (fun u => splitWeight parents data s u / | |
| ((below s).map (splitWeight parents data s)).sum) := by | |
| apply List.map_congr_left | |
| intro u hu | |
| simp only [splitLaw, hu, ite_true] | |
| rw [he, list_sum_map_div, div_self] | |
| exact ne_of_gt (list_sum_map_positive (below s) _ hne | |
| (fun u _ => splitWeight_positive parents data hd s u)) | |
| theorem stageA_table_arguments_bounded : ∀ n ∈ tableP, |n| ≤ 160000 := by decide +kernel | |
| theorem stageB_table_arguments_bounded : ∀ n ∈ tablep, |n| ≤ 160000 := by decide +kernel | |
| theorem zero_table_arguments_bounded : ∀ n ∈ tablez, |n| ≤ 160000 := by decide +kernel | |
| theorem stageA_support_nonempty : ∀ s ∈ positiveInitial, below s ≠ [] := by decide +kernel | |
| theorem stageB_support_nonempty : ∀ s ∈ positiveSecond, below s ≠ [] := by decide +kernel | |
| theorem stageA_support_complement : ∀ s ∈ positiveInitial, ∀ u ∈ below s, | |
| complement s u ∈ below s ∧ ∀ i, u i ≤ s i := by decide +kernel | |
| theorem stageB_support_complement : ∀ s ∈ positiveSecond, ∀ u ∈ below s, | |
| complement s u ∈ below s ∧ ∀ i, u i ≤ s i := by decide +kernel | |
| theorem stageALaw_positive (s u : Shape) (hu : u ∈ below s) : 0 < stageALaw s u := | |
| splitLaw_positive _ _ stageA_table_arguments_bounded s u hu | |
| theorem stageBLaw_positive (s u : Shape) (hu : u ∈ below s) : 0 < stageBLaw s u := | |
| splitLaw_positive _ _ stageB_table_arguments_bounded s u hu | |
| theorem stageALaw_normalized (s : Shape) (hs : s ∈ positiveInitial) : | |
| ((below s).map (stageALaw s)).sum = 1 := | |
| splitLaw_normalized _ _ stageA_table_arguments_bounded s (stageA_support_nonempty s hs) | |
| theorem stageBLaw_normalized (s : Shape) (hs : s ∈ positiveSecond) : | |
| ((below s).map (stageBLaw s)).sum = 1 := | |
| splitLaw_normalized _ _ stageB_table_arguments_bounded s (stageB_support_nonempty s hs) | |
| theorem stageALaw_complement (s u : Shape) (hs : s ∈ positiveInitial) (hu : u ∈ below s) : | |
| stageALaw s (complement s u) = stageALaw s u := by | |
| obtain ⟨hc, hb⟩ := stageA_support_complement s hs u hu | |
| exact splitLaw_complement _ _ s u hb hu hc | |
| theorem stageBLaw_complement (s u : Shape) (hs : s ∈ positiveSecond) (hu : u ∈ below s) : | |
| stageBLaw s (complement s u) = stageBLaw s u := by | |
| obtain ⟨hc, hb⟩ := stageB_support_complement s hs u hu | |
| exact splitLaw_complement _ _ s u hb hu hc | |
| end MatrixMultiplication.AllFieldParameters | |
| end OAI | |