| import OAI.LinearAlgebra.MatrixMultiplication.FieldHistory.Schedule |
| import OAI.LinearAlgebra.MatrixMultiplication.FieldConstruction.ShapeEncoding |
|
|
| namespace OAI |
|
|
| /-! Finite extraction histories, inherited masks and recovery bounds. -/ |
|
|
| noncomputable section |
| namespace MatrixMultiplication.AllFieldHistory |
|
|
| open AllFieldParameters |
| open scoped BigOperators |
| attribute [local instance] Classical.propDecidable Classical.decEq |
|
|
| def shapeCounts {I : Type*} [Fintype I] (code : I → JointPopulation.Shape) |
| (weight : I → ℕ) (u : JointPopulation.Shape) : ℕ := |
| ∑ i, if code i = u then weight i else 0 |
|
|
| theorem shapeCounts_sum {I : Type*} [Fintype I] (code : I → JointPopulation.Shape) |
| (weight : I → ℕ) : ∑ u, shapeCounts code weight u = ∑ i, weight i := by |
| unfold shapeCounts |
| rw [Finset.sum_comm] |
| simp |
|
|
| theorem shapeCounts_positive {I : Type*} [Fintype I] (code : I → JointPopulation.Shape) |
| (weight : I → ℕ) (u : JointPopulation.Shape) (hu : 0 < shapeCounts code weight u) : |
| ∃ i, code i = u ∧ 0 < weight i := by |
| by_contra hn |
| have hz : shapeCounts code weight u = 0 := by |
| apply Finset.sum_eq_zero |
| intro i hi |
| split_ifs with heq |
| · by_contra hne |
| exact hn ⟨i, heq, Nat.pos_of_ne_zero hne⟩ |
| · rfl |
| omega |
|
|
| theorem shapeCounts_at {I : Type*} [Fintype I] (code : I → JointPopulation.Shape) |
| (weight : I → ℕ) (hi : Function.Injective code) (i : I) : |
| shapeCounts code weight (code i) = weight i := by |
| unfold shapeCounts |
| simp only [hi.eq_iff] |
| simp |
|
|
| theorem Work.parentShape_spec {K : ℕ} (w : Work K) : |
| ShapeBounded w.parentShape ∧ shapeTotal w.parentShape = 4 * w.halfLength := by |
| cases w with |
| | stageA h => exact positiveInitial_shape_spec _ h.property |
| | stageB h => exact positiveSecond_shape_spec _ h.property |
| | stageC h => |
| exact ⟨mem_shapes_bounded (bShape_size h.1.val) (by omega), |
| mem_shapes_total (bShape_size h.1.val)⟩ |
|
|
| theorem Work.splitShape_spec {K : ℕ} (w : Work K) (b : w.Branch) : |
| ShapeBounded (w.splitShape b) ∧ shapeTotal (w.splitShape b) = 2 * w.halfLength := by |
| cases w with |
| | stageA h => exact stageA_shape_spec _ _ h.property (aSplit_mem ⟨h, b, false⟩) |
| | stageB h => exact stageB_shape_spec _ _ h.property (bSplit_mem ⟨h, b, false⟩) |
| | stageC h => exact stageC_shape_spec _ (bShape_size h.1.val) h.1.property b |
|
|
| theorem Work.splitShape_le {K : ℕ} (w : Work K) (b : w.Branch) : |
| ∀ i, w.splitShape b i ≤ w.parentShape i := by |
| cases w with |
| | stageA h => exact below_le (aSplit_mem ⟨h, b, false⟩) |
| | stageB h => exact below_le (bSplit_mem ⟨h, b, false⟩) |
| | stageC h => exact below_le (stageCAtom_mem _ (bShape_size h.1.val) h.1.property b) |
|
|
| theorem Work.splitShape_injective {K : ℕ} (w : Work K) : |
| Function.Injective w.splitShape := by |
| cases w with |
| | stageA h => exact stageA_get_injective _ h.property |
| | stageB h => exact stageB_get_injective _ h.property |
| | stageC h => exact stageCAtom_injective _ (bShape_size h.1.val) h.1.property |
|
|
| def branchShape {K : ℕ} (w : PlacedWork K) (b : w.1.Branch) : JointPopulation.Shape := |
| encodePhysicalShape w.2 (w.1.splitShape b) (w.1.splitShape_spec b).1 |
|
|
| theorem branchShape_injective {K : ℕ} (w : PlacedWork K) : |
| Function.Injective (branchShape w) := by |
| intro a b hab |
| exact w.1.splitShape_injective (encodePhysicalShape_inj w.2 hab) |
|
|
| def jointCounts {K : ℕ} (allocation : Allocation) (dilation : ℕ) |
| (w : PlacedWork K) : JointPopulation.Shape → ℕ := |
| shapeCounts (branchShape w) (branchPopulation allocation dilation w) |
|
|
| def activeCounts {K tick : ℕ} (allocation : Allocation) (dilation : ℕ) |
| (h : Active K tick) : JointPopulation.Shape → ℕ := jointCounts allocation dilation h.val |
|
|
| def activeParentShape {K tick : ℕ} (h : Active K tick) : Shape := |
| physicalShape h.val.2 h.val.1.parentShape |
|
|
| def activeHalfLength {K tick : ℕ} (h : Active K tick) : ℕ := h.val.1.halfLength |
|
|
| theorem jointCounts_sum {K : ℕ} (allocation : Allocation) (dilation : ℕ) |
| (w : PlacedWork K) : ∑ u, jointCounts allocation dilation w u = |
| population allocation dilation (w.1.source, w.2) := by |
| rw [jointCounts, shapeCounts_sum, branchPopulation_sum] |
|
|
| theorem jointCounts_at {K : ℕ} (allocation : Allocation) (dilation : ℕ) |
| (w : PlacedWork K) (b : w.1.Branch) : |
| jointCounts allocation dilation w (branchShape w b) = |
| branchPopulation allocation dilation w b := |
| shapeCounts_at _ _ (branchShape_injective w) b |
|
|
| theorem jointCounts_support_sum {K : ℕ} (allocation : Allocation) (dilation : ℕ) |
| (w : PlacedWork K) (u : JointPopulation.Shape) |
| (hu : 0 < jointCounts allocation dilation w u) : |
| u.1.val + u.2.1.val + u.2.2.val = 2 * w.1.halfLength := by |
| obtain ⟨b, rfl, _⟩ := shapeCounts_positive _ _ u hu |
| exact (encodePhysicalShape_total _ _ _).trans (w.1.splitShape_spec b).2 |
|
|
| theorem jointCounts_support_le {K : ℕ} (allocation : Allocation) (dilation : ℕ) |
| (w : PlacedWork K) (u : JointPopulation.Shape) |
| (hu : 0 < jointCounts allocation dilation w u) (s : Fin 3) : |
| (JointPopulation.shapeSide s u).val ≤ physicalShape w.2 w.1.parentShape s := by |
| obtain ⟨b, rfl, _⟩ := shapeCounts_positive _ _ u hu |
| rw [branchShape, encodePhysicalShape_side] |
| exact w.1.splitShape_le b (w.2.symm s) |
|
|
| def shapePositionMap {K : ℕ} (allocation : Allocation) (dilation : ℕ) |
| (w : PlacedWork K) : |
| (Σ b : w.1.Branch, Fin (branchPopulation allocation dilation w b)) → |
| (Σ u : JointPopulation.Shape, Fin (jointCounts allocation dilation w u)) := |
| fun p => ⟨branchShape w p.1, |
| ⟨p.2.val, by rw [jointCounts_at]; exact p.2.isLt⟩⟩ |
|
|
| theorem shapePositionMap_injective {K : ℕ} (allocation : Allocation) (dilation : ℕ) |
| (w : PlacedWork K) : Function.Injective (shapePositionMap allocation dilation w) := by |
| rintro ⟨b, i⟩ ⟨c, j⟩ heq |
| have hbc : b = c := branchShape_injective w (congrArg Sigma.fst heq) |
| subst c |
| have hij : i.val = j.val := congrArg (fun p => p.2.val) heq |
| have : i = j := Fin.ext hij |
| subst j |
| rfl |
|
|
| theorem shapePositionMap_surjective {K : ℕ} (allocation : Allocation) (dilation : ℕ) |
| (w : PlacedWork K) : Function.Surjective (shapePositionMap allocation dilation w) := by |
| rintro ⟨u, i⟩ |
| obtain ⟨b, heq, hb⟩ := shapeCounts_positive _ _ u (Nat.zero_lt_of_lt i.isLt) |
| subst u |
| refine ⟨⟨b, ⟨i.val, ?_⟩⟩, ?_⟩ |
| · simpa only [jointCounts_at] using i.isLt |
| · rfl |
|
|
| def branchPositionEquiv {K : ℕ} (allocation : Allocation) (dilation : ℕ) |
| (w : PlacedWork K) : |
| (Σ u : JointPopulation.Shape, Fin (jointCounts allocation dilation w u)) ≃ |
| (Σ b : w.1.Branch, Fin (branchPopulation allocation dilation w b)) := |
| (Equiv.ofBijective (shapePositionMap allocation dilation w) |
| ⟨shapePositionMap_injective allocation dilation w, |
| shapePositionMap_surjective allocation dilation w⟩).symm |
|
|
| @[simp] theorem branchPositionEquiv_shape {K : ℕ} (allocation : Allocation) (dilation : ℕ) |
| (w : PlacedWork K) |
| (p : Σ u : JointPopulation.Shape, Fin (jointCounts allocation dilation w u)) : |
| branchShape w (branchPositionEquiv allocation dilation w p).1 = p.1 := by |
| exact congrArg Sigma.fst ((branchPositionEquiv allocation dilation w).symm_apply_apply p) |
|
|
| def rootShape {K : ℕ} (h : Initial K) (phi : Placement) : JointPopulation.Shape := |
| encodePhysicalShape phi (initialShape h) (root_shape_spec _ (initialShape_mem h)).1 |
|
|
| def initialJointCounts {K : ℕ} (allocation : Allocation) (dilation : ℕ) |
| (j : Fin K) : JointPopulation.Shape → ℕ := |
| shapeCounts (fun p : Fin sortedInitial.length × Placement => rootShape (j, p.1) p.2) |
| (fun p => population allocation dilation (.initial (j, p.1), p.2)) |
|
|
| theorem initialJointCounts_sum {K : ℕ} (allocation : Allocation) (dilation : ℕ) |
| (j : Fin K) : ∑ u, initialJointCounts allocation dilation j u = |
| populationLength (K := K) allocation dilation := by |
| rw [initialJointCounts, shapeCounts_sum, Fintype.sum_prod_type] |
| exact initial_population_sum allocation dilation j |
|
|
| theorem initialJointCounts_support {K : ℕ} (allocation : Allocation) (dilation : ℕ) |
| (j : Fin K) (u : JointPopulation.Shape) |
| (hu : 0 < initialJointCounts allocation dilation j u) : |
| u.1.val + u.2.1.val + u.2.2.val = 16 := by |
| obtain ⟨p, rfl, _⟩ := shapeCounts_positive _ _ u hu |
| exact (encodePhysicalShape_total _ _ _).trans (root_shape_spec _ (initialShape_mem _)).2 |
|
|
| end MatrixMultiplication.AllFieldHistory |
|
|
| end |
|
|
| end OAI |
|
|
