| import OAI.LinearAlgebra.MatrixMultiplication.FieldHistory.Counts |
| import OAI.LinearAlgebra.MatrixMultiplication.FieldParameters.HalfLaws |
| import OAI.LinearAlgebra.MatrixMultiplication.CoppersmithWinograd.CWCompleteStatistics |
|
|
| namespace OAI |
|
|
| /-! Finite extraction histories, inherited masks and recovery bounds. -/ |
|
|
| noncomputable section |
|
|
| namespace MatrixMultiplication.AllFieldHistory |
|
|
| open AllFieldParameters CWStrands CWWindowedLeaves |
| open scoped BigOperators |
| attribute [local instance] Classical.propDecidable Classical.decEq |
|
|
| def Work.Statistic {K : ℕ} : Work K → Type |
| | .stageA _ => PairSlot |
| | .stageB _ => Fin 6 |
| | .stageC _ => PUnit |
|
|
| instance {K : ℕ} (w : Work K) : Fintype w.Statistic := by |
| cases w <;> dsimp [Work.Statistic] <;> infer_instance |
|
|
| instance {K : ℕ} (w : Work K) : DecidableEq w.Statistic := Classical.decEq _ |
|
|
| def Work.statistic {K : ℕ} (w : Work K) : Raw w.halfLength → w.Statistic := |
| match w with |
| | .stageA _ => CWCompleteStatistics.fourStatistic |
| | .stageB _ => CWCompleteStatistics.twoStatistic |
| | .stageC _ => fun _ => PUnit.unit |
|
|
| def Work.statisticWeight {K : ℕ} (w : Work K) : w.Statistic → ℕ := |
| match w with |
| | .stageA _ => fun a => AllFieldParameters.statisticWeight a.1 + |
| AllFieldParameters.statisticWeight a.2 |
| | .stageB _ => AllFieldParameters.statisticWeight |
| | .stageC _ => fun _ => 0 |
|
|
| theorem Work.statistic_weight {K : ℕ} (w : Work K) (hsharing : w.stage ≠ 2) |
| (x : Raw w.halfLength) : CWStrands.weight x = w.statisticWeight (w.statistic x) := by |
| cases w with |
| | stageA h => exact CWCompleteStatistics.four_weight x |
| | stageB h => exact CWCompleteStatistics.two_weight x |
| | stageC h => exact False.elim (hsharing rfl) |
|
|
| def Work.childLaw {K : ℕ} (w : Work K) (u : Shape) (side : Fin 3) : |
| w.Statistic → ℚ := |
| match w with |
| | .stageA _ => halfLaw u side |
| | .stageB h => littleLaw (aShape h.val) u side |
| | .stageC _ => fun _ => 1 |
|
|
| theorem Work.childLaw_nonnegative {K : ℕ} (w : Work K) (u : Shape) |
| (side : Fin 3) (a : w.Statistic) : 0 ≤ w.childLaw u side a := by |
| cases w with |
| | stageA h => exact halfLaw_nonnegative u side a |
| | stageB h => exact littleLaw_nonnegative (aShape h.val) u side a |
| | stageC h => exact zero_le_one |
|
|
| theorem Work.childLaw_normalized {K : ℕ} (w : Work K) (u : Shape) |
| (hu : u ∈ shapes (2 * w.halfLength)) (side : Fin 3) : |
| ∑ a : w.Statistic, w.childLaw u side a = 1 := by |
| cases w with |
| | stageA h => exact halfLaw_normalized u hu side |
| | stageB h => exact littleLaw_normalized (aShape h.val) u side |
| | stageC h => exact Fintype.sum_unique (fun _ : PUnit => (1 : ℚ)) |
|
|
| theorem Work.childLaw_outside_support {K : ℕ} (w : Work K) (hsharing : w.stage ≠ 2) |
| (u : Shape) (hu : u ∈ shapes (2 * w.halfLength)) (side : Fin 3) |
| (a : w.Statistic) (ha : w.statisticWeight a ≠ u side) : w.childLaw u side a = 0 := by |
| cases w with |
| | stageA h => exact halfLaw_outside_support u hu side a ha |
| | stageB h => |
| have hbound : u side < 5 := |
| lt_of_le_of_lt (mem_shapes_bound hu side) (by norm_num [Work.halfLength]) |
| exact littleLaw_outside_support (aShape h.val) u side hbound a ha |
| | stageC h => exact False.elim (hsharing rfl) |
|
|
| def canonicalChildShape {K : ℕ} (w : PlacedWork K) (u : JointPopulation.Shape) : Shape := |
| fun i => decodeShape u (w.2 i) |
|
|
| @[simp] theorem canonicalChildShape_branchShape {K : ℕ} (w : PlacedWork K) |
| (b : w.1.Branch) : canonicalChildShape w (branchShape w b) = w.1.splitShape b := by |
| funext i |
| simp [canonicalChildShape, branchShape, physicalShape] |
|
|
| theorem Work.halfShape_mem {K : ℕ} (w : Work K) (b : w.Branch) (right : Bool) : |
| halfShape w.parentShape (w.splitShape b) right ∈ shapes (2 * w.halfLength) := by |
| cases w with |
| | stageA h => exact aShape_size ⟨h, b, right⟩ |
| | stageB h => exact bShape_size ⟨h, b, right⟩ |
| | stageC h => |
| have hi := stageCAtom_mem (cShapeParent h) (bShape_size h.1.val) h.1.property b |
| have hs := stageC_children_geometry (cShapeParent h) |
| (bShape_size h.1.val) h.1.property (stageCAtom (cShapeParent h) b) |
| hi |
| have ht : shapeTotal (cShapeParent h) = 4 := mem_shapes_total (bShape_size h.1.val) |
| cases right |
| · change stageCAtom (cShapeParent h) b ∈ shapes 2 |
| simpa only [ht] using below_mem_shapes hi |
| · change complement (cShapeParent h) (stageCAtom (cShapeParent h) b) ∈ shapes 2 |
| simpa only [ht] using below_mem_shapes hs.1 |
|
|
| def placedChildLawRat {K : ℕ} (w : PlacedWork K) (u : JointPopulation.Shape) |
| (side : Fin 3) (right : Bool) : w.1.Statistic → ℚ := |
| w.1.childLaw (halfShape w.1.parentShape (canonicalChildShape w u) right) |
| (w.2.symm side) |
|
|
| def childLawRat {K : ℕ} (w : PlacedWork K) (u : JointPopulation.Shape) |
| (side : Fin 3) : w.1.Statistic → ℚ := placedChildLawRat w u side false |
|
|
| def rightChildLawRat {K : ℕ} (w : PlacedWork K) (u : JointPopulation.Shape) |
| (side : Fin 3) : w.1.Statistic → ℚ := placedChildLawRat w u side true |
|
|
| @[simp] theorem placedChildLawRat_branchShape {K : ℕ} (w : PlacedWork K) |
| (b : w.1.Branch) (side : Fin 3) (right : Bool) : |
| placedChildLawRat w (branchShape w b) side right = |
| w.1.childLaw (halfShape w.1.parentShape (w.1.splitShape b) right) |
| (w.2.symm side) := by |
| simp only [placedChildLawRat, canonicalChildShape_branchShape] |
|
|
| theorem placedChildLawRat_nonnegative {K : ℕ} (w : PlacedWork K) |
| (u : JointPopulation.Shape) (side : Fin 3) (right : Bool) (a : w.1.Statistic) : |
| 0 ≤ placedChildLawRat w u side right a := |
| w.1.childLaw_nonnegative _ _ a |
|
|
| theorem placedChildLawRat_normalized_of_pos {K : ℕ} (allocation : Allocation) |
| (dilation : ℕ) (w : PlacedWork K) (u : JointPopulation.Shape) |
| (hu : 0 < jointCounts allocation dilation w u) (side : Fin 3) (right : Bool) : |
| ∑ a : w.1.Statistic, placedChildLawRat w u side right a = 1 := by |
| obtain ⟨b, rfl, _⟩ := shapeCounts_positive _ _ u hu |
| simp only [placedChildLawRat_branchShape] |
| exact w.1.childLaw_normalized _ (w.1.halfShape_mem b right) _ |
|
|
| def childLaw {K : ℕ} (w : PlacedWork K) (u : JointPopulation.Shape) |
| (side : Fin 3) (a : w.1.Statistic) : ℝ := childLawRat w u side a |
|
|
| def rightChildLaw {K : ℕ} (w : PlacedWork K) (u : JointPopulation.Shape) |
| (side : Fin 3) (a : w.1.Statistic) : ℝ := rightChildLawRat w u side a |
|
|
| abbrev ActiveStatistic {K tick : ℕ} (h : Active K tick) := h.val.1.Statistic |
|
|
| def activeStatistic {K tick : ℕ} (h : Active K tick) : |
| Raw (activeHalfLength h) → ActiveStatistic h := h.val.1.statistic |
|
|
| def leftChildLaw {K tick : ℕ} (side : Fin 3) |
| (c : Active K tick × JointPopulation.Shape) : ActiveStatistic c.1 → ℝ := |
| childLaw c.1.val c.2 side |
|
|
| def rightClassChildLaw {K tick : ℕ} (side : Fin 3) |
| (c : Active K tick × JointPopulation.Shape) : ActiveStatistic c.1 → ℝ := |
| rightChildLaw c.1.val c.2 side |
|
|
| theorem leftChildLaw_nonnegative {K tick : ℕ} (side : Fin 3) |
| (c : Active K tick × JointPopulation.Shape) (a : ActiveStatistic c.1) : |
| 0 ≤ leftChildLaw side c a := by |
| change (0 : ℝ) ≤ (placedChildLawRat c.1.val c.2 side false a : ℝ) |
| exact_mod_cast placedChildLawRat_nonnegative c.1.val c.2 side false a |
|
|
| theorem rightClassChildLaw_nonnegative {K tick : ℕ} (side : Fin 3) |
| (c : Active K tick × JointPopulation.Shape) (a : ActiveStatistic c.1) : |
| 0 ≤ rightClassChildLaw side c a := by |
| change (0 : ℝ) ≤ (placedChildLawRat c.1.val c.2 side true a : ℝ) |
| exact_mod_cast placedChildLawRat_nonnegative c.1.val c.2 side true a |
|
|
| theorem leftChildLaw_normalized_of_pos {K tick : ℕ} (allocation : Allocation) |
| (dilation : ℕ) (side : Fin 3) (c : Active K tick × JointPopulation.Shape) |
| (hc : 0 < activeCounts allocation dilation c.1 c.2) : |
| ∑ a : ActiveStatistic c.1, leftChildLaw side c a = 1 := by |
| change (∑ a : c.1.val.1.Statistic, |
| (placedChildLawRat c.1.val c.2 side false a : ℝ)) = 1 |
| exact_mod_cast placedChildLawRat_normalized_of_pos allocation dilation |
| c.1.val c.2 hc side false |
|
|
| theorem rightClassChildLaw_normalized_of_pos {K tick : ℕ} (allocation : Allocation) |
| (dilation : ℕ) (side : Fin 3) (c : Active K tick × JointPopulation.Shape) |
| (hc : 0 < activeCounts allocation dilation c.1 c.2) : |
| ∑ a : ActiveStatistic c.1, rightClassChildLaw side c a = 1 := by |
| change (∑ a : c.1.val.1.Statistic, |
| (placedChildLawRat c.1.val c.2 side true a : ℝ)) = 1 |
| exact_mod_cast placedChildLawRat_normalized_of_pos allocation dilation |
| c.1.val c.2 hc side true |
|
|
| end MatrixMultiplication.AllFieldHistory |
|
|
| namespace MatrixMultiplication.AllFieldHistoryChildLaws |
|
|
| open AllFieldHistory |
| open scoped BigOperators |
|
|
| abbrev Statistic {K tick : ℕ} (h : Active K tick) := ActiveStatistic h |
|
|
| abbrev statistic {K tick : ℕ} (h : Active K tick) : |
| CWWindowedLeaves.Raw (activeHalfLength h) → Statistic h := activeStatistic h |
|
|
| abbrev leftLaw {K tick : ℕ} (h : Active K tick) (u : JointPopulation.Shape) |
| (side : Fin 3) : Statistic h → ℝ := childLaw h.val u side |
|
|
| abbrev rightLaw {K tick : ℕ} (h : Active K tick) (u : JointPopulation.Shape) |
| (side : Fin 3) : Statistic h → ℝ := rightChildLaw h.val u side |
|
|
| theorem leftLaw_nonnegative {K tick : ℕ} (h : Active K tick) (u : JointPopulation.Shape) |
| (side : Fin 3) (a : Statistic h) : 0 ≤ leftLaw h u side a := |
| leftChildLaw_nonnegative side (h, u) a |
|
|
| theorem rightLaw_nonnegative {K tick : ℕ} (h : Active K tick) (u : JointPopulation.Shape) |
| (side : Fin 3) (a : Statistic h) : 0 ≤ rightLaw h u side a := |
| rightClassChildLaw_nonnegative side (h, u) a |
|
|
| theorem leftLaw_normalized {K tick : ℕ} (allocation : Allocation) (dilation : ℕ) |
| (h : Active K tick) (u : JointPopulation.Shape) |
| (hu : 0 < activeCounts allocation dilation h u) (side : Fin 3) : |
| ∑ a : Statistic h, leftLaw h u side a = 1 := |
| leftChildLaw_normalized_of_pos allocation dilation side (h, u) hu |
|
|
| theorem rightLaw_normalized {K tick : ℕ} (allocation : Allocation) (dilation : ℕ) |
| (h : Active K tick) (u : JointPopulation.Shape) |
| (hu : 0 < activeCounts allocation dilation h u) (side : Fin 3) : |
| ∑ a : Statistic h, rightLaw h u side a = 1 := |
| rightClassChildLaw_normalized_of_pos allocation dilation side (h, u) hu |
|
|
| theorem singleton_typeWindow {P : Type*} [Fintype P] [DecidableEq P] [Nonempty P] |
| (η : ℝ) (hη : 0 ≤ η) (w : P → PUnit) : |
| InheritedMasks.typeWindow (fun _ : PUnit => 1) η w := by |
| intro a |
| have hcount : MatrixMultiplication.Foundation.wordPopulation w a = Fintype.card P := by |
| apply Fintype.card_congr |
| exact |
| { toFun := Subtype.val |
| invFun := fun i => ⟨i, Subsingleton.elim _ _⟩ |
| left_inv := fun i => Subtype.ext rfl |
| right_inv := fun i => rfl } |
| have hpos : (0 : ℝ) < Fintype.card P := by |
| exact_mod_cast (Fintype.card_pos : 0 < Fintype.card P) |
| simpa only [InheritedMasks.empiricalLaw, hcount, div_self (ne_of_gt hpos), |
| sub_self, abs_zero] using hη |
|
|
| end MatrixMultiplication.AllFieldHistoryChildLaws |
|
|
| end |
|
|
| end OAI |
|
|
