File size: 28,021 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
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
import OAI.Computability.PerfectCompleteness.Construction.SourceChildKernelLemmas
import OAI.Computability.PerfectCompleteness.Foundations.CutSlotOutside
import OAI.Computability.PerfectCompleteness.Foundations.WholeCutExteriorTransportLemmas
import OAI.Computability.PerfectCompleteness.Foundations.WholeCutReplayGroupingTransport
import OAI.Computability.PerfectCompleteness.Foundations.WholeCutReplayLemmas
import OAI.Computability.PerfectCompleteness.Repetition.CleanEndpointSlots
import OAI.Computability.PerfectCompleteness.Repetition.CleanRecordChildBlocks

namespace OAI

section

namespace PerfectCompleteness.CleanPhysicalReplay

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

noncomputable section

variable {branch : Nat → Nat} {root h t : Nat}
  (rows repeats : Nat → Nat) (p : Path branch root (h + 1))
  (outside : Slots branch root → Fin t → MixedSupport.Slot)
  (placeholder : Slots branch (h + 1) → Fin t → MixedSupport.Slot)

abbrev Exterior := WholeCutGrouping.Exterior rows repeats p
  (CutSlotAssembly.fill p outside placeholder)

def exteriorAt (inside : Slots branch (h + 1) → Fin t → MixedSupport.Slot)
    (external : Exterior rows repeats p outside placeholder) :
    WholeCutGrouping.Exterior rows repeats p (CutSlotAssembly.fill p outside inside) :=
  WholeCutExteriorTransport.equiv rows repeats p
    (CutSlotAssembly.fill p outside placeholder) (CutSlotAssembly.fill p outside inside)
    (CutSlotAssembly.fill_outside_eq p outside placeholder inside) external

theorem cutSlots_fill (inside : Slots branch (h + 1) → Fin t → MixedSupport.Slot) :
    WholeCutGrouping.cutSlots p (CutSlotAssembly.fill p outside inside) = inside := by
  funext s
  exact CutSlotAssembly.fill_at_cut p outside inside s

theorem childSlots_fill (inside : Slots branch (h + 1) → Fin t → MixedSupport.Slot)
    (i : Fin (branch h)) :
    childSlots (WholeCutGrouping.cutSlots p (CutSlotAssembly.fill p outside inside)) i =
      childSlots inside i :=
  congrArg (fun ss => childSlots ss i) (cutSlots_fill p outside inside)

def fillChild (inside : Slots branch (h + 1) → Fin t → MixedSupport.Slot)
    (i : Fin (branch h))
    (block : CutChildGrouping.Child (C := WholeCutCalls.Index rows repeats p) inside rows i) :
    CutChildGrouping.Child (C := WholeCutCalls.Index rows repeats p)
      (WholeCutGrouping.cutSlots p (CutSlotAssembly.fill p outside inside)) rows i :=
  cast (congrArg (SourceChildKernel.Block (WholeCutCalls.Index rows repeats p) rows)
    (childSlots_fill p outside inside i).symm) block

theorem fillChild_heq (inside : Slots branch (h + 1) → Fin t → MixedSupport.Slot)
    (i : Fin (branch h))
    (block : CutChildGrouping.Child (C := WholeCutCalls.Index rows repeats p) inside rows i) :
    HEq (fillChild rows repeats p outside inside i block) block :=
  cast_heq _ _

private theorem cast_zeroBlock {n : Nat} {C : Type*} [Fintype C]
    (slots target : Slots branch n → Fin t → MixedSupport.Slot) (hs : slots = target) :
    cast (congrArg (SourceChildKernel.Block C rows) hs)
        (SourceChildKernel.zeroBlock (C := C) rows slots) =
      SourceChildKernel.zeroBlock rows target := by
  cases hs
  rfl

theorem fillChild_zero (inside : Slots branch (h + 1) → Fin t → MixedSupport.Slot)
    (i : Fin (branch h)) :
    fillChild rows repeats p outside inside i
        (SourceChildKernel.zeroBlock rows (childSlots inside i)) =
      SourceChildKernel.zeroBlock rows
        (childSlots (WholeCutGrouping.cutSlots p (CutSlotAssembly.fill p outside inside)) i) :=
  cast_zeroBlock rows _ _ (childSlots_fill p outside inside i).symm

