File size: 7,269 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
import Mathlib
import OAI.Computability.MinUncut.Model

namespace OAI

noncomputable section
open scoped BigOperators
open MeasureTheory ProbabilityTheory Filter
open scoped Topology NNReal
open scoped BigOperators
open MeasureTheory ProbabilityTheory Polynomial Filter
open scoped BigOperators Topology
open MeasureTheory ProbabilityTheory WithLp
open scoped BigOperators RealInnerProductSpace
open scoped BigOperators
namespace MinUncut.Box
variable {A : Type*} [Fintype A] [Nonempty A]

def vertex {m : ℕ} (b : Fin m → Bool) (x y : Fin m → A) : Fin m → A :=
  fun i => if b i then x i else y i

def moment {m : ℕ} (f : (Fin m → A) → ℝ) : ℝ :=
  𝔼 x, 𝔼 y, ∏ b : Fin m → Bool, f (vertex b x y)

def correlation {m : ℕ} (f : (Fin m → A) → ℝ)
    (a : Fin m → (Fin m → A) → ℝ) : ℝ :=
  𝔼 x, f x * ∏ i, a i x

def Local {m : ℕ} (a : Fin m → (Fin m → A) → ℝ) : Prop :=
  ∀ i x z, a i (Function.update x i z) = a i x

