File size: 10,833 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
import OAI.Computability.PerfectCompleteness.Decoding.FixedStoppedDecoderContext
import OAI.Computability.PerfectCompleteness.Sampling.CandidateCoupling

namespace OAI

section

namespace PerfectCompleteness.FixedStoppedDirections

noncomputable section

open scoped Classical
open RecursiveSpaces DescendantSpaces TreeSourceSpaces HierarchicalArrays
open UniqueGamesTheorem.Foundations.Games
open UniqueGamesTheorem.Appendix.RankLevelFilter (linearMapFintype)

attribute [local instance] linearMapFintype

variable {δ : ℚ} {hδ : 0 < δ} (parameters : FixedParameters.Parameters δ hδ)
  (i j : Fin parameters.plan.depth) (hij : i < j)

abbrev lowerNode (pref : FixedStoppedDecoderContext.Prefixes parameters i j) :=
  HierarchicalLeftDecoder.LowerNode (FixedStoppedDecoderContext.upper parameters i j pref)
    (i.val + 1) (FixedStoppedDecoderContext.lower parameters i j hij pref)

@[simp] theorem lowerNode_height (pref : FixedStoppedDecoderContext.Prefixes parameters i j) :
    Nodes.height (lowerNode parameters i j hij pref) = i.val + 1 :=
  CleanDecoderContext.lowerHeight (FixedStoppedDecoderContext.upper parameters i j pref)
    (FixedStoppedDecoderContext.lower parameters i j hij pref)

abbrev LowerDirection (pref : FixedStoppedDecoderContext.Prefixes parameters i j) :=
  BucketSampler.Direction
    (FixedRows.rows parameters.plan (Nodes.height (lowerNode parameters i j hij pref)))

instance lowerDirectionNonempty (pref : FixedStoppedDecoderContext.Prefixes parameters i j) :
    Nonempty (LowerDirection parameters i j hij pref) :=
  PreliminarySampler.directionNonempty _ (by
    rw [lowerNode_height]
    exact parameters.plan.rows_pos (parameters.plan.depth - (i.val + 1)))

def lowerDirectionEquiv (pref : FixedStoppedDecoderContext.Prefixes parameters i j) :
    PrefixTests.LevelDirection (FixedRows.rows parameters.plan) i ≃
      LowerDirection parameters i j hij pref :=
  (Equiv.cast (congrArg (fun height =>
    BucketSampler.Direction (FixedRows.rows parameters.plan height))
      (lowerNode_height parameters i j hij pref))).symm

def lowerDirection (pref : FixedStoppedDecoderContext.Prefixes parameters i j)
    (directions : FixedStoppedDecoderContext.Directions parameters) :
    LowerDirection parameters i j hij pref :=
  PrefixTests.nodeDirection (FixedRows.rows parameters.plan) i
    ⟨lowerNode parameters i j hij pref, lowerNode_height parameters i j hij pref⟩ (directions i)

theorem lowerDirection_eq_equiv (pref : FixedStoppedDecoderContext.Prefixes parameters i j)
    (directions : FixedStoppedDecoderContext.Directions parameters) :
    lowerDirection parameters i j hij pref directions =
      lowerDirectionEquiv parameters i j hij pref (directions i) := rfl

def lowerLaw (pref : FixedStoppedDecoderContext.Prefixes parameters i j) :
    FiniteDistribution (LowerDirection parameters i j hij pref) :=
  FiniteDistribution.uniform _

theorem coordinate_law (level : Fin parameters.plan.depth) :
    (FixedStoppedDecoderContext.directionLaw parameters).pushforward
        (fun directions => directions level) =
      CanonicalDirections.levelLaw (FixedRows.rows parameters.plan)
        (fun k => parameters.plan.rows_pos (parameters.plan.depth - (k + 1))) level :=
  FiniteProduct.eval_pushforward
    (CanonicalDirections.levelLaw (FixedRows.rows parameters.plan)
      (fun k => parameters.plan.rows_pos (parameters.plan.depth - (k + 1)))) level

