File size: 39,050 Bytes
4a56cd6
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
import Mathlib
import OAI.Computability.DirectedFeedback.Games.Game
import OAI.Computability.DirectedFeedback.Games.SelectedLikelihood

namespace OAI

namespace DFVSGames.Foundations.Repetition.CompletedSampling

open scoped BigOperators
open Games

noncomputable section

section DistributionIdentities

variable {A B C D : Type*} [Fintype A] [Fintype B] [Fintype C] [Fintype D]

theorem mixture_pushforward_base (ΞΌ : FiniteDistribution A) (f : A β†’ B)
    (K : B β†’ FiniteDistribution C) :
    (ΞΌ.pushforward f).mixture K = ΞΌ.mixture (fun a => K (f a)) := by
  apply FiniteDistribution.eq_of_weight_eq
  intro c
  exact FiniteDistribution.expectation_pushforward ΞΌ f (fun b => (K b).weight c)

theorem product_pushforward_eq_mixture_right (ΞΌ : FiniteDistribution A)
    (Ξ½ : FiniteDistribution B) (f : A Γ— B β†’ C) :
    (ΞΌ.product Ξ½).pushforward f =
      Ξ½.mixture (fun b => ΞΌ.pushforward (fun a => f (a, b))) := by
  classical
  apply FiniteDistribution.eq_of_weight_eq
  intro c
  simp only [FiniteDistribution.pushforward, FiniteDistribution.product,
    FiniteDistribution.mixture, Fintype.sum_prod_type]
  rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro b _
  rw [Finset.mul_sum]
  apply Finset.sum_congr rfl
  intro a _
  by_cases h : f (a, b) = c <;> simp [h, mul_comm]

theorem product_product_pushforward_eq_mixture (ΞΌ : FiniteDistribution A)
    (Ξ½ : FiniteDistribution B) (ΞΊ : FiniteDistribution C) (f : A β†’ B β†’ C β†’ D) :
    (ΞΌ.product (Ξ½.product ΞΊ)).pushforward (fun z => f z.1 z.2.1 z.2.2) =
      (ΞΌ.product Ξ½).mixture
        (fun z => ΞΊ.pushforward (fun c => f z.1 z.2 c)) := by
  classical
  apply FiniteDistribution.eq_of_weight_eq
  intro d
  simp only [FiniteDistribution.pushforward, FiniteDistribution.product,
    FiniteDistribution.mixture, Fintype.sum_prod_type]
  simp only [Finset.mul_sum, mul_ite, mul_zero, mul_assoc]

theorem mixture_totalVariation_le (ΞΌ Ξ½ : FiniteDistribution A)
    (K : A β†’ FiniteDistribution B) :
    (ΞΌ.mixture K).totalVariation (Ξ½.mixture K) ≀ ΞΌ.totalVariation Ξ½ := by
  simpa only [FiniteDistribution.totalVariation, FiniteDistribution.mixture,
    Information.totalVariation, kernelPushforward] using
      totalVariation_kernelPushforward_le ΞΌ.weight Ξ½.weight
        (fun a => (K a).weight) (fun a => Information.gameLaw_isProbability (K a))

end DistributionIdentities

section Diagonal

variable {Z S : Type*} [Fintype Z] [Fintype S]

def diagonalLaw (Οƒ : FiniteDistribution (Z Γ— S)) : FiniteDistribution (Z Γ— S Γ— S) :=
  Information.toGameLaw (diagonalWeights Οƒ.weight)
    (diagonalWeights_isProbability _ (Information.gameLaw_isProbability Οƒ))

theorem diagonalLaw_eq_pushforward (Οƒ : FiniteDistribution (Z Γ— S)) :
    diagonalLaw Οƒ = Οƒ.pushforward (fun z => (z.1, z.2, z.2)) := by
  classical
  apply FiniteDistribution.eq_of_weight_eq
  rintro ⟨z, a, b⟩
  change diagonalWeights Οƒ.weight (z, a, b) =
    (Οƒ.pushforward (fun t => (t.1, t.2, t.2))).weight (z, a, b)
  simp only [diagonalWeights, FiniteDistribution.pushforward,
    Fintype.sum_prod_type, Prod.mk.injEq]
  by_cases hab : a = b
  Β· subst b
    simp [ite_and]
  Β· simp [hab, ite_and]

theorem diagonalLaw_mixture {T : Type*} [Fintype T]
    (Οƒ : FiniteDistribution (Z Γ— S)) (K : Z Γ— S Γ— S β†’ FiniteDistribution T) :
    (diagonalLaw Οƒ).mixture K = Οƒ.mixture (fun z => K (z.1, z.2, z.2)) := by
  rw [diagonalLaw_eq_pushforward, mixture_pushforward_base]

end Diagonal

section Completion

variable {X Y S Ξ“ U V : Type*}
  [Fintype X] [Fintype Y] [Fintype S] [Fintype Ξ“] [Fintype U] [Fintype V]
  [DecidableEq X] [DecidableEq Y] [DecidableEq S]

abbrev Seed (Ξ“ X Y S U V : Type*) :=
  Ξ“ Γ— KernelSampling.Seed (X Γ— S) (Y Γ— S) U V

def seedLaw (Ξ³ : FiniteDistribution Ξ“)
    (L : X Γ— S β†’ FiniteDistribution U) (R : Y Γ— S β†’ FiniteDistribution V) :
    FiniteDistribution (Seed Ξ“ X Y S U V) :=
  Ξ³.product (KernelSampling.seedLaw L R)

def left (sL : Ξ“ β†’ X β†’ S) (seed : Seed Ξ“ X Y S U V) (x : X) : U :=
  KernelSampling.readLeft seed.2 (x, sL seed.1 x)

def right (sR : Ξ“ β†’ Y β†’ S) (seed : Seed Ξ“ X Y S U V) (y : Y) : V :=
  KernelSampling.readRight seed.2 (y, sR seed.1 y)

def completionKernel (L : X Γ— S β†’ FiniteDistribution U)
    (R : Y Γ— S β†’ FiniteDistribution V) (z : (X Γ— Y) Γ— S Γ— S) :
    FiniteDistribution (U Γ— V) :=
  (L (z.1.1, z.2.1)).product (R (z.1.2, z.2.2))

def outputLaw (ΞΌ : FiniteDistribution (X Γ— Y)) (Ξ³ : FiniteDistribution Ξ“)
    (sL : Ξ“ β†’ X β†’ S) (sR : Ξ“ β†’ Y β†’ S)
    (L : X Γ— S β†’ FiniteDistribution U) (R : Y Γ— S β†’ FiniteDistribution V) :
    FiniteDistribution (U Γ— V) :=
  (seedLaw Ξ³ L R).mixture (fun seed =>
    ΞΌ.pushforward (fun q => (left sL seed q.1, right sR seed q.2)))