omit [Nonempty A] in
lemma expect_cons {m : ℕ} (f : (Fin (m+1) → A) → ℝ) :
    (𝔼 x, f x) = 𝔼 z, 𝔼 x, f (Fin.cons z x) := by
  rw [← Finset.expect_product', Finset.univ_product_univ]
  exact Fintype.expect_equiv (Fin.consEquiv (fun _ : Fin (m+1) => A)).symm _ _ (fun x => congrArg f (Fin.cons_self_tail x).symm)

lemma prod_cons {m : ℕ} (f : (Fin (m+1) → Bool) → ℝ) :
    (∏ b, f b) = ∏ z : Bool, ∏ b, f (Fin.cons z b) := by
  rw [← Finset.prod_product' ]
  rw [Finset.univ_product_univ]
  exact Fintype.prod_equiv (Fin.consEquiv (fun _ : Fin (m+1) => Bool)).symm _ _ (fun x => congrArg f (Fin.cons_self_tail x).symm)

omit [Fintype A] [Nonempty A] in
@[simp] lemma vertex_cons {m : ℕ} (b : Bool) (bs : Fin m → Bool)
    (x y : A) (xs ys : Fin m → A) :
    vertex (Fin.cons b bs) (Fin.cons x xs) (Fin.cons y ys) =
      Fin.cons (if b then x else y) (vertex bs xs ys) := by
  ext i
  refine Fin.cases ?_ (fun j => ?_) i <;> simp [vertex]

omit [Nonempty A] in
lemma moment_succ {m : ℕ} (f : (Fin (m+1) → A) → ℝ) :
    moment f = 𝔼 z, 𝔼 w, moment (fun x => f (Fin.cons z x) * f (Fin.cons w x)) := by
  unfold moment
  rw [expect_cons]
  conv_lhs => arg 2; ext z; arg 2; ext x; rw [expect_cons]
  simp_rw [prod_cons, Fintype.prod_bool, vertex_cons]
  simp only [Bool.false_eq_true, ↓reduceIte, Finset.prod_mul_distrib]
  apply Finset.expect_congr rfl
  intro z _
  rw [Finset.expect_comm]

lemma expect_pow_two_pow {T : Type*} [Fintype T] [Nonempty T] (f : T → ℝ) (m : ℕ) :
    (𝔼 t, f t)^(2^m) ≤ 𝔼 t, (f t)^(2^m) := by
  cases m with
  | zero => simp
  | succ m =>
      have he : Even (2^(m+1)) := ⟨2^m, by rw [pow_succ]; omega⟩
      have h := Real.pow_arith_mean_le_arith_mean_pow_of_even Finset.univ
        (fun _ : T => (Fintype.card T : ℝ)⁻¹) f (fun _ _ => by positivity)
        (by simp [Fintype.card_ne_zero]) he
      simpa only [Finset.expect_eq_sum_div_card, Finset.card_univ, ← Finset.mul_sum,
        ← Finset.sum_mul, div_eq_mul_inv, mul_comm] using h

lemma expect_sq_le {T : Type*} [Fintype T] [Nonempty T] (f : T → ℝ) :
    (𝔼 t, f t)^2 ≤ 𝔼 t, (f t)^2 := by
  simpa using expect_pow_two_pow f 1

omit [Fintype A] [Nonempty A] in
lemma face_zero {m : ℕ} (a : Fin (m+1) → (Fin (m+1) → A) → ℝ)
    (ha : Local a) (z w : A) (x : Fin m → A) :
    a 0 (Fin.cons z x) = a 0 (Fin.cons w x) := by
  simpa only [Fin.update_cons_zero] using ha 0 (Fin.cons w x) z

lemma first_step {m : ℕ} (f : (Fin (m+1) → A) → ℝ)
    (a : Fin (m+1) → (Fin (m+1) → A) → ℝ)
    (ha : Local a) (hb : ∀ i x, |a i x| ≤ 1) :
    (correlation f a)^2 ≤ 𝔼 z, 𝔼 w,
      correlation (fun x => f (Fin.cons z x)*f (Fin.cons w x))
        (fun i x => a i.succ (Fin.cons z x)*a i.succ (Fin.cons w x)) := by
  let z₀ := Classical.choice (inferInstance : Nonempty A)
  let g (x : Fin m → A) : ℝ := 𝔼 z, f (Fin.cons z x) * ∏ i : Fin m, a i.succ (Fin.cons z x)
  have hc : correlation f a = 𝔼 x, a 0 (Fin.cons z₀ x) * g x := by
    unfold correlation
    rw [expect_cons, Finset.expect_comm]
    apply Finset.expect_congr rfl
    intro x _
    simp only [Fin.prod_univ_succ]
    simp_rw [face_zero a ha _ z₀ x]
    dsimp [g]
    rw [Finset.mul_expect]
    apply Finset.expect_congr rfl
    intro z _
    ring
  rw [hc]
  calc
    _ ≤ 𝔼 x, (a 0 (Fin.cons z₀ x)*g x)^2 := expect_sq_le _
    _ ≤ 𝔼 x, (g x)^2 := by
      apply Finset.expect_le_expect
      intro x _
      rw [mul_pow]
      have hs : (a 0 (Fin.cons z₀ x))^2 ≤ 1 := by
        nlinarith [sq_abs (a 0 (Fin.cons z₀ x)), hb 0 (Fin.cons z₀ x), abs_nonneg (a 0 (Fin.cons z₀ x))]
      simpa only [one_mul] using mul_le_mul_of_nonneg_right hs (sq_nonneg (g x))
    _ = _ := by
      dsimp [g, correlation]
      simp only [sq, Finset.expect_mul_expect]
      rw [Finset.expect_comm]
      apply Finset.expect_congr rfl
      intro z _
      rw [Finset.expect_comm]
      apply Finset.expect_congr rfl
      intro w _
      apply Finset.expect_congr rfl
      intro x _
      rw [Finset.prod_mul_distrib]
      ring

theorem box_cs (m : ℕ) (f : (Fin m → A) → ℝ)
    (a : Fin m → (Fin m → A) → ℝ) (ha : Local a) (hb : ∀ i x, |a i x|≤1) :
    (correlation f a)^(2^m) ≤ moment f := by
  induction m with
  | zero =>
      have hf : ∀ x : Fin 0 → A, f x = f (fun i => Fin.elim0 i) :=
        fun x => congrArg f (Subsingleton.elim _ _)
      simp [correlation, moment, hf]
  | succ m ih =>
      let g := fun z w (x : Fin m → A) => f (Fin.cons z x)*f (Fin.cons w x)
      let b := fun z w (i : Fin m) (x : Fin m → A) =>
        a i.succ (Fin.cons z x)*a i.succ (Fin.cons w x)
      have h₁ := first_step f a ha hb
      have hlocal (z w : A) : Local (b z w) := by
        intro i x t
        dsimp [b]
        simp only [Fin.cons_update, ha i.succ]
      have hbound (z w : A) (i : Fin m) (x : Fin m → A) : |b z w i x|≤1 := by
        dsimp [b]
        rw [abs_mul]
        simpa using mul_le_mul (hb i.succ (Fin.cons z x)) (hb i.succ (Fin.cons w x))
          (abs_nonneg _) (by norm_num : (0:ℝ)≤1)
      calc
        _ = ((correlation f a)^2)^(2^m) := by rw [← pow_mul, pow_succ]; congr 1; omega
        _ ≤ (𝔼 z, 𝔼 w, correlation (g z w) (b z w))^(2^m) :=
          pow_le_pow_left₀ (sq_nonneg _) h₁ _
        _ ≤ 𝔼 z, (𝔼 w, correlation (g z w) (b z w))^(2^m) := expect_pow_two_pow _ m
        _ ≤ 𝔼 z, 𝔼 w, (correlation (g z w) (b z w))^(2^m) :=
          Finset.expect_le_expect (fun z _ => expect_pow_two_pow _ m)
        _ ≤ 𝔼 z, 𝔼 w, moment (g z w) := by
          apply Finset.expect_le_expect
          intro z _
          apply Finset.expect_le_expect
          intro w _
          exact ih _ _ (hlocal z w) (hbound z w)
        _ = _ := (moment_succ f).symm

lemma abs_correlation_cs {m : ℕ} (hm : 0 < m) (f : (Fin m → A) → ℝ)
    (a : Fin m → (Fin m → A) → ℝ) (ha : Local a) (hb : ∀ i x, |a i x|≤1) :
    |correlation f a|^(2^m) ≤ moment f := by
  have he : Even (2^m) := by
    obtain ⟨k,rfl⟩ := Nat.exists_eq_succ_of_ne_zero (Nat.ne_of_gt hm)
    exact ⟨2^k, by rw [pow_succ]; omega⟩
  simpa only [he.pow_abs] using box_cs m f a ha hb
end MinUncut.Box

end

end OAI