File size: 7,508 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
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
import OAI.LinearAlgebra.MatrixMultiplication.JointExtraction.CanonicalCW
import Mathlib.Tactic.FinCases

namespace OAI

/-! Joint tensor extraction, compatibility and entropy estimates. -/

noncomputable section

namespace MatrixMultiplication.JointCanonicalInitial

open MatrixMultiplication.Foundation JointPopulation JointCanonicalization JointCanonicalCW
open InheritedMasks CWStrands
open scoped BigOperators

attribute [local instance] Classical.propDecidable

variable {H F : Type*} [Fintype H] [DecidableEq H] [CommRing F]
    (counts : H → Shape → ℕ)

abbrev Word := Fin 8 → Fin 7
abbrev RawWords := ∀ h, Positions counts h → Word
abbrev CanonicalWords := ∀ c : ClassKey (H := H), ClassPositions counts c → Word

def wholeEquiv (e : Target counts) : RawWords counts ≃ CanonicalWords counts where
  toFun w := fun c j => w c.1 ((positionEquiv counts e c.1).symm ⟨c.2, j⟩)
  invFun w := fun h i => w (h, (e h).val i) (positionEquiv counts e h i).2
  left_inv w := by
    funext h i
    change w h ((positionEquiv counts e h).symm (positionEquiv counts e h i)) = w h i
    simp
  right_inv w := by
    funext c j
    exact congrArg (fun p : Σ u, Fin (counts c.1 u) => w (c.1, p.1) p.2)
      ((positionEquiv counts e c.1).apply_symm_apply ⟨c.2, j⟩)

def rawSource : Tensor F (RawWords counts) (RawWords counts) (RawWords counts) :=
  classProduct (fun _ : H => strand (Fin 8))

def coarseWord (w : RawWords counts) : Position counts → Fin 17 :=
  fun i => CWCoarseIndices.coarseIndex (by simp) (w i.1 i.2)

def ideal (e : Target counts) : Tensor F (RawWords counts) (RawWords counts)
    (RawWords counts) :=
  JointIdealBranches.ideal (rawSource counts) (coarseWord counts) (coarseWord counts)
    (coarseWord counts) (fun _ _ => True) (fun _ _ => True) (fun _ _ => True)
    (triple counts e)

def canonical : Tensor F (CanonicalWords counts) (CanonicalWords counts)
    (CanonicalWords counts) :=
  classProduct (fun c : ClassKey (H := H) => shapeTensor (Fin 8) (shapeNat c.2))

