File size: 2,730 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
import Mathlib

namespace OAI

noncomputable section
open scoped BigOperators
open MeasureTheory ProbabilityTheory Filter

namespace SKGap

abbrev Spin (n : β„•) := Fin n β†’ Bool
abbrev Edge (n : β„•) := {p : Fin n Γ— Fin n // p.1 < p.2}
abbrev Disorder (n : β„•) := Edge n β†’ ℝ

def spinValue (b : Bool) : ℝ := if b then 1 else -1

def coupling {n : β„•} (g : Disorder n) (i k : Fin n) : ℝ :=
  if h : i < k then g ⟨(i, k), h⟩ else
    if h : k < i then g ⟨(k, i), h⟩ else 0

def hamiltonian {n : β„•} (g : Disorder n) (h : Fin n β†’ ℝ) (x : Spin n) : ℝ :=
  (1 / 2 : ℝ) * βˆ‘ i, βˆ‘ k, spinValue (x i) * coupling g i k * spinValue (x k) +
    βˆ‘ i, h i * spinValue (x i)

def weight {n : β„•} (g : Disorder n) (h : Fin n β†’ ℝ) (x : Spin n) : ℝ :=
  Real.exp (hamiltonian g h x)

def partition {n : β„•} (g : Disorder n) (h : Fin n β†’ ℝ) : ℝ :=
  βˆ‘ x, weight g h x

def mass {n : β„•} (g : Disorder n) (h : Fin n β†’ ℝ) (x : Spin n) : ℝ :=
  weight g h x / partition g h

def expectation {n : β„•} (g : Disorder n) (h : Fin n β†’ ℝ) (f : Spin n β†’ ℝ) : ℝ :=
  βˆ‘ x, mass g h x * f x

def variance {n : β„•} (g : Disorder n) (h : Fin n β†’ ℝ) (f : Spin n β†’ ℝ) : ℝ :=
  expectation g h (fun x => (f x - expectation g h f) ^ 2)

def flip {n : β„•} (i : Fin n) (x : Spin n) : Spin n :=
  Function.update x i (!(x i))

/-- Conditional expectation under the actual Gibbs law given all other spins. -/
def conditionalExpectation {n : β„•} (g : Disorder n) (h : Fin n β†’ ℝ)
    (i : Fin n) (f : Spin n β†’ ℝ) (x : Spin n) : ℝ :=
  (weight g h x * f x + weight g h (flip i x) * f (flip i x)) /
    (weight g h x + weight g h (flip i x))

/-- Unscaled form: each site has a rate-one clock. -/
def dirichlet {n : β„•} (g : Disorder n) (h : Fin n β†’ ℝ) (f : Spin n β†’ ℝ) : ℝ :=
  βˆ‘ i, expectation g h (fun x => (f x - conditionalExpectation g h i f x) ^ 2)

def disorderLaw (Ξ² : ℝ) (n : β„•) : Measure (Disorder n) :=
  Measure.pi (fun _ : Edge n => gaussianReal 0 (Real.toNNReal (Ξ² ^ 2 / n)))

def poincareEvent (n : β„•) (C : ℝ) : Set (Disorder n) :=
  {g | βˆ€ f : Spin n β†’ ℝ, variance g 0 f ≀ C * dirichlet g 0 f}

/-- Rayleigh quotient definition of the uniform-site discrete heat-bath gap. -/
def discreteGap {n : β„•} (g : Disorder n) : ℝ :=
  sInf {r : ℝ | βˆƒ f : Spin n β†’ ℝ, 0 < variance g 0 f ∧
    r = dirichlet g 0 f / ((n : ℝ) * variance g 0 f)}

def MainStatement (Ξ² : ℝ) : Prop :=
  βˆƒ C : ℝ, 0 < C ∧
    Tendsto (fun n : β„• => disorderLaw Ξ² n (poincareEvent n C)) atTop (nhds 1) ∧
    Tendsto (fun n : β„• => disorderLaw Ξ² n {g | 1 / (C * (n : ℝ)) ≀ discreteGap g})
      atTop (nhds 1)

end SKGap
end

end OAI