File size: 16,012 Bytes
2f887db
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
import OAI.Computability.PerfectCompleteness.Construction.SourceChildKernelLemmas
import OAI.Computability.PerfectCompleteness.Repetition.CleanEndpointSlots

namespace OAI

section

namespace PerfectCompleteness.CleanRecordChildBlocks

noncomputable section

open scoped Classical
open UniqueGamesTheorem.Foundations.Games
open RecursiveSpaces TreeSourceSpaces HierarchicalArrays
open SourceQuestionReconstruction

variable {branch : Nat → Nat} {h t v m : Nat} {C : Type*} [Fintype C]
  (rows : Nat → Nat) (clauses : Fin m → SourceClause.NormalizedClause v)
  (designated : Fin (branch h) → Slots branch h)

abbrev Record :=
  CleanSourceRecord.Record
    (D := SourceChildKernel.D (C := C) (t := t) rows clauses designated) designated
    (SourceChildKernel.Factors (C := C) (t := t) rows clauses designated)

abbrev Sample := SourceChildKernel.Sample (C := C) (t := t) rows clauses designated

abbrev Row (i : Fin (branch h)) := SourceTuple m t ×
  (SourceChildKernel.Rest (m := m) (t := t) designated i ×
    SourceChildKernel.Raw (C := C) (t := t) rows clauses designated i)

def clean (record : Record (C := C) (t := t) rows clauses designated) :
    Fin (branch h) → Prop :=
  CleanSourceRecord.clean designated
    (SourceChildKernel.Factors (C := C) (t := t) rows clauses designated) record

def visible (record : Record (C := C) (t := t) rows clauses designated) :
    Visible (E := SourceTuple m t) designated (clean rows clauses designated record) :=
  CleanSourceRecord.visible designated
    (SourceChildKernel.Factors (C := C) (t := t) rows clauses designated) record

def projected (record : Record (C := C) (t := t) rows clauses designated) :
    Fin (branch h) → Bool :=
  CleanSourceRecord.projected designated
    (SourceChildKernel.Factors (C := C) (t := t) rows clauses designated) record

def event (record : Record (C := C) (t := t) rows clauses designated) :
    Sample (C := C) (t := t) rows clauses designated → Bool :=
  UniformCleanSources.recordEvent
    (SourceChildKernel.Factors (C := C) (t := t) rows clauses designated)
    (SourceChildKernel.zero (C := C) (t := t) rows clauses designated) record

