File size: 6,763 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
import Mathlib

namespace OAI

open scoped BigOperators Classical

namespace BufferedIsing.DSS

noncomputable section

variable {V : Type*} [Fintype V]

/-- Directed pair couplings. Both directions are counted; diagonal terms are constants.
This intermediate presentation allows exact restriction without re-enumerating edges. -/
def sgn (b : Bool) : ℝ := if b then 1 else -1

def hamiltonian (J : V β†’ V β†’ ℝ) (h : V β†’ ℝ) (Οƒ : V β†’ Bool) : ℝ :=
  (βˆ‘ u, βˆ‘ v, J u v * sgn (Οƒ u) * sgn (Οƒ v)) + βˆ‘ u, h u * sgn (Οƒ u)

def mass (J : V β†’ V β†’ ℝ) (h : V β†’ ℝ) (Οƒ : V β†’ Bool) : ℝ :=
  Real.exp (hamiltonian J h Οƒ)

def part (J : V β†’ V β†’ ℝ) (h : V β†’ ℝ) : ℝ := βˆ‘ Οƒ, mass J h Οƒ

def average (J : V β†’ V β†’ ℝ) (h : V β†’ ℝ) (f : (V β†’ Bool) β†’ ℝ) : ℝ :=
  (βˆ‘ Οƒ, mass J h Οƒ * f Οƒ) / part J h

def mean (J : V β†’ V β†’ ℝ) (h : V β†’ ℝ) (v : V) : ℝ :=
  average J h (fun Οƒ => sgn (Οƒ v))

lemma mass_pos (J : V β†’ V β†’ ℝ) (h : V β†’ ℝ) (Οƒ : V β†’ Bool) : 0 < mass J h Οƒ :=
  Real.exp_pos _

lemma part_pos (J : V β†’ V β†’ ℝ) (h : V β†’ ℝ) : 0 < part J h := by
  classical
  exact Finset.sum_pos (fun Οƒ _ => mass_pos J h Οƒ) Finset.univ_nonempty

lemma sgn_neg (b : Bool) : sgn (!b) = -sgn b := by cases b <;> norm_num [sgn]
lemma sgn_sq (b : Bool) : sgn b * sgn b = 1 := by cases b <;> norm_num [sgn]
lemma sgn_le_one (b : Bool) : sgn b ≀ 1 := by cases b <;> norm_num [sgn]
lemma neg_one_le_sgn (b : Bool) : -1 ≀ sgn b := by cases b <;> norm_num [sgn]
lemma sgn_mono : Monotone sgn := by
  intro a b hab
  cases a <;> cases b <;> norm_num [sgn] at *
  exact (by decide : Β¬ (true : Bool) ≀ false) hab

lemma average_add (J : V β†’ V β†’ ℝ) (h : V β†’ ℝ) (f g : (V β†’ Bool) β†’ ℝ) :
    average J h (fun Οƒ => f Οƒ + g Οƒ) = average J h f + average J h g := by
  simp [average, mul_add, Finset.sum_add_distrib, add_div]

lemma average_sub (J : V β†’ V β†’ ℝ) (h : V β†’ ℝ) (f g : (V β†’ Bool) β†’ ℝ) :
    average J h (fun Οƒ => f Οƒ - g Οƒ) = average J h f - average J h g := by
  simp [average, mul_sub, Finset.sum_sub_distrib, sub_div]

lemma average_const (J : V β†’ V β†’ ℝ) (h : V β†’ ℝ) (c : ℝ) :
    average J h (fun _ => c) = c := by
  unfold average
  rw [← Finset.sum_mul]
  exact mul_div_cancel_leftβ‚€ c (part_pos J h).ne'

lemma mean_lt_one (J : V β†’ V β†’ ℝ) (h : V β†’ ℝ) (v : V) : mean J h v < 1 := by
  classical
  rw [mean, average, div_lt_one (part_pos J h)]
  apply Finset.sum_lt_sum
  Β· intro Οƒ _
    exact mul_le_of_le_one_right (mass_pos J h Οƒ).le (sgn_le_one _)
  · refine ⟨fun _ => false, Finset.mem_univ _, ?_⟩
    simp only [sgn, Bool.false_eq_true, ↓reduceIte]
    nlinarith [mass_pos J h (fun _ => false)]

lemma neg_one_lt_mean (J : V β†’ V β†’ ℝ) (h : V β†’ ℝ) (v : V) : -1 < mean J h v := by
  classical
  rw [mean, average, lt_div_iffβ‚€ (part_pos J h)]
  rw [part, Finset.mul_sum]
  apply Finset.sum_lt_sum
  Β· intro Οƒ _
    nlinarith [neg_one_le_sgn (Οƒ v), mass_pos J h Οƒ]
  · refine ⟨fun _ => true, Finset.mem_univ _, ?_⟩
    simp only [sgn, ↓reduceIte]
    nlinarith [mass_pos J h (fun _ => true)]

lemma sgn_modular (a b : Bool) : sgn a + sgn b = sgn (a βŠ“ b) + sgn (a βŠ” b) := by
  cases a <;> cases b <;> norm_num [sgn]

lemma sgn_product_supermodular (a b c d : Bool) :
    sgn a * sgn b + sgn c * sgn d ≀
      sgn (a βŠ“ c) * sgn (b βŠ“ d) + sgn (a βŠ” c) * sgn (b βŠ” d) := by
  cases a <;> cases b <;> cases c <;> cases d <;> norm_num [sgn]