def retainedAt (inside : Slots branch (h + 1) → Fin t → MixedSupport.Slot)
    (clean : Fin (branch h) → Prop)
    (children : (i : {i : Fin (branch h) // ¬ clean i}) →
      CutChildGrouping.Child (C := WholeCutCalls.Index rows repeats p) inside rows i.val) :
    WholeCutReplayGrouping.RetainedChildren rows repeats p
      (CutSlotAssembly.fill p outside inside) clean :=
  fun i => fillChild rows repeats p outside inside i.val (children i)

def assembleAt (inside : Slots branch (h + 1) → Fin t → MixedSupport.Slot)
    (clean : Fin (branch h) → Prop)
    (external : Exterior rows repeats p outside placeholder)
    (children : (i : {i : Fin (branch h) // ¬ clean i}) →
      CutChildGrouping.Child (C := WholeCutCalls.Index rows repeats p) inside rows i.val) :
    WholeCutReplay.Tape rows repeats p (CutSlotAssembly.fill p outside inside) clean :=
  WholeCutReplayGrouping.assemble rows repeats p (CutSlotAssembly.fill p outside inside) clean
    (exteriorAt rows repeats p outside placeholder inside external)
    (retainedAt rows repeats p outside inside clean children)

def physicalTape (inside : Slots branch (h + 1) → Fin t → MixedSupport.Slot)
    (external : Exterior rows repeats p outside placeholder)
    (children : CutChildGrouping.Raw (C := WholeCutCalls.Index rows repeats p) inside rows) :
    WholeCutSampler.Tape rows repeats p (CutSlotAssembly.fill p outside inside) :=
  (WholeCutGrouping.splitTape rows repeats p (CutSlotAssembly.fill p outside inside)).symm
    (exteriorAt rows repeats p outside placeholder inside external,
      fun i => fillChild rows repeats p outside inside i (children i))

theorem assembleAt_eq_erase (inside : Slots branch (h + 1) → Fin t → MixedSupport.Slot)
    (clean : Fin (branch h) → Prop)
    (external : Exterior rows repeats p outside placeholder)
    (children : CutChildGrouping.Raw (C := WholeCutCalls.Index rows repeats p) inside rows) :
    assembleAt rows repeats p outside placeholder inside clean external (fun i => children i.val) =
      WholeCutReplay.erase rows repeats p (CutSlotAssembly.fill p outside inside) clean
        (physicalTape rows repeats p outside placeholder inside external children) := by
  have h := WholeCutReplayGrouping.assemble_splitTape rows repeats p
    (CutSlotAssembly.fill p outside inside) clean
    (physicalTape rows repeats p outside placeholder inside external children)
  change WholeCutReplayGrouping.assemble rows repeats p (CutSlotAssembly.fill p outside inside) clean
      (exteriorAt rows repeats p outside placeholder inside external)
      (fun child => fillChild rows repeats p outside inside child.val (children child.val)) =
    WholeCutReplay.erase rows repeats p (CutSlotAssembly.fill p outside inside) clean
      (physicalTape rows repeats p outside placeholder inside external children)
  simpa only [physicalTape, Equiv.apply_symm_apply] using h

theorem physicalTape_grouped_zero
    (inside : Slots branch (h + 1) → Fin t → MixedSupport.Slot)
    (clean : Fin (branch h) → Prop)
    (external : Exterior rows repeats p outside placeholder)
    (children : CutChildGrouping.Raw (C := WholeCutCalls.Index rows repeats p) inside rows)
    (hzero : ∀ i, clean i → children i =
      SourceChildKernel.zeroBlock rows (childSlots inside i)) :
    WholeCutZero.GroupedAtClean rows repeats p (CutSlotAssembly.fill p outside inside) clean
      (physicalTape rows repeats p outside placeholder inside external children) := by
  intro i hi
  have hz : fillChild rows repeats p outside inside i (children i) =
      SourceChildKernel.zeroBlock rows
        (childSlots (WholeCutGrouping.cutSlots p (CutSlotAssembly.fill p outside inside)) i) := by
    rw [hzero i hi]
    exact fillChild_zero rows repeats p outside inside i
  change (∀ q, ((WholeCutGrouping.splitTape rows repeats p
      (CutSlotAssembly.fill p outside inside)
      (physicalTape rows repeats p outside placeholder inside external children)).2 i).1 q = 0) ∧ _
  simp only [physicalTape, Equiv.apply_symm_apply]
  rw [hz]
  exact ⟨fun _ => rfl, fun _ _ => rfl⟩

private theorem exteriorAt_heq
    (inside : Slots branch (h + 1) → Fin t → MixedSupport.Slot)
    (external : Exterior rows repeats p outside placeholder) :
    HEq (exteriorAt rows repeats p outside placeholder inside external) external :=
  cast_heq _ _

theorem transport_assembleAt
    (inside target : Slots branch (h + 1) → Fin t → MixedSupport.Slot)
    (clean : Fin (branch h) → Prop)
    (hs : ∀ i, ¬ clean i → ∀ s, inside (i, s) = target (i, s))
    (external : Exterior rows repeats p outside placeholder)
    (children : (i : {i : Fin (branch h) // ¬ clean i}) →
      CutChildGrouping.Child (C := WholeCutCalls.Index rows repeats p) inside rows i.val)
    (other : (i : {i : Fin (branch h) // ¬ clean i}) →
      CutChildGrouping.Child (C := WholeCutCalls.Index rows repeats p) target rows i.val)
    (hc : ∀ i, HEq (children i) (other i)) :
    WholeCutReplayKeys.transportTape rows repeats p
        (CutSlotAssembly.fill p outside inside) (CutSlotAssembly.fill p outside target) clean
        (CutSlotAssembly.fill_kept_eq p outside inside target clean hs)
        (assembleAt rows repeats p outside placeholder inside clean external children) =
      assembleAt rows repeats p outside placeholder target clean external other := by
  unfold assembleAt
  rw [WholeCutReplayGroupingTransport.transport_assemble]
  apply congrArg₂ (WholeCutReplayGrouping.assemble rows repeats p
    (CutSlotAssembly.fill p outside target) clean)
  · apply eq_of_heq
    exact (cast_heq _ _).trans
      ((exteriorAt_heq rows repeats p outside placeholder inside external).trans
        (exteriorAt_heq rows repeats p outside placeholder target external).symm)
  · funext i
    apply eq_of_heq
    exact (WholeCutReplayGroupingTransport.castChildren_apply_heq rows repeats p
      (CutSlotAssembly.fill p outside inside) (CutSlotAssembly.fill p outside target) clean
      (CutSlotAssembly.fill_kept_eq p outside inside target clean hs)
      (retainedAt rows repeats p outside inside clean children) i).trans
        ((fillChild_heq rows repeats p outside inside i.val (children i)).trans
          ((hc i).trans (fillChild_heq rows repeats p outside target i.val (other i)).symm))

section Source

variable {v m : Nat} [NeZero m]
  (clauses : Fin m → SourceClause.NormalizedClause v)
  (designated : Fin (branch h) → Slots branch h)

abbrev Record := CleanRecordChildBlocks.Record
  (C := WholeCutCalls.Index rows repeats p) (t := t) rows clauses designated

abbrev Sample := SourceChildKernel.Sample
  (C := WholeCutCalls.Index rows repeats p) (t := t) rows clauses designated

def leftRecord (record : Record (t := t) rows repeats p clauses designated)
    (external : Exterior rows repeats p outside placeholder) :
    WholeCutReplay.Tape rows repeats p
      (CutSlotAssembly.fill p outside (CleanRecordChildBlocks.leftRef rows clauses designated record))
      (CleanRecordChildBlocks.clean rows clauses designated record) :=
  assembleAt rows repeats p outside placeholder
    (CleanRecordChildBlocks.leftRef rows clauses designated record)
    (CleanRecordChildBlocks.clean rows clauses designated record) external
    (CleanRecordChildBlocks.leftChild rows clauses designated record)

def rightRecord (record : Record (t := t) rows repeats p clauses designated)
    (external : Exterior rows repeats p outside placeholder) :
    WholeCutReplay.Tape rows repeats p
      (CutSlotAssembly.fill p outside (CleanRecordChildBlocks.rightRef rows clauses designated record))
      (CleanRecordChildBlocks.clean rows clauses designated record) :=
  assembleAt rows repeats p outside placeholder
    (CleanRecordChildBlocks.rightRef rows clauses designated record)
    (CleanRecordChildBlocks.clean rows clauses designated record) external
    (CleanRecordChildBlocks.rightChild rows clauses designated record)

def leftInside (x : Sample (t := t) rows repeats p clauses designated) :
    Slots branch (h + 1) → Fin t → MixedSupport.Slot :=
  SourceChildKernel.parentLeftSlots clauses designated (fun i => ((x i).1, (x i).2.1))

def rightInside (x : Sample (t := t) rows repeats p clauses designated) :
    Slots branch (h + 1) → Fin t → MixedSupport.Slot :=
  SourceChildKernel.parentRightSlots rows clauses designated
    (fun i => ((x i).1, (x i).2.1)) (fun i => (x i).2.2)

def leftBlocks (x : Sample (t := t) rows repeats p clauses designated) :
    CutChildGrouping.Raw (C := WholeCutCalls.Index rows repeats p)
      (leftInside rows repeats p clauses designated x) rows :=
  SourceChildKernel.leftChildren rows clauses designated
    (fun i => ((x i).1, (x i).2.1)) (fun i => (x i).2.2)

def rightBlocks (x : Sample (t := t) rows repeats p clauses designated) :
    CutChildGrouping.Raw (C := WholeCutCalls.Index rows repeats p)
      (rightInside rows repeats p clauses designated x) rows :=
  SourceChildKernel.rightChildren rows clauses designated
    (fun i => ((x i).1, (x i).2.1)) (fun i => (x i).2.2)

def leftTape (x : Sample (t := t) rows repeats p clauses designated)
    (external : Exterior rows repeats p outside placeholder) :
    WholeCutSampler.Tape rows repeats p
      (CutSlotAssembly.fill p outside (leftInside rows repeats p clauses designated x)) :=
  physicalTape rows repeats p outside placeholder (leftInside rows repeats p clauses designated x)
    external (leftBlocks rows repeats p clauses designated x)

def rightTape (x : Sample (t := t) rows repeats p clauses designated)
    (external : Exterior rows repeats p outside placeholder) :
    WholeCutSampler.Tape rows repeats p
      (CutSlotAssembly.fill p outside (rightInside rows repeats p clauses designated x)) :=
  physicalTape rows repeats p outside placeholder (rightInside rows repeats p clauses designated x)
    external (rightBlocks rows repeats p clauses designated x)

theorem leftInside_nonclean (record : Record (t := t) rows repeats p clauses designated)
    (x : Sample (t := t) rows repeats p clauses designated)
    (hevent : CleanRecordChildBlocks.event rows clauses designated record x = true)
    (i : Fin (branch h)) (hi : ¬ CleanRecordChildBlocks.clean rows clauses designated record i)
    (s : Slots branch h) :
    CleanRecordChildBlocks.leftRef rows clauses designated record (i, s) =
      leftInside rows repeats p clauses designated x (i, s) :=
  congrFun (CleanRecordChildBlocks.leftRef_childSlots_event
    rows clauses designated record x hevent ⟨i, hi⟩) s

theorem rightInside_nonclean (record : Record (t := t) rows repeats p clauses designated)
    (x : Sample (t := t) rows repeats p clauses designated)
    (hevent : CleanRecordChildBlocks.event rows clauses designated record x = true)
    (i : Fin (branch h)) (hi : ¬ CleanRecordChildBlocks.clean rows clauses designated record i)
    (s : Slots branch h) :
    CleanRecordChildBlocks.rightRef rows clauses designated record (i, s) =
      rightInside rows repeats p clauses designated x (i, s) :=
  congrFun (CleanRecordChildBlocks.rightRef_childSlots_event
    rows clauses designated record x hevent ⟨i, hi⟩) s

theorem leftRecord_eq_erase (record : Record (t := t) rows repeats p clauses designated)
    (x : Sample (t := t) rows repeats p clauses designated)
    (hevent : CleanRecordChildBlocks.event rows clauses designated record x = true)
    (external : Exterior rows repeats p outside placeholder) :
    WholeCutReplayKeys.transportTape rows repeats p
      (CutSlotAssembly.fill p outside (CleanRecordChildBlocks.leftRef rows clauses designated record))
      (CutSlotAssembly.fill p outside (leftInside rows repeats p clauses designated x))
      (CleanRecordChildBlocks.clean rows clauses designated record)
      (CutSlotAssembly.fill_kept_eq p outside _ _ _
        (leftInside_nonclean rows repeats p clauses designated record x hevent))
      (leftRecord rows repeats p outside placeholder clauses designated record external) =
    WholeCutReplay.erase rows repeats p
      (CutSlotAssembly.fill p outside (leftInside rows repeats p clauses designated x))
      (CleanRecordChildBlocks.clean rows clauses designated record)
      (leftTape rows repeats p outside placeholder clauses designated x external) := by
  exact (transport_assembleAt rows repeats p outside placeholder _ _ _
    (leftInside_nonclean rows repeats p clauses designated record x hevent) external _ _
    (CleanRecordChildBlocks.leftChild_event_heq rows clauses designated record x hevent)).trans
      (assembleAt_eq_erase rows repeats p outside placeholder _ _ external
        (leftBlocks rows repeats p clauses designated x))

theorem rightRecord_eq_erase (record : Record (t := t) rows repeats p clauses designated)
    (x : Sample (t := t) rows repeats p clauses designated)
    (hevent : CleanRecordChildBlocks.event rows clauses designated record x = true)
    (external : Exterior rows repeats p outside placeholder) :
    WholeCutReplayKeys.transportTape rows repeats p
      (CutSlotAssembly.fill p outside (CleanRecordChildBlocks.rightRef rows clauses designated record))
      (CutSlotAssembly.fill p outside (rightInside rows repeats p clauses designated x))
      (CleanRecordChildBlocks.clean rows clauses designated record)
      (CutSlotAssembly.fill_kept_eq p outside _ _ _
        (rightInside_nonclean rows repeats p clauses designated record x hevent))
      (rightRecord rows repeats p outside placeholder clauses designated record external) =
    WholeCutReplay.erase rows repeats p
      (CutSlotAssembly.fill p outside (rightInside rows repeats p clauses designated x))
      (CleanRecordChildBlocks.clean rows clauses designated record)
      (rightTape rows repeats p outside placeholder clauses designated x external) := by
  exact (transport_assembleAt rows repeats p outside placeholder _ _ _
    (rightInside_nonclean rows repeats p clauses designated record x hevent) external _ _
    (CleanRecordChildBlocks.rightChild_event_heq rows clauses designated record x hevent)).trans
      (assembleAt_eq_erase rows repeats p outside placeholder _ _ external
        (rightBlocks rows repeats p clauses designated x))

variable
  (μ : Fin (branch h) → FiniteDistribution (SourceQuestionReconstruction.SourceTuple m t))
  (ν : (i : Fin (branch h)) → FiniteDistribution
    (SourceChildKernel.Rest (m := m) (t := t) designated i))
  (flag : Fin (branch h) → FiniteDistribution Bool)

omit [NeZero m] in
theorem rightBlocks_zero (record : Record (t := t) rows repeats p clauses designated)
    (x : Sample (t := t) rows repeats p clauses designated)
    (hx : (SourceChildKernel.childrenLaw rows clauses designated μ ν flag).weight x ≠ 0)
    (hevent : CleanRecordChildBlocks.event rows clauses designated record x = true)
    (i : Fin (branch h)) (hi : CleanRecordChildBlocks.clean rows clauses designated record i) :
    rightBlocks rows repeats p clauses designated x i =
      SourceChildKernel.zeroBlock rows
        (childSlots (rightInside rows repeats p clauses designated x) i) :=
  SourceChildKernel.childrenLaw_clean_zero rows clauses designated μ ν flag x hx i
    (CleanRecordChildBlocks.childClean_of_clean rows clauses designated record x hevent i hi)

omit [NeZero m] in
theorem leftBlocks_zero (record : Record (t := t) rows repeats p clauses designated)
    (x : Sample (t := t) rows repeats p clauses designated)
    (hx : (SourceChildKernel.childrenLaw rows clauses designated μ ν flag).weight x ≠ 0)
    (hevent : CleanRecordChildBlocks.event rows clauses designated record x = true)
    (i : Fin (branch h)) (hi : CleanRecordChildBlocks.clean rows clauses designated record i) :
    leftBlocks rows repeats p clauses designated x i =
      SourceChildKernel.zeroBlock rows
        (childSlots (leftInside rows repeats p clauses designated x) i) := by
  have hz := rightBlocks_zero rows repeats p clauses designated μ ν flag record x hx hevent i hi
  change ChildAssemblyProjection.childPullback rows
    (SourceChildKernel.parentProjection rows clauses designated
      (fun j => ((x j).1, (x j).2.1)) (fun j => (x j).2.2)) i
    (rightBlocks rows repeats p clauses designated x i) = _
  rw [hz]
  exact map_zero _

omit [NeZero m] in
theorem rightTape_grouped_zero (record : Record (t := t) rows repeats p clauses designated)
    (x : Sample (t := t) rows repeats p clauses designated)
    (hx : (SourceChildKernel.childrenLaw rows clauses designated μ ν flag).weight x ≠ 0)
    (hevent : CleanRecordChildBlocks.event rows clauses designated record x = true)
    (external : Exterior rows repeats p outside placeholder) :
    WholeCutZero.GroupedAtClean rows repeats p
      (CutSlotAssembly.fill p outside (rightInside rows repeats p clauses designated x))
      (CleanRecordChildBlocks.clean rows clauses designated record)
      (rightTape rows repeats p outside placeholder clauses designated x external) :=
  physicalTape_grouped_zero rows repeats p outside placeholder _ _ external _
    (rightBlocks_zero rows repeats p clauses designated μ ν flag record x hx hevent)

omit [NeZero m] in
theorem leftTape_grouped_zero (record : Record (t := t) rows repeats p clauses designated)
    (x : Sample (t := t) rows repeats p clauses designated)
    (hx : (SourceChildKernel.childrenLaw rows clauses designated μ ν flag).weight x ≠ 0)
    (hevent : CleanRecordChildBlocks.event rows clauses designated record x = true)
    (external : Exterior rows repeats p outside placeholder) :
    WholeCutZero.GroupedAtClean rows repeats p
      (CutSlotAssembly.fill p outside (leftInside rows repeats p clauses designated x))
      (CleanRecordChildBlocks.clean rows clauses designated record)
      (leftTape rows repeats p outside placeholder clauses designated x external) :=
  physicalTape_grouped_zero rows repeats p outside placeholder _ _ external _
    (leftBlocks_zero rows repeats p clauses designated μ ν flag record x hx hevent)

private theorem response_of_erase {Y : Type*}
    (slots target : Slots branch root → Fin t → MixedSupport.Slot)
    (clean : Fin (branch h) → Prop)
    (hs : ∀ s, CutSamplerKeyLocality.keptLeaf p clean s → slots s = target s)
    (reference : WholeCutReplay.Tape rows repeats p slots clean)
    (tape : WholeCutSampler.Tape rows repeats p target)
    (htape : WholeCutReplayKeys.transportTape rows repeats p slots target clean hs reference =
      WholeCutReplay.erase rows repeats p target clean tape)
    (hzero : WholeCutZero.GroupedAtClean rows repeats p target clean tape)
    (post : Output branch root rows → Y)
    (labeling : KeyStrategy.Strategy (TreeCanonical.locationCount branch root t))
    (side : CanonicalKeys.Side) :
    KeyStrategy.response labeling side (TreeCanonical.numberedSlots slots)
      (WholeCutReplayKeys.query rows repeats p slots clean reference post) =
    KeyStrategy.response labeling side (TreeCanonical.numberedSlots target)
      (WholeCutKeyLocality.query rows repeats p target tape post) := by
  have h := WholeCutReplayKeys.response_eq_transport rows repeats p slots target clean hs
    reference post labeling side
  rw [htape, WholeCutReplayKeys.query_erase rows repeats p target clean tape post hzero] at h
  exact h

theorem leftRecord_response_eq {Y : Type*}
    (record : Record (t := t) rows repeats p clauses designated)
    (x : Sample (t := t) rows repeats p clauses designated)
    (hx : (SourceChildKernel.childrenLaw rows clauses designated μ ν flag).weight x ≠ 0)
    (hevent : CleanRecordChildBlocks.event rows clauses designated record x = true)
    (external : Exterior rows repeats p outside placeholder)
    (post : Output branch root rows → Y)
    (labeling : KeyStrategy.Strategy (TreeCanonical.locationCount branch root t))
    (side : CanonicalKeys.Side) :
    KeyStrategy.response labeling side
      (TreeCanonical.numberedSlots
        (CutSlotAssembly.fill p outside (CleanRecordChildBlocks.leftRef rows clauses designated record)))
      (WholeCutReplayKeys.query rows repeats p
        (CutSlotAssembly.fill p outside (CleanRecordChildBlocks.leftRef rows clauses designated record))
        (CleanRecordChildBlocks.clean rows clauses designated record)
        (leftRecord rows repeats p outside placeholder clauses designated record external) post) =
    KeyStrategy.response labeling side
      (TreeCanonical.numberedSlots
        (CutSlotAssembly.fill p outside (leftInside rows repeats p clauses designated x)))
      (WholeCutKeyLocality.query rows repeats p
        (CutSlotAssembly.fill p outside (leftInside rows repeats p clauses designated x))
        (leftTape rows repeats p outside placeholder clauses designated x external) post) :=
  response_of_erase rows repeats p _ _ _
    (CutSlotAssembly.fill_kept_eq p outside _ _ _
      (leftInside_nonclean rows repeats p clauses designated record x hevent)) _ _
    (leftRecord_eq_erase rows repeats p outside placeholder clauses designated record x hevent external)
    (leftTape_grouped_zero rows repeats p outside placeholder clauses designated μ ν flag
      record x hx hevent external) post labeling side

theorem rightRecord_response_eq {Y : Type*}
    (record : Record (t := t) rows repeats p clauses designated)
    (x : Sample (t := t) rows repeats p clauses designated)
    (hx : (SourceChildKernel.childrenLaw rows clauses designated μ ν flag).weight x ≠ 0)
    (hevent : CleanRecordChildBlocks.event rows clauses designated record x = true)
    (external : Exterior rows repeats p outside placeholder)
    (post : Output branch root rows → Y)
    (labeling : KeyStrategy.Strategy (TreeCanonical.locationCount branch root t))
    (side : CanonicalKeys.Side) :
    KeyStrategy.response labeling side
      (TreeCanonical.numberedSlots
        (CutSlotAssembly.fill p outside (CleanRecordChildBlocks.rightRef rows clauses designated record)))
      (WholeCutReplayKeys.query rows repeats p
        (CutSlotAssembly.fill p outside (CleanRecordChildBlocks.rightRef rows clauses designated record))
        (CleanRecordChildBlocks.clean rows clauses designated record)
        (rightRecord rows repeats p outside placeholder clauses designated record external) post) =
    KeyStrategy.response labeling side
      (TreeCanonical.numberedSlots
        (CutSlotAssembly.fill p outside (rightInside rows repeats p clauses designated x)))
      (WholeCutKeyLocality.query rows repeats p
        (CutSlotAssembly.fill p outside (rightInside rows repeats p clauses designated x))
        (rightTape rows repeats p outside placeholder clauses designated x external) post) :=
  response_of_erase rows repeats p _ _ _
    (CutSlotAssembly.fill_kept_eq p outside _ _ _
      (rightInside_nonclean rows repeats p clauses designated record x hevent)) _ _
    (rightRecord_eq_erase rows repeats p outside placeholder clauses designated record x hevent external)
    (rightTape_grouped_zero rows repeats p outside placeholder clauses designated μ ν flag
      record x hx hevent external) post labeling side

end Source

section OwnReplay

variable {v m : Nat} [NeZero m]
  (clauses : Fin m → SourceClause.NormalizedClause v)
  (designated : Fin (branch h) → Slots branch h)
  (record : Record (t := t) rows repeats p clauses designated)
  (external : Exterior rows repeats p outside placeholder)

def leftReplay
    (own : {i : Fin (branch h) // CleanRecordChildBlocks.clean rows clauses designated record i} →
      Fin t → Fin m) :=
  CleanEndpointSlots.leftReplay clauses designated
    (CleanRecordChildBlocks.clean rows clauses designated record)
    (CleanRecordChildBlocks.visible rows clauses designated record) rows repeats p outside
    (leftRecord rows repeats p outside placeholder clauses designated record external) own

def rightReplay
    (own : {i : Fin (branch h) // CleanRecordChildBlocks.clean rows clauses designated record i} →
      Fin t → Fin v) :=
  CleanEndpointSlots.rightReplay clauses designated
    (CleanRecordChildBlocks.clean rows clauses designated record)
    (CleanRecordChildBlocks.visible rows clauses designated record) rows repeats p outside
    (CleanRecordChildBlocks.projected rows clauses designated record)
    (rightRecord rows repeats p outside placeholder clauses designated record external) own

end OwnReplay

end
end PerfectCompleteness.CleanPhysicalReplay

end

end OAI