omit [DecidableEq H] in
theorem canonical_pack (e : Target counts) (x y z : RawWords counts) :
    canonical counts (wholeEquiv counts e x) (wholeEquiv counts e y)
      (wholeEquiv counts e z) =
      ∏ h, ∏ i, shapeTensor (F := F) (Fin 8) (shapeNat ((e h).val i))
        (x h i) (y h i) (z h i) := by
  unfold canonical classProduct
  rw [Fintype.prod_prod_type]
  apply Finset.prod_congr rfl
  intro h _
  rw [← Fintype.prod_sigma']
  apply Fintype.prod_equiv (positionEquiv counts e h).symm
  intro i
  simp only [wholeEquiv, Equiv.coe_fn_mk, positionEquiv_symm_shape]

omit [DecidableEq H] in
theorem ideal_eq_canonical (e : Target counts) (x y z : RawWords counts) :
    ideal (F := F) counts e x y z = canonical counts (wholeEquiv counts e x)
      (wholeEquiv counts e y) (wholeEquiv counts e z) := by
  rw [canonical_pack]
  simp only [ideal, JointIdealBranches.ideal, ExactRecovery.delete, and_true,
    rawSource, classProduct, shapeTensor, Fintype.prod_ite_zero, forall_and]
  congr 1
  simp [coarseWord, triple, shapeNat, shapeSide, CWCoarseIndices.coarseIndex,
    funext_iff, Fin.ext_iff, Sigma.forall]

def coordinateMatrix (e : Target counts) : CanonicalWords counts → RawWords counts → F :=
  fun x v => if v = (wholeEquiv counts e).symm x then 1 else 0

theorem ideal_restrict (e : Target counts) :
    Tensor.restrict (coordinateMatrix (F := F) counts e) (coordinateMatrix counts e)
      (coordinateMatrix counts e) (ideal counts e) = canonical counts := by
  funext x y z
  simp only [Tensor.restrict, coordinateMatrix]
  simp only [ite_mul, mul_ite, zero_mul, mul_zero, one_mul, Finset.sum_ite_eq',
    Finset.mem_univ, ↓reduceIte]
  rw [ideal_eq_canonical]
  simp

omit [DecidableEq H] in
theorem coarse_support (x y z : RawWords counts)
    (hT : rawSource (F := F) counts x y z ≠ 0) (i : Position counts) :
    (coarseWord counts x i).val + (coarseWord counts y i).val +
      (coarseWord counts z i).val = 16 := by
  have hh : strand (F := F) (Fin 8) (x i.1 i.2) (y i.1 i.2) (z i.1 i.2) ≠ 0 := by
    intro hz
    apply hT
    unfold rawSource classProduct
    apply Finset.prod_eq_zero (Finset.mem_univ i.1)
    exact Finset.prod_eq_zero (Finset.mem_univ i.2) hz
  simpa [coarseWord] using
    CWCoarseIndices.strand_coarse_support (F := F) (by simp)
      (x i.1 i.2) (y i.1 i.2) (z i.1 i.2) hh

def sideMask (s : Fin 3) (w : RawWords counts) : Prop :=
  ∀ h a, wordPopulation (fun i => coarseWord counts w ⟨h, i⟩) a =
    wordPopulation (sideWord counts s (triple counts (canonicalTarget counts)) h) a

def maskedSource : Tensor F (RawWords counts) (RawWords counts) (RawWords counts) :=
  ExactRecovery.delete (rawSource counts) (sideMask counts 0) (sideMask counts 1)
    (sideMask counts 2)

omit [Fintype H] [DecidableEq H] in
theorem sideMask_of_target (s : Fin 3) (e : Target counts) (w : RawWords counts)
    (he : coarseWord counts w =
      fun i => sideWord counts s (triple counts e) i.1 i.2) :
    sideMask counts s w := by
  intro h a
  rw [he]
  exact marginal_population_eq counts e (canonicalTarget counts) h s a

theorem maskedSource_support (x y z : RawWords counts)
    (hT : maskedSource (F := F) counts x y z ≠ 0) :
    (coarseWord counts x, coarseWord counts y, coarseWord counts z) ∈
      ambientSet counts (fun _ => 16) := by
  have hm : sideMask counts 0 x ∧ sideMask counts 1 y ∧ sideMask counts 2 z := by
    by_contra hn
    simp [maskedSource, ExactRecovery.delete, hn] at hT
  have hr : rawSource (F := F) counts x y z ≠ 0 := by
    simpa [maskedSource, ExactRecovery.delete, hm] using hT
  apply Finset.mem_filter.mpr
  refine ⟨Finset.mem_univ _, ?_, ?_⟩
  · intro i
    exact coarse_support counts x y z hr i
  · intro h s a
    fin_cases s
    · refine Eq.trans ?_ (hm.1 h a)
      apply congrArg (fun v : Positions counts h → Fin 17 => wordPopulation v a)
      funext i
      simp [sideWord, shapeSide]
    · refine Eq.trans ?_ (hm.2.1 h a)
      apply congrArg (fun v : Positions counts h → Fin 17 => wordPopulation v a)
      funext i
      simp [sideWord, shapeSide]
    · refine Eq.trans ?_ (hm.2.2 h a)
      apply congrArg (fun v : Positions counts h → Fin 17 => wordPopulation v a)
      funext i
      simp [sideWord, shapeSide]

omit [DecidableEq H] in
theorem ideal_support_masks (e : Target counts) (x y z : RawWords counts)
    (hT : ideal (F := F) counts e x y z ≠ 0) :
    sideMask counts 0 x ∧ sideMask counts 1 y ∧ sideMask counts 2 z := by
  have hc : coarseWord counts x = (triple counts e).1 ∧
      coarseWord counts y = (triple counts e).2.1 ∧
      coarseWord counts z = (triple counts e).2.2 := by
    by_contra hn
    simp [ideal, JointIdealBranches.ideal, ExactRecovery.delete, hn] at hT
  constructor
  · apply sideMask_of_target counts 0 e x
    simpa [sideWord, shapeSide] using hc.1
  constructor
  · apply sideMask_of_target counts 1 e y
    simpa [sideWord, shapeSide] using hc.2.1
  · apply sideMask_of_target counts 2 e z
    simpa [sideWord, shapeSide] using hc.2.2

omit [DecidableEq H] in
theorem delete_ideal_eq (e : Target counts) :
    ExactRecovery.delete (ideal (F := F) counts e) (sideMask counts 0)
      (sideMask counts 1) (sideMask counts 2) = ideal counts e := by
  funext x y z
  by_cases h : ideal (F := F) counts e x y z = 0
  · rw [ExactRecovery.delete, h]
    simp
  · rw [ExactRecovery.delete, ite_eq_left (ideal_support_masks counts e x y z h)]

end MatrixMultiplication.JointCanonicalInitial

end

end OAI