File size: 4,930 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
import OAI.Computability.PerfectCompleteness.Sampling.BucketResamplingLaw
import OAI.Computability.PerfectCompleteness.Sampling.BucketUniformLemmas

namespace OAI


namespace PerfectCompleteness.BucketMatrixResampling

noncomputable section

open scoped Classical
open UniqueGamesTheorem.Foundations.Games
open BucketSampler (F2 Direction Tape)

variable {Ξ© : Type*} (V : Submodule F2 (Ξ© β†’ F2))

abbrev Matrix (β„“ : Nat) := Module.Dual F2 V β†’β‚—[F2] (Fin β„“ β†’ F2)

def assembledMatrix (β„“ : Nat) (t : Tape β„“ V) : Matrix V β„“ :=
  EvaluationMatrix.ofRows V (BucketSampler.evaluate β„“ (id : V β†’ V) t)

theorem assembledMatrix_update (β„“ : Nat) (t : Tape β„“ V)
    (a : Direction β„“) (new : V) :
    assembledMatrix V β„“ (Function.update t a new) =
      EvaluationMatrix.shift V (assembledMatrix V β„“ t) a.val (new - t a) := by
  unfold assembledMatrix
  rw [BucketSampler.evaluate_update]
  apply LinearMap.ext
  intro q
  funext i
  change q (BucketSampler.evaluate β„“ (id : V β†’ V) t i + a.val i β€’ (new - t a)) =
    q (BucketSampler.evaluate β„“ (id : V β†’ V) t i) + q (new - t a) * a.val i
  simp only [map_add, map_smul, smul_eq_mul, mul_comm]

private theorem pushforward_id {A : Type*} [Fintype A] (ΞΌ : FiniteDistribution A) :
    ΞΌ.pushforward (fun a => a) = ΞΌ := by
  apply FiniteDistribution.eq_of_weight_eq
  intro a
  simp [FiniteDistribution.pushforward]


variable (β„“ : Nat) [Fintype V] [Fintype (Matrix V β„“)]

theorem matrix_difference_law (ΞΌ : FiniteDistribution (Tape β„“ V)) (a : Direction β„“) :
    (ΞΌ.product (FiniteDistribution.uniform V)).pushforward
        (fun p => (assembledMatrix V β„“ p.1, p.2 - p.1 a)) =
      (ΞΌ.pushforward (assembledMatrix V β„“)).product (FiniteDistribution.uniform V) := by
  rw [UniformDifference.observed_difference_law ΞΌ (fun t => t a)
    (assembledMatrix V β„“)]
  have hp := FiniteDistribution.product_pushforward ΞΌ
    (FiniteDistribution.uniform V) (assembledMatrix V β„“) (id : V β†’ V)
  have hi : (FiniteDistribution.uniform V).pushforward (id : V β†’ V) =
      FiniteDistribution.uniform V :=
    pushforward_id (FiniteDistribution.uniform V)
  rw [hi] at hp
  simpa only [id_eq] using hp

theorem resampled_matrix_pair_law (ΞΌ : FiniteDistribution (Tape β„“ V)) (a : Direction β„“) :
    (ΞΌ.product (FiniteDistribution.uniform V)).pushforward
        (fun p => (assembledMatrix V β„“ p.1,
          assembledMatrix V β„“ (Function.update p.1 a p.2))) =
      ((ΞΌ.pushforward (assembledMatrix V β„“)).product (FiniteDistribution.uniform V)).pushforward
        (fun p => (p.1, EvaluationMatrix.shift V p.1 a.val p.2)) := by
  have h := congrArg
    (fun Ξ½ : FiniteDistribution (Matrix V β„“ Γ— V) => Ξ½.pushforward
      (fun p => (p.1, EvaluationMatrix.shift V p.1 a.val p.2)))
    (matrix_difference_law V β„“ ΞΌ a)
  rw [FiniteDistribution.pushforward_comp] at h
  simpa only [assembledMatrix_update] using h

variable [FiniteDimensional F2 V]

theorem uniform_assembledMatrix_law :
    (BucketSampler.tapeLaw β„“ (FiniteDistribution.uniform V)).pushforward
        (assembledMatrix V β„“) = FiniteDistribution.uniform (Matrix V β„“) :=
  BucketUniform.uniform_matrix_law V β„“

theorem uniform_matrix_difference_law (a : Direction β„“) :
    ((BucketSampler.tapeLaw β„“ (FiniteDistribution.uniform V)).product
        (FiniteDistribution.uniform V)).pushforward
        (fun p => (assembledMatrix V β„“ p.1, p.2 - p.1 a)) =
      (FiniteDistribution.uniform (Matrix V β„“)).product (FiniteDistribution.uniform V) := by
  rw [matrix_difference_law, uniform_assembledMatrix_law]

theorem uniform_resampled_matrix_pair_law (a : Direction β„“) :
    ((BucketSampler.tapeLaw β„“ (FiniteDistribution.uniform V)).product
        (FiniteDistribution.uniform V)).pushforward
        (fun p => (assembledMatrix V β„“ p.1,
          assembledMatrix V β„“ (Function.update p.1 a p.2))) =
      ((FiniteDistribution.uniform (Matrix V β„“)).product
        (FiniteDistribution.uniform V)).pushforward
          (fun p => (p.1, EvaluationMatrix.shift V p.1 a.val p.2)) := by
  rw [resampled_matrix_pair_law, uniform_assembledMatrix_law]

theorem uniform_resampled_event_probability (a : Direction β„“)
    (event : Matrix V β„“ Γ— Matrix V β„“ β†’ Bool) :
    ((BucketSampler.tapeLaw β„“ (FiniteDistribution.uniform V)).product
        (FiniteDistribution.uniform V)).probability
        (fun p => event (assembledMatrix V β„“ p.1,
          assembledMatrix V β„“ (Function.update p.1 a p.2))) =
      ((FiniteDistribution.uniform (Matrix V β„“)).product
        (FiniteDistribution.uniform V)).probability
          (fun p => event (p.1, EvaluationMatrix.shift V p.1 a.val p.2)) := by
  have h := congrArg (fun Ξ½ => FiniteDistribution.probability Ξ½ event)
    (uniform_resampled_matrix_pair_law V β„“ a)
  simpa only [FiniteDistribution.probability_pushforward] using h

end
end PerfectCompleteness.BucketMatrixResampling

end OAI