abbrev Nonclean (record : Record (C := C) (t := t) rows clauses designated) :=
  {i : Fin (branch h) // ¬ clean rows clauses designated record i}

def extract (record : Record (C := C) (t := t) rows clauses designated)
    (i : Nonclean rows clauses designated record) : Row (C := C) (t := t) rows clauses designated i.val :=
  match hr : record i.val with
  | .inl row => row
  | .inr _ => False.elim (i.property (by
      simp only [clean, CleanSourceRecord.clean, hr, UniformCleanSources.cleanRecord]))

theorem record_extract (record : Record (C := C) (t := t) rows clauses designated)
    (i : Nonclean rows clauses designated record) :
    record i.val = .inl (extract rows clauses designated record i) := by
  unfold extract
  split
  · rename_i row hr
    exact hr
  · rename_i rest hr
    exact False.elim (i.property (by
      simp only [clean, CleanSourceRecord.clean, hr, UniformCleanSources.cleanRecord]))

theorem extract_eq (record : Record (C := C) (t := t) rows clauses designated)
    (x : Sample (C := C) (t := t) rows clauses designated)
    (hevent : event rows clauses designated record x = true)
    (i : Nonclean rows clauses designated record) :
    extract rows clauses designated record i = x i.val := by
  have obs := CleanSourceRecord.observation_eq designated
    (SourceChildKernel.Factors (C := C) (t := t) rows clauses designated)
    (SourceChildKernel.zero (C := C) (t := t) rows clauses designated) record x hevent i.val
  cases hc : UniformCleanSources.childClean
      (SourceChildKernel.Factors (C := C) (t := t) rows clauses designated)
      (SourceChildKernel.zero (C := C) (t := t) rows clauses designated)
      i.val (x i.val).1 (x i.val).2.1 (x i.val).2.2 with
  | false =>
      have hr : record i.val = .inl (x i.val) := by
        simpa only [SelectedSources.childObservation, hc, Bool.false_eq_true, ite_false]
          using obs.symm
      exact Sum.inl.inj ((record_extract rows clauses designated record i).symm.trans hr)
  | true =>
      have hr : record i.val = .inr (x i.val).2.1 := by
        simpa only [SelectedSources.childObservation, hc, ite_true] using obs.symm
      exact False.elim (i.property (by
        simp only [clean, CleanSourceRecord.clean, hr, UniformCleanSources.cleanRecord]))

def source (record : Record (C := C) (t := t) rows clauses designated)
    (i : Nonclean rows clauses designated record) :
    SourceChildKernel.Source (m := m) (t := t) designated i.val :=
  ((extract rows clauses designated record i).1, (extract rows clauses designated record i).2.1)

def raw (record : Record (C := C) (t := t) rows clauses designated)
    (i : Nonclean rows clauses designated record) :
    SourceChildKernel.Raw (C := C) (t := t) rows clauses designated i.val :=
  (extract rows clauses designated record i).2.2

theorem visible_nonclean (record : Record (C := C) (t := t) rows clauses designated)
    (i : Nonclean rows clauses designated record) (leaf : Slots branch h)
    (hleaf : ¬ (clean rows clauses designated record i.val ∧ leaf = designated i.val)) :
    visible rows clauses designated record i.val ⟨leaf, hleaf⟩ =
      SourceChildKernel.tree designated i.val (source rows clauses designated record i) leaf := by
  dsimp only [visible, CleanSourceRecord.visible]
  split
  · rename_i row hr
    have hrow : row = extract rows clauses designated record i :=
      Sum.inl.inj (hr.symm.trans (record_extract rows clauses designated record i))
    rw [hrow]
    rfl
  · rename_i rest hr
    have hbad := hr.symm.trans (record_extract rows clauses designated record i)
    cases hbad

theorem projected_nonclean (record : Record (C := C) (t := t) rows clauses designated)
    (i : Nonclean rows clauses designated record) :
    projected rows clauses designated record i.val =
      SourceChildKernel.rawProjected rows clauses designated i.val
        (raw rows clauses designated record i) := by
  simp only [projected, CleanSourceRecord.projected,
    record_extract rows clauses designated record i, raw,
    CleanSourceRecord.rawProjected, SourceChildKernel.rawProjected]
  cases (extract rows clauses designated record i).2.2 <;> rfl

variable [NeZero m]

def leftRef (record : Record (C := C) (t := t) rows clauses designated) :
    Slots branch (h + 1) → Fin t → MixedSupport.Slot :=
  CleanEndpointSlots.leftReference clauses designated (clean rows clauses designated record)
    (visible rows clauses designated record)

def rightRef (record : Record (C := C) (t := t) rows clauses designated) :
    Slots branch (h + 1) → Fin t → MixedSupport.Slot :=
  CleanEndpointSlots.rightReference clauses designated (clean rows clauses designated record)
    (visible rows clauses designated record) (projected rows clauses designated record)

theorem leftRef_childSlots (record : Record (C := C) (t := t) rows clauses designated)
    (i : Nonclean rows clauses designated record) :
    childSlots (leftRef rows clauses designated record) i.val =
      SourceChildKernel.nativeSlots clauses designated i.val (source rows clauses designated record i) := by
  funext leaf k
  have hn : ¬ (clean rows clauses designated record i.val ∧ leaf = designated i.val) :=
    fun h => i.property h.1
  simp only [leftRef, CleanEndpointSlots.leftReference, CleanEndpointSlots.leftInside,
    childSlots, reconstructLeft, reconstruct, dite_eq_right hn]
  rw [visible_nonclean rows clauses designated record i leaf hn]
  rfl

theorem rightRef_childSlots (record : Record (C := C) (t := t) rows clauses designated)
    (i : Nonclean rows clauses designated record) :
    childSlots (rightRef rows clauses designated record) i.val =
      SourceChildKernel.mixedSlots clauses designated i.val (source rows clauses designated record i)
        (SourceChildKernel.rawProjected rows clauses designated i.val (raw rows clauses designated record i)) := by
  funext leaf k
  have hn : ¬ (clean rows clauses designated record i.val ∧ leaf = designated i.val) :=
    fun h => i.property h.1
  simp only [rightRef, CleanEndpointSlots.rightReference, CleanEndpointSlots.rightInside,
    childSlots, reconstructRight, reconstruct, dite_eq_right hn]
  rw [visible_nonclean rows clauses designated record i leaf hn,
    projected_nonclean rows clauses designated record i]
  exact (SourceChildKernel.mixedSlots_eq_rightTuple clauses designated i.val
    (source rows clauses designated record i)
    (SourceChildKernel.rawProjected rows clauses designated i.val (raw rows clauses designated record i))
    leaf k).symm

theorem leftRef_childSlots_event (record : Record (C := C) (t := t) rows clauses designated)
    (x : Sample (C := C) (t := t) rows clauses designated)
    (hevent : event rows clauses designated record x = true)
    (i : Nonclean rows clauses designated record) :
    childSlots (leftRef rows clauses designated record) i.val =
      childSlots (SourceChildKernel.parentLeftSlots clauses designated
        (fun j => ((x j).1, (x j).2.1))) i.val :=
  (leftRef_childSlots rows clauses designated record i).trans
    (congrArg (fun y : Row (C := C) (t := t) rows clauses designated i.val =>
      SourceChildKernel.nativeSlots clauses designated i.val (y.1, y.2.1))
      (extract_eq rows clauses designated record x hevent i))

theorem rightRef_childSlots_event (record : Record (C := C) (t := t) rows clauses designated)
    (x : Sample (C := C) (t := t) rows clauses designated)
    (hevent : event rows clauses designated record x = true)
    (i : Nonclean rows clauses designated record) :
    childSlots (rightRef rows clauses designated record) i.val =
      childSlots (SourceChildKernel.parentRightSlots rows clauses designated
        (fun j => ((x j).1, (x j).2.1)) (fun j => (x j).2.2)) i.val :=
  (rightRef_childSlots rows clauses designated record i).trans
    (congrArg (fun y : Row (C := C) (t := t) rows clauses designated i.val =>
      SourceChildKernel.mixedSlots clauses designated i.val (y.1, y.2.1)
        (SourceChildKernel.rawProjected rows clauses designated i.val y.2.2))
      (extract_eq rows clauses designated record x hevent i))

def physicalRight (i : Fin (branch h)) (row : Row (C := C) (t := t) rows clauses designated i) :
    SourceChildKernel.Block C rows (SourceChildKernel.mixedSlots clauses designated i (row.1, row.2.1)
      (SourceChildKernel.rawProjected rows clauses designated i row.2.2)) :=
  SourceChildKernel.decodeRight rows clauses designated i (row.1, row.2.1) row.2.2

def physicalLeft (i : Fin (branch h)) (row : Row (C := C) (t := t) rows clauses designated i) :
    SourceChildKernel.Block C rows (SourceChildKernel.nativeSlots clauses designated i (row.1, row.2.1)) :=
  let p := SourceChildKernel.projection clauses designated i (row.1, row.2.1)
    (SourceChildKernel.rawProjected rows clauses designated i row.2.2)
  let block := physicalRight rows clauses designated i row
  (fun call => ChildBlockProjection.squarePullback p (block.1 call),
    ChildBlockProjection.arraysPullback rows p block.2)

omit [NeZero m] in
theorem physicalLeft_eq_leftChildren
    (x : Sample (C := C) (t := t) rows clauses designated) (i : Fin (branch h)) :
    physicalLeft rows clauses designated i (x i) =
      SourceChildKernel.leftChildren rows clauses designated
        (fun j => ((x j).1, (x j).2.1)) (fun j => (x j).2.2) i := by
  rw [SourceChildKernel.leftChildren_apply]
  rfl

def rightChild (record : Record (C := C) (t := t) rows clauses designated)
    (i : Nonclean rows clauses designated record) :
    SourceChildKernel.Block C rows (childSlots (rightRef rows clauses designated record) i.val) :=
  cast (congrArg (SourceChildKernel.Block C rows) (rightRef_childSlots rows clauses designated record i).symm)
    (physicalRight rows clauses designated i.val (extract rows clauses designated record i))

def leftChild (record : Record (C := C) (t := t) rows clauses designated)
    (i : Nonclean rows clauses designated record) :
    SourceChildKernel.Block C rows (childSlots (leftRef rows clauses designated record) i.val) :=
  cast (congrArg (SourceChildKernel.Block C rows) (leftRef_childSlots rows clauses designated record i).symm)
    (physicalLeft rows clauses designated i.val (extract rows clauses designated record i))

theorem rightChild_heq (record : Record (C := C) (t := t) rows clauses designated)
    (i : Nonclean rows clauses designated record) :
    HEq (rightChild rows clauses designated record i)
      (physicalRight rows clauses designated i.val (extract rows clauses designated record i)) :=
  cast_heq _ _

theorem leftChild_heq (record : Record (C := C) (t := t) rows clauses designated)
    (i : Nonclean rows clauses designated record) :
    HEq (leftChild rows clauses designated record i)
      (physicalLeft rows clauses designated i.val (extract rows clauses designated record i)) :=
  cast_heq _ _

private theorem dependent_congr {A : Sort*} {B : A → Sort*} (f : (a : A) → B a)
    {a b : A} (h : a = b) : HEq (f a) (f b) := by
  cases h
  rfl

theorem rightChild_event_heq (record : Record (C := C) (t := t) rows clauses designated)
    (x : Sample (C := C) (t := t) rows clauses designated)
    (hevent : event rows clauses designated record x = true)
    (i : Nonclean rows clauses designated record) :
    HEq (rightChild rows clauses designated record i)
      (SourceChildKernel.rightChildren rows clauses designated
        (fun j => ((x j).1, (x j).2.1)) (fun j => (x j).2.2) i.val) :=
  (rightChild_heq rows clauses designated record i).trans
    (dependent_congr (physicalRight rows clauses designated i.val)
      (extract_eq rows clauses designated record x hevent i))

theorem leftChild_event_heq (record : Record (C := C) (t := t) rows clauses designated)
    (x : Sample (C := C) (t := t) rows clauses designated)
    (hevent : event rows clauses designated record x = true)
    (i : Nonclean rows clauses designated record) :
    HEq (leftChild rows clauses designated record i)
      (SourceChildKernel.leftChildren rows clauses designated
        (fun j => ((x j).1, (x j).2.1)) (fun j => (x j).2.2) i.val) := by
  have hphysical :
      HEq (physicalLeft rows clauses designated i.val (extract rows clauses designated record i))
        (physicalLeft rows clauses designated i.val (x i.val)) :=
    dependent_congr (physicalLeft rows clauses designated i.val)
      (extract_eq rows clauses designated record x hevent i)
  exact (leftChild_heq rows clauses designated record i).trans
    (hphysical.trans (heq_of_eq (physicalLeft_eq_leftChildren rows clauses designated x i.val)))

omit [NeZero m] in
theorem childClean_of_clean (record : Record (C := C) (t := t) rows clauses designated)
    (x : Sample (C := C) (t := t) rows clauses designated)
    (hevent : event rows clauses designated record x = true) (i : Fin (branch h))
    (hi : clean rows clauses designated record i) :
    UniformCleanSources.childClean
      (SourceChildKernel.Factors (C := C) (t := t) rows clauses designated)
      (SourceChildKernel.zero (C := C) (t := t) rows clauses designated)
      i (x i).1 (x i).2.1 (x i).2.2 = true := by
  have obs := CleanSourceRecord.observation_eq designated
    (SourceChildKernel.Factors (C := C) (t := t) rows clauses designated)
    (SourceChildKernel.zero (C := C) (t := t) rows clauses designated) record x hevent i
  cases hc : UniformCleanSources.childClean
      (SourceChildKernel.Factors (C := C) (t := t) rows clauses designated)
      (SourceChildKernel.zero (C := C) (t := t) rows clauses designated)
      i (x i).1 (x i).2.1 (x i).2.2 with
  | false =>
      have hr : record i = .inl (x i) := by
        simpa only [SelectedSources.childObservation, hc, Bool.false_eq_true, ite_false]
          using obs.symm
      simp only [clean, CleanSourceRecord.clean, hr, UniformCleanSources.cleanRecord,
        Bool.false_eq_true] at hi
  | true => rfl

end
end PerfectCompleteness.CleanRecordChildBlocks

end

end OAI