theorem lowerDirection_law (pref : FixedStoppedDecoderContext.Prefixes parameters i j) :
    (FixedStoppedDecoderContext.directionLaw parameters).pushforward
        (lowerDirection parameters i j hij pref) = lowerLaw parameters i j hij pref := by
  let : Nonempty (PrefixTests.LevelDirection (FixedRows.rows parameters.plan) i) :=
    PreliminarySampler.directionNonempty _
      (parameters.plan.rows_pos (parameters.plan.depth - (i.val + 1)))
  change (FixedStoppedDecoderContext.directionLaw parameters).pushforward
    (fun directions => lowerDirectionEquiv parameters i j hij pref (directions i)) = _
  rw [← FiniteDistribution.pushforward_comp (FixedStoppedDecoderContext.directionLaw parameters)
    (fun directions => directions i) (lowerDirectionEquiv parameters i j hij pref), coordinate_law]
  change (FiniteDistribution.uniform (PrefixTests.LevelDirection (FixedRows.rows parameters.plan) i)).pushforward
    (lowerDirectionEquiv parameters i j hij pref) =
      FiniteDistribution.uniform (LowerDirection parameters i j hij pref)
  rw [← FiniteDistribution.transport_eq_pushforward]
  exact UniformConditioning.uniform_transport (lowerDirectionEquiv parameters i j hij pref)

theorem lowerDirection_expectation (pref : FixedStoppedDecoderContext.Prefixes parameters i j)
    (f : LowerDirection parameters i j hij pref → ℝ) :
    (FixedStoppedDecoderContext.directionLaw parameters).expectation
        (fun directions => f (lowerDirection parameters i j hij pref directions)) =
      (lowerLaw parameters i j hij pref).expectation f := by
  rw [← lowerDirection_law, FiniteDistribution.expectation_pushforward]

variable (input : List Bool)

theorem direction_eq (context : FixedStoppedDecoderContext.Context parameters i j hij input) :
    FixedStoppedDecoderContext.direction parameters i j hij input context =
      (lowerDirection parameters i j hij context.1 context.2.2.2.1).val := rfl

theorem expectation_coordinate
    (f : (pref : FixedStoppedDecoderContext.Prefixes parameters i j) →
      (external : FixedStoppedDecoderContext.OutsideQuestions parameters i j hij input pref) →
      FixedStoppedDecoderContext.Advice parameters i j pref →
      FixedStoppedDecoderContext.Exterior parameters i j hij input pref external →
      PrefixTests.LevelDirection (FixedRows.rows parameters.plan) i → ℝ) :
    (FixedStoppedDecoderContext.law parameters i j hij input).expectation (fun context =>
      f context.1 context.2.1 context.2.2.1 context.2.2.2.2 (context.2.2.2.1 i)) =
    (FixedStoppedDecoderContext.prefixLaw parameters i j hij).expectation (fun pref =>
      (FiniteDistribution.uniform
        (FixedStoppedDecoderContext.OutsideQuestions parameters i j hij input pref)).expectation
          (fun external =>
        (FiniteDistribution.uniform (FixedStoppedDecoderContext.Advice parameters i j pref)).expectation
          (fun A =>
          (FiniteDistribution.uniform
            (FixedStoppedDecoderContext.Exterior parameters i j hij input pref external)).expectation
              (fun exterior =>
            (CanonicalDirections.levelLaw (FixedRows.rows parameters.plan)
              (fun k => parameters.plan.rows_pos (parameters.plan.depth - (k + 1))) i).expectation
                (fun direction => f pref external A exterior direction))))) := by
  rw [FixedStoppedDecoderContext.law, CandidateCoupling.expectation_sigmaLaw]
  apply FiniteDistribution.expectation_congr
  intro pref
  rw [CandidateCoupling.expectation_sigmaLaw]
  apply FiniteDistribution.expectation_congr
  intro external
  rw [FixedStoppedDecoderContext.fiberLaw, FiniteDistribution.expectation_product]
  apply FiniteDistribution.expectation_congr
  intro A
  rw [FiniteDistribution.expectation_product, FiniteDistribution.expectation_comm]
  apply FiniteDistribution.expectation_congr
  intro exterior
  rw [← coordinate_law parameters i, FiniteDistribution.expectation_pushforward]