theorem outputLaw_eq_product_pushforward
    (ΞΌ : FiniteDistribution (X Γ— Y)) (Ξ³ : FiniteDistribution Ξ“)
    (sL : Ξ“ β†’ X β†’ S) (sR : Ξ“ β†’ Y β†’ S)
    (L : X Γ— S β†’ FiniteDistribution U) (R : Y Γ— S β†’ FiniteDistribution V) :
    outputLaw ΞΌ Ξ³ sL sR L R =
      (ΞΌ.product (seedLaw Ξ³ L R)).pushforward
        (fun z => (left sL z.2 z.1.1, right sR z.2 z.1.2)) := by
  exact (product_pushforward_eq_mixture_right ΞΌ (seedLaw Ξ³ L R)
    (fun z : (X Γ— Y) Γ— Seed Ξ“ X Y S U V =>
      (left sL z.2 z.1.1, right sR z.2 z.1.2))).symm

theorem outputLaw_eq_mixture
    (ΞΌ : FiniteDistribution (X Γ— Y)) (Ξ³ : FiniteDistribution Ξ“)
    (sL : Ξ“ β†’ X β†’ S) (sR : Ξ“ β†’ Y β†’ S)
    (L : X Γ— S β†’ FiniteDistribution U) (R : Y Γ— S β†’ FiniteDistribution V) :
    outputLaw ΞΌ Ξ³ sL sR L R =
      (sharedOutputLaw ΞΌ Ξ³ sL sR).mixture (completionKernel L R) := by
  calc
    outputLaw ΞΌ Ξ³ sL sR L R =
        (ΞΌ.product Ξ³).mixture (fun z =>
          (KernelSampling.seedLaw L R).pushforward (fun table =>
            (KernelSampling.readLeft table (z.1.1, sL z.2 z.1.1),
             KernelSampling.readRight table (z.1.2, sR z.2 z.1.2)))) := by
      rw [outputLaw_eq_product_pushforward]
      exact product_product_pushforward_eq_mixture ΞΌ Ξ³ (KernelSampling.seedLaw L R)
        (fun q seed table =>
          (KernelSampling.readLeft table (q.1, sL seed q.1),
           KernelSampling.readRight table (q.2, sR seed q.2)))
    _ = (ΞΌ.product Ξ³).mixture (fun z =>
        completionKernel L R (z.1, sL z.2 z.1.1, sR z.2 z.1.2)) := by
      apply congrArg ((ΞΌ.product Ξ³).mixture)
      funext z
      exact KernelSampling.read_joint_pushforward L R
        (z.1.1, sL z.2 z.1.1) (z.1.2, sR z.2 z.1.2)
    _ = (sharedOutputLaw ΞΌ Ξ³ sL sR).mixture (completionKernel L R) := by
      exact (mixture_pushforward_base (ΞΌ.product Ξ³)
        (fun z => (z.1, sL z.2 z.1.1, sR z.2 z.1.2)) (completionKernel L R)).symm

omit [DecidableEq X] [DecidableEq Y] [DecidableEq S] in

theorem diagonalLaw_completion_mixture
    (Οƒ : FiniteDistribution ((X Γ— Y) Γ— S))
    (L : X Γ— S β†’ FiniteDistribution U) (R : Y Γ— S β†’ FiniteDistribution V) :
    (diagonalLaw Οƒ).mixture (completionKernel L R) =
      Οƒ.mixture (fun z => (L (z.1.1, z.2)).product (R (z.1.2, z.2))) := by
  exact diagonalLaw_mixture Οƒ (completionKernel L R)

theorem outputLaw_totalVariation_le
    (ΞΌ : FiniteDistribution (X Γ— Y)) (Ξ³ : FiniteDistribution Ξ“)
    (sL : Ξ“ β†’ X β†’ S) (sR : Ξ“ β†’ Y β†’ S)
    (L : X Γ— S β†’ FiniteDistribution U) (R : Y Γ— S β†’ FiniteDistribution V)
    (Οƒ : FiniteDistribution ((X Γ— Y) Γ— S)) :
    (outputLaw ΞΌ Ξ³ sL sR L R).totalVariation
        (Οƒ.mixture (fun z => (L (z.1.1, z.2)).product (R (z.1.2, z.2)))) ≀
      (sharedOutputLaw ΞΌ Ξ³ sL sR).totalVariation (diagonalLaw Οƒ) := by
  rw [outputLaw_eq_mixture, ← diagonalLaw_completion_mixture Οƒ L R]
  exact mixture_totalVariation_le _ _ (completionKernel L R)

end Completion

variable {I X Y S Ξ“ : Type*}
  [Fintype I] [Fintype X] [Fintype Y] [Fintype S] [Fintype Ξ“]
  [DecidableEq I] [DecidableEq X] [DecidableEq Y] [DecidableEq S]

def coordinateLeft (j : I) (sL : Ξ“ β†’ X β†’ S)
    (seed : Seed Ξ“ X Y S (I β†’ X) (I β†’ Y)) (x : X) : I β†’ X :=
  KernelSampling.completedLeft j seed.2 (x, sL seed.1 x)

def coordinateRight (j : I) (sR : Ξ“ β†’ Y β†’ S)
    (seed : Seed Ξ“ X Y S (I β†’ X) (I β†’ Y)) (y : Y) : I β†’ Y :=
  KernelSampling.completedRight j seed.2 (y, sR seed.1 y)

omit [Fintype I] [Fintype X] [Fintype Y] [Fintype S] [Fintype Ξ“]
  [DecidableEq X] [DecidableEq Y] [DecidableEq S] in
@[simp] theorem coordinateLeft_preserves (j : I) (sL : Ξ“ β†’ X β†’ S)
    (seed : Seed Ξ“ X Y S (I β†’ X) (I β†’ Y)) (x : X) :
    coordinateLeft j sL seed x j = x := by
  simp [coordinateLeft]

omit [Fintype I] [Fintype X] [Fintype Y] [Fintype S] [Fintype Ξ“]
  [DecidableEq X] [DecidableEq Y] [DecidableEq S] in
@[simp] theorem coordinateRight_preserves (j : I) (sR : Ξ“ β†’ Y β†’ S)
    (seed : Seed Ξ“ X Y S (I β†’ X) (I β†’ Y)) (y : Y) :
    coordinateRight j sR seed y j = y := by
  simp [coordinateRight]

def coordinateOutputLaw (ΞΌ : FiniteDistribution (X Γ— Y)) (Ξ³ : FiniteDistribution Ξ“)
    (j : I) (sL : Ξ“ β†’ X β†’ S) (sR : Ξ“ β†’ Y β†’ S)
    (L : X Γ— S β†’ FiniteDistribution (I β†’ X))
    (R : Y Γ— S β†’ FiniteDistribution (I β†’ Y)) :
    FiniteDistribution ((I β†’ X) Γ— (I β†’ Y)) :=
  (seedLaw Ξ³ L R).mixture (fun seed => ΞΌ.pushforward
    (fun q => (coordinateLeft j sL seed q.1, coordinateRight j sR seed q.2)))