lemma mass_lattice (J : V β†’ V β†’ ℝ) (hJ : βˆ€ u v, 0 ≀ J u v) (h : V β†’ ℝ)
    (Οƒ Ο„ : V β†’ Bool) : mass J h Οƒ * mass J h Ο„ ≀ mass J h (Οƒ βŠ“ Ο„) * mass J h (Οƒ βŠ” Ο„) := by
  rw [mass, mass, mass, mass, ← Real.exp_add, ← Real.exp_add, Real.exp_le_exp]
  have he : (βˆ‘ u, βˆ‘ v, (J u v * sgn (Οƒ u) * sgn (Οƒ v) +
      J u v * sgn (Ο„ u) * sgn (Ο„ v))) ≀
      βˆ‘ u, βˆ‘ v, (J u v * sgn ((Οƒ βŠ“ Ο„) u) * sgn ((Οƒ βŠ“ Ο„) v) +
      J u v * sgn ((Οƒ βŠ” Ο„) u) * sgn ((Οƒ βŠ” Ο„) v)) := by
    apply Finset.sum_le_sum
    intro u _
    apply Finset.sum_le_sum
    intro v _
    have := mul_le_mul_of_nonneg_left
      (sgn_product_supermodular (Οƒ u) (Οƒ v) (Ο„ u) (Ο„ v)) (hJ u v)
    simpa only [Pi.inf_apply, Pi.sup_apply, mul_add, mul_assoc] using this
  have hf : (βˆ‘ v, (h v * sgn (Οƒ v) + h v * sgn (Ο„ v))) =
      βˆ‘ v, (h v * sgn ((Οƒ βŠ“ Ο„) v) + h v * sgn ((Οƒ βŠ” Ο„) v)) := by
    apply Finset.sum_congr rfl
    intro v _
    simpa only [Pi.inf_apply, Pi.sup_apply, mul_add] using
      congrArg (fun x => h v * x) (sgn_modular (Οƒ v) (Ο„ v))
  simp only [Finset.sum_add_distrib] at he hf
  dsimp at he hf
  dsimp [hamiltonian]
  linarith

lemma hamiltonian_field_add (J : V β†’ V β†’ ℝ) (h k : V β†’ ℝ) (Οƒ : V β†’ Bool) :
    hamiltonian J (h + k) Οƒ = hamiltonian J h Οƒ + βˆ‘ v, k v * sgn (Οƒ v) := by
  simp only [hamiltonian, Pi.add_apply, add_mul, Finset.sum_add_distrib]
  ring

lemma mass_field_add (J : V β†’ V β†’ ℝ) (h k : V β†’ ℝ) (Οƒ : V β†’ Bool) :
    mass J (h + k) Οƒ = mass J h Οƒ * Real.exp (βˆ‘ v, k v * sgn (Οƒ v)) := by
  simp only [mass, hamiltonian_field_add, Real.exp_add]

lemma mean_mono (J : V β†’ V β†’ ℝ) (hJ : βˆ€ u v, 0 ≀ J u v)
    (h k : V β†’ ℝ) (hhk : h ≀ k) (o : V) : mean J h o ≀ mean J k o := by
  classical
  let w := mass J h
  let r : (V β†’ Bool) β†’ ℝ := fun Οƒ => Real.exp (βˆ‘ v, (k v - h v) * sgn (Οƒ v))
  let f : (V β†’ Bool) β†’ ℝ := fun Οƒ => sgn (Οƒ o) + 1
  have hf0 : βˆ€ Οƒ, 0 ≀ f Οƒ := fun Οƒ => by dsimp [f]; linarith [neg_one_le_sgn (Οƒ o)]
  have hf : Monotone f := fun Οƒ Ο„ hστ => by
    dsimp [f]
    linarith [sgn_mono (hστ o)]
  have hr : Monotone r := by
    intro Οƒ Ο„ hστ
    apply Real.exp_le_exp.mpr
    apply Finset.sum_le_sum
    intro v _
    exact mul_le_mul_of_nonneg_left (sgn_mono (hστ v)) (sub_nonneg.mpr (hhk v))
  have H := fkg f r w (fun Οƒ => (mass_pos J h Οƒ).le) hf0
    (fun Οƒ => (Real.exp_pos _).le) hf hr (mass_lattice J hJ h)
  have hw : βˆ€ Οƒ, mass J k Οƒ = w Οƒ * r Οƒ := by
    intro Οƒ
    have hk : k = h + (k - h) := by ext v; simp
    conv_lhs => rw [hk, mass_field_add]
    rfl
  have hz : (βˆ‘ Οƒ, w Οƒ * r Οƒ) = part J k := by simp_rw [← hw]; rfl
  have H' : average J h f ≀ average J k f := by
    rw [average, average, div_le_div_iffβ‚€ (part_pos J h) (part_pos J k)]
    rw [← hz]
    have hn : (βˆ‘ Οƒ, mass J k Οƒ * f Οƒ) = βˆ‘ Οƒ, w Οƒ * (f Οƒ * r Οƒ) := by
      apply Finset.sum_congr rfl
      intro Οƒ _
      rw [hw]
      ring
    rw [hn]
    simpa only [w, part, mul_comm] using H
  dsimp [f] at H'
  rw [average_add, average_add, average_const, average_const] at H'
  exact (add_le_add_iff_right 1).mp H'

end

end BufferedIsing.DSS

end OAI