theorem expectation_lowerDirection
    (f : (pref : FixedStoppedDecoderContext.Prefixes parameters i j) →
      (external : FixedStoppedDecoderContext.OutsideQuestions parameters i j hij input pref) →
      FixedStoppedDecoderContext.Advice parameters i j pref →
      FixedStoppedDecoderContext.Exterior parameters i j hij input pref external →
      LowerDirection parameters i j hij pref → ℝ) :
    (FixedStoppedDecoderContext.law parameters i j hij input).expectation (fun context =>
      f context.1 context.2.1 context.2.2.1 context.2.2.2.2
        (lowerDirection parameters i j hij context.1 context.2.2.2.1)) =
    (FixedStoppedDecoderContext.prefixLaw parameters i j hij).expectation (fun pref =>
      (FiniteDistribution.uniform
        (FixedStoppedDecoderContext.OutsideQuestions parameters i j hij input pref)).expectation
          (fun external =>
        (FiniteDistribution.uniform (FixedStoppedDecoderContext.Advice parameters i j pref)).expectation
          (fun A =>
          (FiniteDistribution.uniform
            (FixedStoppedDecoderContext.Exterior parameters i j hij input pref external)).expectation
              (fun exterior =>
            (lowerLaw parameters i j hij pref).expectation
              (fun direction => f pref external A exterior direction))))) := by
  rw [FixedStoppedDecoderContext.law, CandidateCoupling.expectation_sigmaLaw]
  apply FiniteDistribution.expectation_congr
  intro pref
  rw [CandidateCoupling.expectation_sigmaLaw]
  apply FiniteDistribution.expectation_congr
  intro external
  rw [FixedStoppedDecoderContext.fiberLaw, FiniteDistribution.expectation_product]
  apply FiniteDistribution.expectation_congr
  intro A
  rw [FiniteDistribution.expectation_product, FiniteDistribution.expectation_comm]
  apply FiniteDistribution.expectation_congr
  intro exterior
  exact lowerDirection_expectation parameters i j hij pref (f pref external A exterior)

theorem expectation_direction
    (f : (pref : FixedStoppedDecoderContext.Prefixes parameters i j) →
      (external : FixedStoppedDecoderContext.OutsideQuestions parameters i j hij input pref) →
      FixedStoppedDecoderContext.Advice parameters i j pref →
      FixedStoppedDecoderContext.Exterior parameters i j hij input pref external →
      Block (FixedRows.rows parameters.plan) (lowerNode parameters i j hij pref) → ℝ) :
    (FixedStoppedDecoderContext.law parameters i j hij input).expectation (fun context =>
      f context.1 context.2.1 context.2.2.1 context.2.2.2.2
        (FixedStoppedDecoderContext.direction parameters i j hij input context)) =
    (FixedStoppedDecoderContext.prefixLaw parameters i j hij).expectation (fun pref =>
      (FiniteDistribution.uniform
        (FixedStoppedDecoderContext.OutsideQuestions parameters i j hij input pref)).expectation
          (fun external =>
        (FiniteDistribution.uniform (FixedStoppedDecoderContext.Advice parameters i j pref)).expectation
          (fun A =>
          (FiniteDistribution.uniform
            (FixedStoppedDecoderContext.Exterior parameters i j hij input pref external)).expectation
              (fun exterior =>
            (lowerLaw parameters i j hij pref).expectation
              (fun direction => f pref external A exterior direction.val))))) :=
  expectation_lowerDirection parameters i j hij input
    (fun pref external A exterior direction => f pref external A exterior direction.val)

end
end PerfectCompleteness.FixedStoppedDirections

end

end OAI