theorem coordinateOutputLaw_eq_mixture
    (ΞΌ : FiniteDistribution (X Γ— Y)) (Ξ³ : FiniteDistribution Ξ“)
    (j : I) (sL : Ξ“ β†’ X β†’ S) (sR : Ξ“ β†’ Y β†’ S)
    (L : X Γ— S β†’ FiniteDistribution (I β†’ X))
    (R : Y Γ— S β†’ FiniteDistribution (I β†’ Y))
    (hL : βˆ€ q xs, (L q).weight xs β‰  0 β†’ xs j = q.1)
    (hR : βˆ€ q ys, (R q).weight ys β‰  0 β†’ ys j = q.1) :
    coordinateOutputLaw ΞΌ Ξ³ j sL sR L R =
      (sharedOutputLaw ΞΌ Ξ³ sL sR).mixture (completionKernel L R) := by
  calc
    coordinateOutputLaw ΞΌ Ξ³ j sL sR L R =
        (ΞΌ.product (seedLaw Ξ³ L R)).pushforward
          (fun z => (coordinateLeft j sL z.2 z.1.1,
            coordinateRight j sR z.2 z.1.2)) := by
      exact (product_pushforward_eq_mixture_right ΞΌ (seedLaw Ξ³ L R)
        (fun z : (X Γ— Y) Γ— Seed Ξ“ X Y S (I β†’ X) (I β†’ Y) =>
          (coordinateLeft j sL z.2 z.1.1, coordinateRight j sR z.2 z.1.2))).symm
    _ = (ΞΌ.product Ξ³).mixture (fun z =>
        (KernelSampling.seedLaw L R).pushforward (fun table =>
          (KernelSampling.completedLeft j table (z.1.1, sL z.2 z.1.1),
           KernelSampling.completedRight j table (z.1.2, sR z.2 z.1.2)))) := by
      exact product_product_pushforward_eq_mixture ΞΌ Ξ³ (KernelSampling.seedLaw L R)
        (fun q seed table =>
          (KernelSampling.completedLeft j table (q.1, sL seed q.1),
           KernelSampling.completedRight j table (q.2, sR seed q.2)))
    _ = (ΞΌ.product Ξ³).mixture (fun z =>
        completionKernel L R (z.1, sL z.2 z.1.1, sR z.2 z.1.2)) := by
      apply congrArg ((ΞΌ.product Ξ³).mixture)
      funext z
      exact KernelSampling.completed_joint_pushforward L R j hL hR
        (z.1.1, sL z.2 z.1.1) (z.1.2, sR z.2 z.1.2)
    _ = (sharedOutputLaw ΞΌ Ξ³ sL sR).mixture (completionKernel L R) := by
      exact (mixture_pushforward_base (ΞΌ.product Ξ³)
        (fun z => (z.1, sL z.2 z.1.1, sR z.2 z.1.2)) (completionKernel L R)).symm

theorem coordinateOutputLaw_eq_outputLaw
    (ΞΌ : FiniteDistribution (X Γ— Y)) (Ξ³ : FiniteDistribution Ξ“)
    (j : I) (sL : Ξ“ β†’ X β†’ S) (sR : Ξ“ β†’ Y β†’ S)
    (L : X Γ— S β†’ FiniteDistribution (I β†’ X))
    (R : Y Γ— S β†’ FiniteDistribution (I β†’ Y))
    (hL : βˆ€ q xs, (L q).weight xs β‰  0 β†’ xs j = q.1)
    (hR : βˆ€ q ys, (R q).weight ys β‰  0 β†’ ys j = q.1) :
    coordinateOutputLaw ΞΌ Ξ³ j sL sR L R = outputLaw ΞΌ Ξ³ sL sR L R := by
  rw [coordinateOutputLaw_eq_mixture ΞΌ Ξ³ j sL sR L R hL hR, outputLaw_eq_mixture]

theorem coordinateOutputLaw_totalVariation_le
    (ΞΌ : FiniteDistribution (X Γ— Y)) (Ξ³ : FiniteDistribution Ξ“)
    (j : I) (sL : Ξ“ β†’ X β†’ S) (sR : Ξ“ β†’ Y β†’ S)
    (L : X Γ— S β†’ FiniteDistribution (I β†’ X))
    (R : Y Γ— S β†’ FiniteDistribution (I β†’ Y))
    (hL : βˆ€ q xs, (L q).weight xs β‰  0 β†’ xs j = q.1)
    (hR : βˆ€ q ys, (R q).weight ys β‰  0 β†’ ys j = q.1)
    (Οƒ : FiniteDistribution ((X Γ— Y) Γ— S)) :
    (coordinateOutputLaw ΞΌ Ξ³ j sL sR L R).totalVariation
        (Οƒ.mixture (fun z => (L (z.1.1, z.2)).product (R (z.1.2, z.2)))) ≀
      (sharedOutputLaw ΞΌ Ξ³ sL sR).totalVariation (diagonalLaw Οƒ) := by
  rw [coordinateOutputLaw_eq_outputLaw ΞΌ Ξ³ j sL sR L R hL hR]
  exact outputLaw_totalVariation_le ΞΌ Ξ³ sL sR L R Οƒ

end

end DFVSGames.Foundations.Repetition.CompletedSampling

namespace DFVSGames.Foundations.Games.Game

noncomputable section

variable {Q₁ Qβ‚‚ A₁ Aβ‚‚ R₁ Rβ‚‚ B₁ Bβ‚‚ Seed : Type*}
  [Fintype Q₁] [Fintype Qβ‚‚] [Fintype A₁] [Fintype Aβ‚‚]
  [Fintype R₁] [Fintype Rβ‚‚] [Fintype B₁] [Fintype Bβ‚‚] [Fintype Seed]
  [Nonempty A₁] [Nonempty Aβ‚‚]

def localEmbeddingLaw (G : Game Q₁ Qβ‚‚ A₁ Aβ‚‚)
    (seedLaw : FiniteDistribution Seed)
    (left : Seed β†’ Q₁ β†’ R₁) (right : Seed β†’ Qβ‚‚ β†’ Rβ‚‚) :
    FiniteDistribution (R₁ Γ— Rβ‚‚) :=
  seedLaw.mixture fun seed =>
    G.questions.pushforward fun q => (left seed q.1, right seed q.2)

