File size: 7,156 Bytes
cdec422
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
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