| import OAI.LinearAlgebra.MatrixMultiplication.FieldHistory.MaskCore |
| import OAI.LinearAlgebra.MatrixMultiplication.FieldHistory.BranchWeights |
|
|
| namespace OAI |
|
|
| /-! Finite extraction histories, inherited masks and recovery bounds. -/ |
|
|
| noncomputable section |
|
|
| namespace MatrixMultiplication.AllFieldHistoryMaskLaws |
|
|
| open AllFieldHistory AllFieldHistoryChildLaws AllFieldHistorySupport |
| open AllFieldHistoryMasks AllFieldHistoryBranchWeights AllFieldParameters |
| open PermutationMatching |
| open scoped BigOperators |
| attribute [local instance] Classical.propDecidable Classical.decEq |
|
|
| variable {K tick : ℕ} |
|
|
| def parentCenter (allocation : Allocation) (side : Fin 3) (h : Active K tick) |
| (a b : Statistic h) : ℝ := |
| ∑ u : JointPopulation.Shape, |
| (activeCounts allocation 1 h u : ℝ) / |
| population allocation 1 (h.val.1.source, h.val.2) * |
| (leftLaw h u side a * rightLaw h u side b) |
|
|
| theorem center_eq_parentCenter (allocation : Allocation) (side : Fin 3) |
| (i : MaskIndex K tick) : |
| center allocation side i = parentCenter allocation side i.1 (i.2.1 i.1) (i.2.2 i.1) := by |
| have hw (c : testedClasses allocation i) : |
| classWeight (fun c : testedClasses allocation i => Positions allocation 1 c.val) c = |
| (activeCounts allocation 1 c.val.1 c.val.2 : ℝ) / |
| population allocation 1 (i.1.val.1.source, i.1.val.2) := by |
| rw [selected_classWeight_formula allocation (by decide : 0 < (1 : ℕ))] |
| simp only [selectedBasePopulation, testedClasses, positiveClasses_baseCount] |
| unfold center classProductMixture |
| simp_rw [hw] |
| let f : Classes K tick → ℝ := fun c => |
| (activeCounts allocation 1 c.1 c.2 : ℝ) / |
| population allocation 1 (i.1.val.1.source, i.1.val.2) * |
| (leftProbability side i c * rightProbability side i c) |
| change (∑ c : testedClasses allocation i, f c.val) = _ |
| rw [Finset.sum_coe_sort] |
| have hzero (c : Classes K tick) : |
| (if 0 < activeCounts allocation 1 c.1 c.2 then f c else 0) = f c := by |
| split_ifs with hc |
| · rfl |
| · have hz : activeCounts allocation 1 c.1 c.2 = 0 := Nat.eq_zero_of_not_pos hc |
| simp [f, hz] |
| simp only [testedClasses, positiveClasses, Finset.sum_filter, ite_and, hzero] |
| rw [Fintype.sum_prod_type, Fintype.sum_eq_single i.1] |
| · simp [f, parentCenter, leftProbability, rightProbability, leftSymbol, rightSymbol] |
| · intro h hh |
| apply Finset.sum_eq_zero |
| intro u _ |
| exact ite_eq_right hh |
|
|
| def stageBActive (h : APositive K) (phi : Placement) |
| (ht : FiniteSchedule.lotTick (Work.stageB h).lot (Work.stageB h).stage = tick) : |
| Active K tick := ⟨(.stageB h, phi), ht⟩ |
|
|
| theorem stageB_leftLaw_branch (h : APositive K) (phi : Placement) |
| (ht : FiniteSchedule.lotTick (Work.stageB h).lot (Work.stageB h).stage = tick) |
| (k : BSplit h) (side : Fin 3) (a : Fin 6) : |
| leftLaw (stageBActive h phi ht) (branchShape (.stageB h, phi) k) side a = |
| (littleLaw (aShape h.val) (bSplit ⟨h, k, false⟩) (phi.symm side) a : ℝ) := by |
| change (placedChildLawRat (.stageB h, phi) (branchShape (.stageB h, phi) k) |
| side false a : ℝ) = _ |
| rw [placedChildLawRat_branchShape (.stageB h, phi) k side false] |
| simp [Work.childLaw, Work.splitShape, halfShape] |
|
|
| theorem stageB_rightLaw_branch (h : APositive K) (phi : Placement) |
| (ht : FiniteSchedule.lotTick (Work.stageB h).lot (Work.stageB h).stage = tick) |
| (k : BSplit h) (side : Fin 3) (b : Fin 6) : |
| rightLaw (stageBActive h phi ht) (branchShape (.stageB h, phi) k) side b = |
| (littleLaw (aShape h.val) (complement (aShape h.val) (bSplit ⟨h, k, false⟩)) |
| (phi.symm side) b : ℝ) := by |
| change (placedChildLawRat (.stageB h, phi) (branchShape (.stageB h, phi) k) |
| side true b : ℝ) = _ |
| rw [placedChildLawRat_branchShape (.stageB h, phi) k side true] |
| simp [Work.childLaw, Work.parentShape, Work.splitShape, halfShape] |
|
|
| theorem stageB_sum_laws (h : APositive K) (side : Fin 3) (a b : Fin 6) : |
| (∑ k : BSplit h, |
| stageBLaw (aShape h.val) (bSplit ⟨h, k, false⟩) * |
| littleLaw (aShape h.val) (bSplit ⟨h, k, false⟩) side a * |
| littleLaw (aShape h.val) (complement (aShape h.val) (bSplit ⟨h, k, false⟩)) side b) = |
| halfLaw (aShape h.val) side (a, b) := by |
| rw [halfLaw_positive_parent _ h.property] |
| unfold positiveHalfLaw |
| change (∑ k : Fin (below (aShape h.val)).length, |
| stageBLaw (aShape h.val) (below (aShape h.val))[k.val] * |
| littleLaw (aShape h.val) (below (aShape h.val))[k.val] side a * |
| littleLaw (aShape h.val) (complement (aShape h.val) (below (aShape h.val))[k.val]) side b) = _ |
| exact Fin.sum_univ_fun_getElem (below (aShape h.val)) |
| (fun u => stageBLaw (aShape h.val) u * littleLaw (aShape h.val) u side a * |
| littleLaw (aShape h.val) (complement (aShape h.val) u) side b) |
|
|
| theorem parentCenter_stageB (allocation : Allocation) (h : APositive K) (phi : Placement) |
| (ht : FiniteSchedule.lotTick (Work.stageB h).lot (Work.stageB h).stage = tick) |
| (side : Fin 3) (a b : Fin 6) : |
| parentCenter allocation side (stageBActive h phi ht) a b = |
| (halfLaw (aShape h.val) (phi.symm side) (a, b) : ℝ) := by |
| let w : PlacedWork K := (.stageB h, phi) |
| let f : JointPopulation.Shape → ℝ := fun u => |
| leftLaw (stageBActive h phi ht) u side a * rightLaw (stageBActive h phi ht) u side b |
| calc |
| parentCenter allocation side (stageBActive h phi ht) a b = |
| (∑ u, (jointCounts allocation 1 w u : ℝ) * f u) / |
| population allocation 1 (.afterA h.val, phi) := by |
| unfold parentCenter |
| rw [Finset.sum_div] |
| apply Finset.sum_congr rfl |
| intro u _ |
| dsimp only [activeCounts, stageBActive, w, f, Work.source] |
| ring |
| _ = (∑ k : BSplit h, (branchPopulation allocation 1 w k : ℝ) * f (branchShape w k)) / |
| population allocation 1 (.afterA h.val, phi) := by |
| rw [jointCounts, shapeCounts_weighted_sum] |
| rfl |
| _ = ∑ k : BSplit h, |
| (stageBLaw (aShape h.val) (bSplit ⟨h, k, false⟩) : ℝ) * |
| (littleLaw (aShape h.val) (bSplit ⟨h, k, false⟩) (phi.symm side) a : ℝ) * |
| (littleLaw (aShape h.val) (complement (aShape h.val) (bSplit ⟨h, k, false⟩)) |
| (phi.symm side) b : ℝ) := by |
| rw [Finset.sum_div] |
| apply Finset.sum_congr rfl |
| intro k _ |
| dsimp only [f, w] |
| rw [stageB_leftLaw_branch, stageB_rightLaw_branch] |
| rw [mul_div_right_comm, |
| stageB_branchWeight_real allocation (by decide : 0 < (1 : ℕ)) h k phi] |
| ring |
| _ = (halfLaw (aShape h.val) (phi.symm side) (a, b) : ℝ) := by |
| exact_mod_cast stageB_sum_laws h (phi.symm side) a b |
|
|
| theorem center_stageB (allocation : Allocation) (h : APositive K) (phi : Placement) |
| (ht : FiniteSchedule.lotTick (Work.stageB h).lot (Work.stageB h).stage = tick) |
| (side : Fin 3) (a b : SymbolChoice K tick) : |
| center allocation side (stageBActive h phi ht, a, b) = |
| (halfLaw (aShape h.val) (phi.symm side) |
| (a (stageBActive h phi ht), b (stageBActive h phi ht)) : ℝ) := by |
| rw [center_eq_parentCenter] |
| exact parentCenter_stageB allocation h phi ht side _ _ |
|
|
| end MatrixMultiplication.AllFieldHistoryMaskLaws |
|
|
| end |
|
|
| end OAI |
|
|