theorem success_le_value_add_embedding_distance
    (G : Game Q₁ Qβ‚‚ A₁ Aβ‚‚) (H : Game R₁ Rβ‚‚ B₁ Bβ‚‚)
    (seedLaw : FiniteDistribution Seed)
    (left : Seed β†’ Q₁ β†’ R₁) (right : Seed β†’ Qβ‚‚ β†’ Rβ‚‚)
    (answerLeft : Seed β†’ Q₁ β†’ B₁ β†’ A₁)
    (answerRight : Seed β†’ Qβ‚‚ β†’ Bβ‚‚ β†’ Aβ‚‚)
    (acceptance : βˆ€ seed x y a b,
      H.accepts (left seed x) (right seed y) a b = true β†’
      G.accepts x y (answerLeft seed x a) (answerRight seed y b) = true)
    (strategy : Strategy R₁ Rβ‚‚ B₁ Bβ‚‚) :
    H.success strategy ≀ G.value +
      H.questions.totalVariation (G.localEmbeddingLaw seedLaw left right) := by
  have localBound (seed : Seed) :
      (G.questions.pushforward (fun q => (left seed q.1, right seed q.2))).probability
        (H.wins strategy) ≀ G.value := by
    let embedded : Game R₁ Rβ‚‚ B₁ Bβ‚‚ :=
      { questions := G.questions.pushforward fun q => (left seed q.1, right seed q.2)
        accepts := H.accepts }
    change embedded.success strategy ≀ G.value
    exact (G.success_le_of_localSimulation embedded (left seed) (right seed)
      (answerLeft seed) (answerRight seed) rfl (acceptance seed) strategy).trans
      (G.success_le_value _)
  have mixtureBound :
      (G.localEmbeddingLaw seedLaw left right).probability (H.wins strategy) ≀ G.value :=
    seedLaw.probability_mixture_le _ _ _ localBound
  exact (H.questions.probability_le_add_totalVariation
    (G.localEmbeddingLaw seedLaw left right) (H.wins strategy)).trans
    (add_le_add mixtureBound (le_refl _))

def coordinateGame (G : Game Q₁ Qβ‚‚ A₁ Aβ‚‚) {n : Nat} (coordinate : Fin n)
    (law : FiniteDistribution ((Fin n β†’ Q₁) Γ— (Fin n β†’ Qβ‚‚))) :
    Game (Fin n β†’ Q₁) (Fin n β†’ Qβ‚‚) (Fin n β†’ A₁) (Fin n β†’ Aβ‚‚) where
  questions := law
  accepts x y a b := G.accepts (x coordinate) (y coordinate) (a coordinate) (b coordinate)

theorem coordinate_probability_le_value_add_embedding_distance
    (G : Game Q₁ Qβ‚‚ A₁ Aβ‚‚) {n : Nat} (coordinate : Fin n)
    (law : FiniteDistribution ((Fin n β†’ Q₁) Γ— (Fin n β†’ Qβ‚‚)))
    (seedLaw : FiniteDistribution Seed)
    (left : Seed β†’ Q₁ β†’ Fin n β†’ Q₁) (right : Seed β†’ Qβ‚‚ β†’ Fin n β†’ Qβ‚‚)
    (left_preserves : βˆ€ seed x, left seed x coordinate = x)
    (right_preserves : βˆ€ seed y, right seed y coordinate = y)
    (strategy : Strategy (Fin n β†’ Q₁) (Fin n β†’ Qβ‚‚) (Fin n β†’ A₁) (Fin n β†’ Aβ‚‚)) :
    law.probability (G.coordinateWin strategy coordinate) ≀ G.value +
      law.totalVariation (G.localEmbeddingLaw seedLaw left right) := by
  apply G.success_le_value_add_embedding_distance (G.coordinateGame coordinate law)
    seedLaw left right (fun _ _ a => a coordinate) (fun _ _ b => b coordinate)
  intro seed x y a b h
  simpa only [coordinateGame, left_preserves, right_preserves] using h

theorem coordinate_probability_le_value_of_approximate_embeddings
    {SeedFamily : Nat β†’ Type*} [βˆ€ t, Fintype (SeedFamily t)]
    (G : Game Q₁ Qβ‚‚ A₁ Aβ‚‚) {n : Nat} (coordinate : Fin n)
    (law : FiniteDistribution ((Fin n β†’ Q₁) Γ— (Fin n β†’ Qβ‚‚)))
    (seedLaw : (t : Nat) β†’ FiniteDistribution (SeedFamily t))
    (left : (t : Nat) β†’ SeedFamily t β†’ Q₁ β†’ Fin n β†’ Q₁)
    (right : (t : Nat) β†’ SeedFamily t β†’ Qβ‚‚ β†’ Fin n β†’ Qβ‚‚)
    (left_preserves : βˆ€ t seed x, left t seed x coordinate = x)
    (right_preserves : βˆ€ t seed y, right t seed y coordinate = y)
    (strategy : Strategy (Fin n β†’ Q₁) (Fin n β†’ Qβ‚‚) (Fin n β†’ A₁) (Fin n β†’ Aβ‚‚))
    (distance : ℝ)
    (close : βˆ€ Ξ· : ℝ, 0 < Ξ· β†’ βˆƒ t,
      law.totalVariation (G.localEmbeddingLaw (seedLaw t) (left t) (right t)) ≀
        distance + Ξ·) :
    law.probability (G.coordinateWin strategy coordinate) ≀ G.value + distance := by
  by_contra h
  have gap : 0 < law.probability (G.coordinateWin strategy coordinate) -
      (G.value + distance) := sub_pos.mpr (lt_of_not_ge h)
  obtain ⟨t, ht⟩ := close
    ((law.probability (G.coordinateWin strategy coordinate) - (G.value + distance)) / 2)
    (by linarith)
  have bound := G.coordinate_probability_le_value_add_embedding_distance coordinate law
    (seedLaw t) (left t) (right t) (left_preserves t) (right_preserves t) strategy
  linarith

end
end DFVSGames.Foundations.Games.Game

namespace DFVSGames.Foundations.Repetition
open scoped BigOperators
open Games CorrelatedSampling
noncomputable section
variable {Q₁ Qβ‚‚ A₁ Aβ‚‚ S : Type*}
  [Fintype Q₁] [Fintype Qβ‚‚] [Fintype A₁] [Fintype Aβ‚‚] [Fintype S]
  [Nonempty A₁] [Nonempty Aβ‚‚] [Nonempty S]
  [DecidableEq Q₁] [DecidableEq Qβ‚‚] [DecidableEq S] {n : Nat}

