math / data /lean /OAI /Probability /Ising /GibbsMeasure.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
6.76 kB
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