theorem coordinate_probability_le_value_of_local_completion
    (G : Game Q₁ Qβ‚‚ A₁ Aβ‚‚) (j : Fin n)
    (strategy : Strategy (Fin n β†’ Q₁) (Fin n β†’ Qβ‚‚) (Fin n β†’ A₁) (Fin n β†’ Aβ‚‚))
    (Οƒ : FiniteDistribution ((Q₁ Γ— Qβ‚‚) Γ— S))
    (profileL : Q₁ β†’ FiniteDistribution S) (profileR : Qβ‚‚ β†’ FiniteDistribution S)
    (completionL : Q₁ Γ— S β†’ FiniteDistribution (Fin n β†’ Q₁))
    (completionR : Qβ‚‚ Γ— S β†’ FiniteDistribution (Fin n β†’ Qβ‚‚))
    (supportL : βˆ€ q xs, (completionL q).weight xs β‰  0 β†’ xs j = q.1)
    (supportR : βˆ€ q ys, (completionR q).weight ys β‰  0 β†’ ys j = q.1)
    (fallback : S) :
    (Οƒ.mixture (fun z => (completionL (z.1.1,z.2)).product
      (completionR (z.1.2,z.2)))).probability (G.coordinateWin strategy j) ≀
      G.value +
        (2 * Information.totalVariation Οƒ.weight
          (fun z => G.questions.weight z.1 * (profileL z.1.1).weight z.2) +
         2 * Information.totalVariation Οƒ.weight
          (fun z => G.questions.weight z.1 * (profileR z.1.2).weight z.2)) := by
  let targetLaw := Οƒ.mixture (fun z => (completionL (z.1.1,z.2)).product (completionR (z.1.2,z.2)))
  let Ξ΄ := 2 * Information.totalVariation Οƒ.weight
      (fun z => G.questions.weight z.1 * (profileL z.1.1).weight z.2) +
    2 * Information.totalVariation Οƒ.weight
      (fun z => G.questions.weight z.1 * (profileR z.1.2).weight z.2)
  change targetLaw.probability (G.coordinateWin strategy j) ≀ G.value + Ξ΄
  by_contra h
  have gap : 0 < targetLaw.probability (G.coordinateWin strategy j) - (G.value + Ξ΄) :=
    sub_pos.mpr (lt_of_not_ge h)
  let Ξ· := (targetLaw.probability (G.coordinateWin strategy j) - (G.value + Ξ΄)) / 2
  have hΞ· : 0 < Ξ· := by dsimp [Ξ·]; linarith
  obtain ⟨N,hN⟩ := samplerOutputLaw_arbitrarily_close Οƒ G.questions profileL profileR fallback Ξ· hΞ·
  let thresholds := sharedProfileThresholds profileL profileR
  let Ξ³ := traceSeedLaw (rectangleDistribution (Ξ± := S) thresholds) N
  let sL := samplerLocal thresholds profileL fallback N
  let sR := samplerLocal thresholds profileR fallback N
  have hvariation := CompletedSampling.coordinateOutputLaw_totalVariation_le
    G.questions Ξ³ j sL sR completionL completionR supportL supportR Οƒ
  have hclose : (CompletedSampling.coordinateOutputLaw G.questions Ξ³ j sL sR completionL completionR).totalVariation targetLaw ≀ Ξ΄ + Ξ· :=
    hvariation.trans hN
  have hsuccess := G.coordinate_probability_le_value_add_embedding_distance j targetLaw
    (CompletedSampling.seedLaw Ξ³ completionL completionR)
    (CompletedSampling.coordinateLeft j sL) (CompletedSampling.coordinateRight j sR)
    (CompletedSampling.coordinateLeft_preserves j sL)
    (CompletedSampling.coordinateRight_preserves j sR) strategy
  have hsym : targetLaw.totalVariation
      (G.localEmbeddingLaw (CompletedSampling.seedLaw Ξ³ completionL completionR)
        (CompletedSampling.coordinateLeft j sL) (CompletedSampling.coordinateRight j sR)) =
      (CompletedSampling.coordinateOutputLaw G.questions Ξ³ j sL sR completionL completionR).totalVariation targetLaw := by
    unfold FiniteDistribution.totalVariation
    congr 1
    apply Finset.sum_congr rfl
    intro q _
    exact abs_sub_comm _ _
  rw [hsym] at hsuccess
  dsimp [Ξ·] at hclose
  linarith

end
end DFVSGames.Foundations.Repetition

namespace DFVSGames.Foundations.Repetition

open scoped BigOperators
open Games
noncomputable section

variable {Q₁ Qβ‚‚ A₁ Aβ‚‚ : Type*}
  [Fintype Q₁] [Fintype Qβ‚‚] [Fintype A₁] [Fintype Aβ‚‚]
  [DecidableEq Q₁] [DecidableEq Qβ‚‚] {n : β„•}

theorem selectedLabels_card (selected : Finset (Fin n)) :
    Fintype.card (SelectedLabels (A₁ := A₁) (Aβ‚‚ := Aβ‚‚) selected) =
      (Fintype.card A₁ * Fintype.card Aβ‚‚) ^ selected.card := by
  simp [SelectedLabels, Fintype.card_prod, mul_pow]

theorem unusedCoordinates_card (selected : Finset (Fin n)) :
    Fintype.card {i : Fin n // i βˆ‰ selected} = n - selected.card := by
  classical
  simp

theorem unusedCoordinates_card_real (selected : Finset (Fin n)) :
    (Fintype.card {i : Fin n // i βˆ‰ selected} : ℝ) = (n : ℝ) - selected.card := by
  have hs : selected.card ≀ n := by simpa using Finset.card_le_univ selected
  rw [unusedCoordinates_card, Nat.cast_sub hs]

theorem log_le_logTwo {x : ℝ} (hx : 1 ≀ x) : Real.log x ≀ logTwo x := by
  have hlog : 0 ≀ Real.log x := Real.log_nonneg hx
  have htwo : 0 < Real.log 2 := Real.log_pos (by norm_num)
  have htwo_le : Real.log 2 ≀ 1 := by
    convert Real.log_le_sub_one_of_pos (by norm_num : (0 : ℝ) < 2) using 1 ; norm_num
  unfold logTwo
  apply (le_div_iffβ‚€ htwo).2
  simpa using mul_le_mul_of_nonneg_left htwo_le hlog

theorem selectedLabels_log_le [Nonempty A₁] [Nonempty Aβ‚‚]
    (selected : Finset (Fin n)) (ell : ℝ)
    (hell : logTwo ((Fintype.card A₁ : ℝ) * (Fintype.card Aβ‚‚ : ℝ)) ≀ ell) :
    Real.log (Fintype.card (SelectedLabels (A₁ := A₁) (Aβ‚‚ := Aβ‚‚) selected) : ℝ) ≀
      (selected.card : ℝ) * ell := by
  have ha : (1 : ℝ) ≀ Fintype.card A₁ := by exact_mod_cast Fintype.card_pos (Ξ± := A₁)
  have hb : (1 : ℝ) ≀ Fintype.card Aβ‚‚ := by exact_mod_cast Fintype.card_pos (Ξ± := Aβ‚‚)
  have hab : (1 : ℝ) ≀ (Fintype.card A₁ : ℝ) * (Fintype.card Aβ‚‚ : ℝ) := by nlinarith
  rw [selectedLabels_card, Nat.cast_pow, Nat.cast_mul, Real.log_pow]
  exact mul_le_mul_of_nonneg_left ((log_le_logTwo hab).trans hell) (Nat.cast_nonneg _)

omit [DecidableEq Q₁] [DecidableEq Qβ‚‚] in

theorem selectedInformationRadius_le [Nonempty A₁] [Nonempty Aβ‚‚]
    (G : Game Q₁ Qβ‚‚ A₁ Aβ‚‚)
    (strategy : Strategy (Fin n β†’ Q₁) (Fin n β†’ Qβ‚‚) (Fin n β†’ A₁) (Fin n β†’ Aβ‚‚))
    (selected : Finset (Fin n)) (positive : 0 < G.selectedSuccess strategy selected)
    (ell : ℝ)
    (hell : logTwo ((Fintype.card A₁ : ℝ) * (Fintype.card Aβ‚‚ : ℝ)) ≀ ell) :
    selectedInformationRadius G strategy selected ≀
      Real.sqrt (((n : ℝ) - selected.card) *
        ((selected.card : ℝ) * ell + logTwo (1 / G.selectedSuccess strategy selected))) := by
  have hprob : 1 ≀ 1 / G.selectedSuccess strategy selected := by
    apply (le_div_iffβ‚€ positive).2
    simpa using G.selectedSuccess_le_one strategy selected
  have hbudget := add_le_add (selectedLabels_log_le (A₁ := A₁) (Aβ‚‚ := Aβ‚‚) selected ell hell)
    (log_le_logTwo hprob)
  unfold selectedInformationRadius
  rw [← unusedCoordinates_card_real selected]
  apply Real.sqrt_le_sqrt
  exact mul_le_mul_of_nonneg_left hbudget (Nat.cast_nonneg _)

theorem sqrt_budget_factor (a b : ℝ) (ha : 0 < a) :
    Real.sqrt (a * b) = a * Real.sqrt (b / a) := by
  have he : a * b = a ^ 2 * (b / a) := by
    field_simp
  rw [he, Real.sqrt_mul (sq_nonneg a), Real.sqrt_sq (le_of_lt ha)]

omit [DecidableEq Q₁] [DecidableEq Qβ‚‚] in

theorem exists_coordinate_le_information_budget [Nonempty A₁] [Nonempty Aβ‚‚]
    (G : Game Q₁ Qβ‚‚ A₁ Aβ‚‚)
    (strategy : Strategy (Fin n β†’ Q₁) (Fin n β†’ Qβ‚‚) (Fin n β†’ A₁) (Fin n β†’ Aβ‚‚))
    (selected : Finset (Fin n)) (positive : 0 < G.selectedSuccess strategy selected)
    (ell : ℝ)
    (hell : logTwo ((Fintype.card A₁ : ℝ) * (Fintype.card Aβ‚‚ : ℝ)) ≀ ell)
    (hselected : selected.card < n)
    (error : {i : Fin n // i βˆ‰ selected} β†’ ℝ)
    (hsum : (βˆ‘ j, error j) ≀ 15 * selectedInformationRadius G strategy selected) :
    βˆƒ j : {i : Fin n // i βˆ‰ selected}, error j ≀ 15 * Real.sqrt
      (((selected.card : ℝ) * ell + logTwo (1 / G.selectedSuccess strategy selected)) /
        ((n : ℝ) - selected.card)) := by
  classical
  have hcard : 0 < Fintype.card {i : Fin n // i βˆ‰ selected} := by
    rw [unusedCoordinates_card]
    exact Nat.sub_pos_of_lt hselected
  let : Nonempty {i : Fin n // i βˆ‰ selected} := Fintype.card_pos_iff.mp hcard
  have hden : 0 < (n : ℝ) - selected.card := by
    rw [← unusedCoordinates_card_real selected]
    exact_mod_cast hcard
  have htotal := hsum.trans (mul_le_mul_of_nonneg_left
    (selectedInformationRadius_le G strategy selected positive ell hell) (by norm_num : (0 : ℝ) ≀ 15))
  rw [sqrt_budget_factor _ _ hden] at htotal
  have havg : (βˆ‘ j, error j) ≀ βˆ‘ _j : {i : Fin n // i βˆ‰ selected},
      15 * Real.sqrt
        (((selected.card : ℝ) * ell + logTwo (1 / G.selectedSuccess strategy selected)) /
          ((n : ℝ) - selected.card)) := by
    simpa only [Finset.sum_const, Finset.card_univ, nsmul_eq_mul,
      unusedCoordinates_card_real, mul_assoc, mul_left_comm] using htotal
  obtain ⟨j, _, hj⟩ := Finset.exists_le_of_sum_le Finset.univ_nonempty havg
  exact ⟨j, hj⟩

end
end DFVSGames.Foundations.Repetition

namespace DFVSGames.Foundations.Repetition.SelectionSequence

private theorem exists_unused_inline_SelectionSequence {n : Nat} (S : Finset (Fin n)) (hcard : S.card < n) :
    βˆƒ j : Fin n, j βˆ‰ S := by
  classical
  apply Classical.byContradiction
  intro h
  have hall : βˆ€ j : Fin n, j ∈ S := by
    intro j
    apply Classical.byContradiction
    intro hj
    exact h ⟨j, hj⟩
  have hfull : S = Finset.univ :=
    Finset.ext (fun j => iff_of_true (hall j) (Finset.mem_univ j))
  have hbad : n < n := by
    simpa only [hfull, Finset.card_univ, Fintype.card_fin] using hcard
  exact Nat.lt_irrefl n hbad

noncomputable def nextSet {n : Nat}
    (Step : Finset (Fin n) β†’ Fin n β†’ Prop)
    (witness : βˆ€ S, S.card < n β†’ βˆƒ j, j βˆ‰ S ∧ Step S j)
    (S : Finset (Fin n)) : Finset (Fin n) :=
  if hs : S.card < n then insert (Classical.choose (witness S hs)) S else S

noncomputable def selectedSet {n : Nat}
    (Step : Finset (Fin n) β†’ Fin n β†’ Prop)
    (witness : βˆ€ S, S.card < n β†’ βˆƒ j, j βˆ‰ S ∧ Step S j) : Nat β†’ Finset (Fin n)
  | 0 => βˆ…
  | m + 1 => nextSet Step witness (selectedSet Step witness m)

theorem selectedSet_card {n : Nat}
    (Step : Finset (Fin n) β†’ Fin n β†’ Prop)
    (witness : βˆ€ S, S.card < n β†’ βˆƒ j, j βˆ‰ S ∧ Step S j) (m : Nat) :
    (selectedSet Step witness m).card = min m n := by
  induction m with
  | zero => simp [selectedSet]
  | succ m ih =>
    by_cases hm : m < n
    Β· have hc : (selectedSet Step witness m).card = m := by
        simpa only [Nat.min_eq_left (Nat.le_of_lt hm)] using ih
      have hs : (selectedSet Step witness m).card < n := by
        simpa only [hc] using hm
      rw [selectedSet, nextSet, dite_eq_left hs,
        Finset.card_insert_of_notMem ((Classical.choose_spec (witness _ hs)).1),
        hc, Nat.min_eq_left (Nat.succ_le_of_lt hm)]
    Β· have hc : (selectedSet Step witness m).card = n := by
        simpa only [Nat.min_eq_right (Nat.le_of_not_gt hm)] using ih
      have hs : Β¬(selectedSet Step witness m).card < n := by
        rw [hc]
        exact Nat.not_lt.mpr (Nat.le_refl n)
      rw [selectedSet, nextSet, dite_eq_right hs, hc,
        Nat.min_eq_right (Nat.le_trans (Nat.le_of_not_gt hm) (Nat.le_succ m))]

theorem selectedSet_subset_succ {n : Nat}
    (Step : Finset (Fin n) β†’ Fin n β†’ Prop)
    (witness : βˆ€ S, S.card < n β†’ βˆƒ j, j βˆ‰ S ∧ Step S j) (m : Nat) :
    selectedSet Step witness m βŠ† selectedSet Step witness (m + 1) := by
  change selectedSet Step witness m βŠ† nextSet Step witness (selectedSet Step witness m)
  unfold nextSet
  split
  Β· exact Finset.subset_insert _ _
  Β· exact le_rfl

theorem selectedSet_monotone {n : Nat}
    (Step : Finset (Fin n) β†’ Fin n β†’ Prop)
    (witness : βˆ€ S, S.card < n β†’ βˆƒ j, j βˆ‰ S ∧ Step S j) :
    Monotone (selectedSet Step witness) :=
  monotone_nat_of_le_succ (selectedSet_subset_succ Step witness)

theorem selectedSet_univ {n : Nat}
    (Step : Finset (Fin n) β†’ Fin n β†’ Prop)
    (witness : βˆ€ S, S.card < n β†’ βˆƒ j, j βˆ‰ S ∧ Step S j) :
    selectedSet Step witness n = Finset.univ := by
  apply Finset.eq_of_subset_of_card_le (Finset.subset_univ _)
  simp [selectedSet_card]

theorem selectedSet_step {n : Nat}
    (Step : Finset (Fin n) β†’ Fin n β†’ Prop)
    (witness : βˆ€ S, S.card < n β†’ βˆƒ j, j βˆ‰ S ∧ Step S j)
    (m : Nat) (hm : m < n) :
    βˆƒ j, j βˆ‰ selectedSet Step witness m ∧
      selectedSet Step witness (m + 1) = insert j (selectedSet Step witness m) ∧
      Step (selectedSet Step witness m) j := by
  have hc : (selectedSet Step witness m).card = m := by
    rw [selectedSet_card, Nat.min_eq_left (Nat.le_of_lt hm)]
  have hs : (selectedSet Step witness m).card < n := by simpa only [hc] using hm
  let j := Classical.choose (witness (selectedSet Step witness m) hs)
  have hj := Classical.choose_spec (witness (selectedSet Step witness m) hs)
  refine ⟨j, hj.1, ?_, hj.2⟩
  simp only [selectedSet, nextSet, dite_eq_left hs, j]

def SetStep {n : Nat} (P : Finset (Fin n) β†’ ℝ) (v ell : ℝ)
    (S : Finset (Fin n)) (j : Fin n) : Prop :=
  P (insert j S) ≀ P S *
    (v + 15 * Real.sqrt (((S.card : ℝ) * ell + logTwo (1 / P S)) /
      ((n : ℝ) - S.card)))

theorem totalSetStep {n : Nat} (P : Finset (Fin n) β†’ ℝ) (v ell : ℝ)
    (hnonneg : βˆ€ S, 0 ≀ P S) (hanti : Antitone P)
    (hpositive : βˆ€ S, S.card < n β†’ 0 < P S β†’
      βˆƒ j, j βˆ‰ S ∧ SetStep P v ell S j) :
    βˆ€ S, S.card < n β†’ βˆƒ j, j βˆ‰ S ∧ SetStep P v ell S j := by
  intro S hcard
  by_cases hp : 0 < P S
  Β· exact hpositive S hcard hp
  · obtain ⟨j, hj⟩ := exists_unused_inline_SelectionSequence S hcard
    have hz : P S = 0 := le_antisymm (le_of_not_gt hp) (hnonneg S)
    have hnext : P (insert j S) = 0 := le_antisymm
      ((hanti (Finset.subset_insert j S)).trans (le_of_eq hz)) (hnonneg (insert j S))
    refine ⟨j, hj, ?_⟩
    simpa only [SetStep, hnext, hz, zero_mul] using (le_refl (0 : ℝ))

theorem exists_scalar_sequence {n : Nat} (P : Finset (Fin n) β†’ ℝ) (v ell : ℝ)
    (hempty : P βˆ… = 1) (hnonneg : βˆ€ S, 0 ≀ P S) (hanti : Antitone P)
    (hpositive : βˆ€ S, S.card < n β†’ 0 < P S β†’
      βˆƒ j, j βˆ‰ S ∧ SetStep P v ell S j) :
    βˆƒ p : Nat β†’ ℝ, p 0 = 1 ∧ (βˆ€ m, 0 ≀ p m) ∧ Antitone p ∧
      ScalarRecurrence p n v ell ∧ p n = P Finset.univ := by
  let witness := totalSetStep P v ell hnonneg hanti hpositive
  let sets := selectedSet (SetStep P v ell) witness
  let p := fun m => P (sets m)
  refine ⟨p, ?_, ?_, ?_, ?_, ?_⟩
  Β· change P (selectedSet (SetStep P v ell) witness 0) = 1
    simpa only [selectedSet] using hempty
  Β· intro m
    exact hnonneg (sets m)
  Β· intro i j hij
    exact hanti (selectedSet_monotone (SetStep P v ell) witness hij)
  Β· intro m hm
    obtain ⟨j, _, hnext, hbound⟩ :=
      selectedSet_step (SetStep P v ell) witness m hm
    have hc : (selectedSet (SetStep P v ell) witness m).card = m := by
      rw [selectedSet_card, Nat.min_eq_left (Nat.le_of_lt hm)]
    change P (selectedSet (SetStep P v ell) witness (m + 1)) ≀ _
    rw [hnext]
    simpa only [SetStep, hc] using hbound
  Β· change P (selectedSet (SetStep P v ell) witness n) = P Finset.univ
    rw [selectedSet_univ]

open DFVSGames.Foundations.Games

variable {Q₁ Qβ‚‚ A₁ Aβ‚‚ : Type*}
variable [Fintype Q₁] [Fintype Qβ‚‚] [Fintype A₁] [Fintype Aβ‚‚]
variable [Nonempty A₁] [Nonempty Aβ‚‚]

def ConditionalCoordinateBound (G : Game Q₁ Qβ‚‚ A₁ Aβ‚‚) (n : Nat)
    (strategy : Strategy (Fin n β†’ Q₁) (Fin n β†’ Qβ‚‚) (Fin n β†’ A₁) (Fin n β†’ Aβ‚‚))
    (ell : ℝ) : Prop :=
  βˆ€ (S : Finset (Fin n)) (_hcard : S.card < n)
    (hp : 0 < G.selectedSuccess strategy S),
    βˆƒ j, j βˆ‰ S ∧
      (((G.repetition n).questions.condition (G.selectedWins strategy S) hp).probability
        (G.coordinateWin strategy j)) ≀
        G.value + 15 * Real.sqrt
          (((S.card : ℝ) * ell + logTwo (1 / G.selectedSuccess strategy S)) /
            ((n : ℝ) - S.card))

theorem repetition_success_le_of_conditionalCoordinateBound
    (G : Game Q₁ Qβ‚‚ A₁ Aβ‚‚) (n : Nat)
    (strategy : Strategy (Fin n β†’ Q₁) (Fin n β†’ Qβ‚‚) (Fin n β†’ A₁) (Fin n β†’ Aβ‚‚))
    {v ell : ℝ} (hvalue : G.value ≀ v) (hv1 : v < 1) (hell : 1 ≀ ell)
    (hcoordinate : ConditionalCoordinateBound G n strategy ell) :
    (G.repetition n).success strategy ≀
      (1 - (1 - v)^3 / 6000)^((n : ℝ) / ell) := by
  have hpositive : βˆ€ S : Finset (Fin n), S.card < n β†’
      0 < G.selectedSuccess strategy S β†’
      βˆƒ j, j βˆ‰ S ∧ SetStep (G.selectedSuccess strategy) v ell S j := by
    intro S hcard hp
    obtain ⟨j, hj, hbound⟩ := hcoordinate S hcard hp
    refine ⟨j, hj, ?_⟩
    change G.selectedSuccess strategy (insert j S) ≀ _
    rw [G.selectedSuccess_insert strategy S j hp]
    exact mul_le_mul_of_nonneg_left
      (hbound.trans (add_le_add hvalue (le_refl _))) (le_of_lt hp)
  obtain ⟨p, hp0, hpnonneg, hpmono, hrec, hpn⟩ :=
    exists_scalar_sequence (G.selectedSuccess strategy) v ell
      (G.selectedSuccess_empty strategy) (G.selectedSuccess_nonnegative strategy)
      (G.selectedSuccess_antitone strategy) hpositive
  have hbound := scalar_bound_6000 p n
    (G.value_nonnegative.trans hvalue) hv1 hell hp0 hpnonneg hpmono hrec
  rw [hpn, G.selectedSuccess_univ strategy] at hbound
  exact hbound

end DFVSGames.Foundations.Repetition.SelectionSequence

namespace DFVSGames.Foundations.Repetition
open scoped BigOperators
open Games
noncomputable section
variable {Q₁ Qβ‚‚ A₁ Aβ‚‚ : Type*}
  [Fintype Q₁] [Fintype Qβ‚‚] [Fintype A₁] [Fintype Aβ‚‚]
  [Nonempty A₁] [Nonempty Aβ‚‚]
  [DecidableEq Q₁] [DecidableEq Qβ‚‚] {n : Nat}

theorem selected_coordinate_probability_le_value_add_error
    (G : Game Q₁ Qβ‚‚ A₁ Aβ‚‚)
    (strategy : Strategy (Fin n β†’ Q₁) (Fin n β†’ Qβ‚‚) (Fin n β†’ A₁) (Fin n β†’ Aβ‚‚))
    (selected : Finset (Fin n)) (positive : 0 < G.selectedSuccess strategy selected)
    (j : {i : Fin n // i βˆ‰ selected}) :
    ((G.repetition n).questions.condition (G.selectedWins strategy selected) positive).probability
      (G.coordinateWin strategy j.1) ≀
        G.value + selectedEmbeddingError G strategy selected positive j := by
  classical
  let : Nonempty (SelectedCommonData (Q₁ := Q₁) (Qβ‚‚ := Qβ‚‚)
      (A₁ := A₁) (Aβ‚‚ := Aβ‚‚) selected j) :=
    finiteDistribution_nonempty (selectedProfileFallback G strategy selected positive j)
  have h := coordinate_probability_le_value_of_local_completion G j.1 strategy
    (selectedSamplingTarget G strategy selected positive j)
    (selectedLeftProfile G strategy selected positive j)
    (selectedRightProfile G strategy selected positive j)
    (selectedFullLeftCompletion G strategy selected j)
    (selectedFullRightCompletion G strategy selected j)
    (selectedFullLeftCompletion_support G strategy selected j)
    (selectedFullRightCompletion_support G strategy selected j)
    (Classical.choice inferInstance)
  have htarget : (selectedSamplingTarget G strategy selected positive j).mixture
      (fun z => (selectedFullLeftCompletion G strategy selected j (z.1.1,z.2)).product
        (selectedFullRightCompletion G strategy selected j (z.1.2,z.2))) =
      (G.repetition n).questions.condition (G.selectedWins strategy selected) positive :=
    selectedFullCompletionMixture_eq_conditionedQuestions G strategy selected positive j
  rw [htarget, selectedSamplingTarget_left_error, selectedSamplingTarget_right_error] at h
  exact h

theorem holenstein_conditionalCoordinateBound
    (G : Game Q₁ Qβ‚‚ A₁ Aβ‚‚) (n : Nat)
    (strategy : Strategy (Fin n β†’ Q₁) (Fin n β†’ Qβ‚‚) (Fin n β†’ A₁) (Fin n β†’ Aβ‚‚))
    (ell : ℝ)
    (halphabet : logTwo ((Fintype.card A₁ : ℝ) * (Fintype.card Aβ‚‚ : ℝ)) ≀ ell) :
    SelectionSequence.ConditionalCoordinateBound G n strategy ell := by
  intro selected hcard positive
  obtain ⟨j,hj⟩ := exists_coordinate_le_information_budget G strategy selected positive ell
    halphabet hcard (selectedEmbeddingError G strategy selected positive)
    (selectedEmbeddingError_sum_le_fifteen G strategy selected positive)
  exact ⟨j.1,j.property,
    (selected_coordinate_probability_le_value_add_error G strategy selected positive j).trans
      (add_le_add le_rfl hj)⟩

theorem holenstein_repetition_success
    (G : Game Q₁ Qβ‚‚ A₁ Aβ‚‚) (n : Nat)
    (strategy : Strategy (Fin n β†’ Q₁) (Fin n β†’ Qβ‚‚) (Fin n β†’ A₁) (Fin n β†’ Aβ‚‚))
    {v ell : ℝ} (hvalue : G.value ≀ v) (hv : v < 1) (hell : 1 ≀ ell)
    (halphabet : logTwo ((Fintype.card A₁ : ℝ) * (Fintype.card Aβ‚‚ : ℝ)) ≀ ell) :
    (G.repetition n).success strategy ≀
      (1 - (1 - v)^3 / 6000)^((n : ℝ) / ell) :=
  SelectionSequence.repetition_success_le_of_conditionalCoordinateBound G n strategy
    hvalue hv hell (holenstein_conditionalCoordinateBound G n strategy ell halphabet)

theorem holenstein_repetition_value
    (G : Game Q₁ Qβ‚‚ A₁ Aβ‚‚) (n : Nat)
    {v ell : ℝ} (hvalue : G.value ≀ v) (hv : v < 1) (hell : 1 ≀ ell)
    (halphabet : logTwo ((Fintype.card A₁ : ℝ) * (Fintype.card Aβ‚‚ : ℝ)) ≀ ell) :
    (G.repetition n).value ≀
      (1 - (1 - v)^3 / 6000)^((n : ℝ) / ell) := by
  apply ((G.repetition n).value_le_iff _).2
  intro strategy
  exact holenstein_repetition_success G n strategy hvalue hv hell halphabet

end
end DFVSGames.Foundations.Repetition

end OAI