Random currents and the switching lemma
AbbreviationCurrent: a multiplicity in \(\mathbb{N}\) for each unordered pair#✓fully proved
A current on the edges of V: a multiplicity n_e ∈ ℕ for every unordered pair e.
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
Used by 35
DefinitionIncident flux of a current at a vertex#✓fully proved
The total multiplicity ∑_{e ∋ x} n_e of the edges of G incident to x.
noncomputable def incidentFlux (n : Current V) (x : V) : ℕ :=
∑ e ∈ G.edgeFinset.filter (fun e => x ∈ e), n e
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:69
Uses 1 · Used by 8
DefinitionSources of a current#✓fully proved
The sources ∂n: the vertices with odd incident flux.
noncomputable def sources (n : Current V) : Finset V :=
Finset.univ.filter (fun x => Odd (incidentFlux G n x))
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:69
noncomputable def incidentFlux (n : Current V) (x : V) : ℕ :=
∑ e ∈ G.edgeFinset.filter (fun e => x ∈ e), n e
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:72
Uses 2 · Used by 19
DefinitionWeight of a random current#✓fully proved
The current weight w(n) = ∏_{e ∈ E(G)} (βJ_e)^{n_e}/n_e!.
noncomputable def weight (β : ℝ) (J : Sym2 V → ℝ) (n : Current V) : ℝ :=
∏ e ∈ G.edgeFinset, (β * J e) ^ (n e) / (Nat.factorial (n e))
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:69
Uses 1 · Used by 19
LemmaCurrent weights are nonnegative for nonnegative \(\beta\) and couplings#✓fully proved
Current weights are nonnegative for β ≥ 0 and nonnegative couplings.
lemma weight_nonneg (β : ℝ) (J : Sym2 V → ℝ) (hβ : 0 ≤ β) (hJ : ∀ e, 0 ≤ J e)
(n : Current V) : 0 ≤ weight G β J n
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:69
noncomputable def weight (β : ℝ) (J : Sym2 V → ℝ) (n : Current V) : ℝ :=
∏ e ∈ G.edgeFinset, (β * J e) ^ (n e) / (Nat.factorial (n e))
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:85
DefinitionSubgraph of edges carrying positive current#✓fully proved
The subgraph of G of edges with n_e ≥ 1.
def currentSubgraph (n : Current V) : SimpleGraph V where
Adj x y := G.Adj x y ∧ 1 ≤ n s(x, y)
symm := by
constructor
intro x y ⟨hadj, hpos⟩
exact ⟨hadj.symm, by rwa [Sym2.eq_swap]⟩
loopless := ⟨fun x ⟨hadj, _⟩ => hadj.ne rfl⟩
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:69
Uses 1 · Used by 6
DefinitionConnectivity through edges carrying positive current#✓fully proved
x and y are joined by a path of edges carrying positive current.
def CurrentConnected (n : Current V) (x y : V) : Prop :=
(currentSubgraph G n).Reachable x y
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:69
def currentSubgraph (n : Current V) : SimpleGraph V where
Adj x y := G.Adj x y ∧ 1 ≤ n s(x, y)
symm := by
constructor
intro x y ⟨hadj, hpos⟩
exact ⟨hadj.symm, by rwa [Sym2.eq_swap]⟩
loopless := ⟨fun x ⟨hadj, _⟩ => hadj.ne rfl⟩
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:105
Uses 2 · Used by 8
DefinitionSubgraph of edges with odd current#✓fully proved
The subgraph of G of edges with odd multiplicity.
def oddSubgraph (n : Current V) : SimpleGraph V where
Adj x y := G.Adj x y ∧ Odd (n s(x, y))
symm := by
constructor
intro x y ⟨hadj, hodd⟩
exact ⟨hadj.symm, by rwa [Sym2.eq_swap]⟩
loopless := ⟨fun x ⟨hadj, _⟩ => hadj.ne rfl⟩
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:69
Uses 1 · Used by 4
AbbreviationBackbone paths along odd-current edges#✓fully proved
Backbone paths from x to y: paths in the subgraph of odd edges.
abbrev IsBackbonePath (n : Current V) (x y : V) : Type _ :=
(oddSubgraph G n).Path x y
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:69
def oddSubgraph (n : Current V) : SimpleGraph V where
Adj x y := G.Adj x y ∧ Odd (n s(x, y))
symm := by
constructor
intro x y ⟨hadj, hodd⟩
exact ⟨hadj.symm, by rwa [Sym2.eq_swap]⟩
loopless := ⟨fun x ⟨hadj, _⟩ => hadj.ne rfl⟩
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:150
Uses 2 · Used by 3
DefinitionCanonical backbone path of a current#✓fully proved
A canonical backbone path: the least one for a given linear order on backbone paths.
noncomputable def backbone (n : Current V) (x y : V)
[LinearOrder (IsBackbonePath G n x y)]
(h : Nonempty (IsBackbonePath G n x y)) : IsBackbonePath G n x y :=
(Finset.univ : Finset (IsBackbonePath G n x y)).min'
(Finset.univ_nonempty_iff.mpr h)
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:69
abbrev IsBackbonePath (n : Current V) (x y : V) : Type _ :=
(oddSubgraph G n).Path x y
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:179
DefinitionTrace of a current as a bond configuration#✓fully proved
The trace of a current: the bond configuration with e open iff n_e ≥ 1.
def percolationField (n : Current V) : Sym2 V → Bool :=
fun e => decide (1 ≤ n e)
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:69
Uses 1
DefinitionGhost vertex of the extended vertex set#✓fully proved
The ghost vertex none of Option V.
DefinitionGraph with a ghost vertex joined to every site#✓fully proved
The graph on V ⊔ {ghost} with the edges of G and an edge from every site to the ghost.
StatMech.Sharpness.withGhost · 18 lines
def withGhost : SimpleGraph (Option V) where
Adj a b :=
match a, b with
| some x, some y => G.Adj x y
| some _, none => True
| none, some _ => True
| none, none => False
symm := by
constructor
rintro (_ | x) (_ | y) h
· exact h
· exact h
· exact h
· exact G.symm.symm _ _ h
loopless := ⟨by
rintro (_ | x) h
· exact h
· exact G.loopless.irrefl x h⟩
Used by 24
DefinitionNumber of walk edges at a vertex#✓fully proved
The number of edges of the walk p incident to x.
def walkDeg {a b : V} (p : H.Walk a b) (x : V) : ℕ :=
(p.edges.filter (fun e => x ∈ e)).length
Used by 1
DefinitionCurrent with a walk removed#✓fully proved
The current n with one unit removed from each traversal of an edge of p.
def removeWalk {a b : V} (n : Current V) (p : H.Walk a b) : Current V :=
fun e => n e - p.edges.count e
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:69
Uses 1
DefinitionExtension of an edge function to a current#✓fully proved
Extension of a function on the edges of G to a current, zero off E(G).
noncomputable def ofEdgeFun (m : ↥G.edgeFinset → ℕ) : Current V :=
fun e => if h : e ∈ G.edgeFinset then m ⟨e, h⟩ else 0
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:69
Uses 1 · Used by 16
DefinitionCurrent sum with prescribed sources#✓fully proved
The current sum Z(∂ = A) = ∑_{∂n = A} w(n) over currents on the edges of G.
noncomputable def currentSum (β : ℝ) (J : Sym2 V → ℝ) (A : Finset V) : ℝ :=
∑' m : ↥G.edgeFinset → ℕ,
if sources G (ofEdgeFun G m) = A then weight G β J (ofEdgeFun G m) else 0
noncomputable def sources (n : Current V) : Finset V :=
Finset.univ.filter (fun x => Odd (incidentFlux G n x))
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:76
noncomputable def ofEdgeFun (m : ↥G.edgeFinset → ℕ) : Current V :=
fun e => if h : e ∈ G.edgeFinset then m ⟨e, h⟩ else 0
PhyslibExt/CondensedMatter/IsingModel/Sharpness/CurrentRep.lean:315
noncomputable def weight (β : ℝ) (J : Sym2 V → ℝ) (n : Current V) : ℝ :=
∏ e ∈ G.edgeFinset, (β * J e) ^ (n e) / (Nat.factorial (n e))
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:85
Uses 3 · Used by 10
DefinitionTerm of the exponential expansion of an edge weight#✓fully proved
The k-th term (βJ_e σ_e)^k / k! of the expansion of exp(βJ_e σ_e).
noncomputable def gEdge (β : ℝ) (J : Sym2 V → ℝ) (s : ConfigSpace V)
(e : Sym2 V) (k : ℕ) : ℝ := (β * J e) ^ k * (bond s e) ^ k / k.factorial
abbrev ConfigSpace (E : Type*) : Type _ := E → Bool
MathlibExt/Probability/Configuration/ConfigSpace.lean:40
def bond (s : ConfigSpace V) (e : Sym2 V) : ℝ :=
Sym2.lift ⟨fun x y => spin s x * spin s y, fun _ _ => mul_comm _ _⟩ e
PhyslibExt/CondensedMatter/IsingModel/Gibbs.lean:85
Uses 2 · Used by 6
DefinitionBoltzmann weight with couplings#✓fully proved
The Boltzmann weight exp(β ∑_e J_e σ_e) with couplings J.
noncomputable def boltzmannJ (β : ℝ) (J : Sym2 V → ℝ) (s : ConfigSpace V) : ℝ :=
Real.exp (β * ∑ e ∈ G.edgeFinset, J e * bond s e)
abbrev ConfigSpace (E : Type*) : Type _ := E → Bool
MathlibExt/Probability/Configuration/ConfigSpace.lean:40
def bond (s : ConfigSpace V) (e : Sym2 V) : ℝ :=
Sym2.lift ⟨fun x y => spin s x * spin s y, fun _ _ => mul_comm _ _⟩ e
PhyslibExt/CondensedMatter/IsingModel/Gibbs.lean:85
Uses 2 · Used by 14
DefinitionPartition function with couplings#✓fully proved
The partition function with couplings J.
noncomputable def partitionJ (β : ℝ) (J : Sym2 V → ℝ) : ℝ :=
∑ s : ConfigSpace V, boltzmannJ G β J s
abbrev ConfigSpace (E : Type*) : Type _ := E → Bool
MathlibExt/Probability/Configuration/ConfigSpace.lean:40
noncomputable def boltzmannJ (β : ℝ) (J : Sym2 V → ℝ) (s : ConfigSpace V) : ℝ :=
Real.exp (β * ∑ e ∈ G.edgeFinset, J e * bond s e)
PhyslibExt/CondensedMatter/IsingModel/Sharpness/CurrentRep.lean:379
Uses 2 · Used by 13
DefinitionCorrelation function with couplings#✓fully proved
The correlation ⟨σ_A⟩_{β,J} with couplings J.
noncomputable def expectationJ (β : ℝ) (J : Sym2 V → ℝ) (A : Finset V) : ℝ :=
(∑ s : ConfigSpace V, spinProd A s * boltzmannJ G β J s) / partitionJ G β J
abbrev ConfigSpace (E : Type*) : Type _ := E → Bool
MathlibExt/Probability/Configuration/ConfigSpace.lean:40
def spinProd (A : Finset V) (s : ConfigSpace V) : ℝ := ∏ x ∈ A, spin s x
PhyslibExt/CondensedMatter/IsingModel/GKS.lean:186
noncomputable def boltzmannJ (β : ℝ) (J : Sym2 V → ℝ) (s : ConfigSpace V) : ℝ :=
Real.exp (β * ∑ e ∈ G.edgeFinset, J e * bond s e)
PhyslibExt/CondensedMatter/IsingModel/Sharpness/CurrentRep.lean:379
noncomputable def partitionJ (β : ℝ) (J : Sym2 V → ℝ) : ℝ :=
∑ s : ConfigSpace V, boltzmannJ G β J s
PhyslibExt/CondensedMatter/IsingModel/Sharpness/CurrentRep.lean:450
Uses 4 · Used by 16
TheoremRandom-current representation#✓fully proved
The random-current representation: ⟨σ_A⟩_{β,J} = Z(∂ = A)/Z(∂ = ∅). Reference: M. Aizenman,
"Geometric analysis of φ⁴ fields and Ising models", Comm. Math. Phys. 86 (1982) 1–48; J. Ginibre
(1970); H. Duminil-Copin, "Random currents expansion of the Ising model", lecture notes (2016),
arXiv:1607.06933.
theorem current_representation (β : ℝ) (J : Sym2 V → ℝ) (A : Finset V) :
expectationJ G β J A = currentSum G β J A / currentSum G β J ∅
noncomputable def expectationJ (β : ℝ) (J : Sym2 V → ℝ) (A : Finset V) : ℝ :=
(∑ s : ConfigSpace V, spinProd A s * boltzmannJ G β J s) / partitionJ G β J
PhyslibExt/CondensedMatter/IsingModel/Sharpness/CurrentRep.lean:454
noncomputable def currentSum (β : ℝ) (J : Sym2 V → ℝ) (A : Finset V) : ℝ :=
∑' m : ↥G.edgeFinset → ℕ,
if sources G (ofEdgeFun G m) = A then weight G β J (ofEdgeFun G m) else 0
PhyslibExt/CondensedMatter/IsingModel/Sharpness/CurrentRep.lean:335
Uses 15 · Used by 7
DefinitionOdd current on every edge of a path#✓fully proved
Every edge of the path carries odd current.
def shb_IsBackboneOf (n : Current V) (x y : V) (ω : G.Path x y) : Prop :=
∀ e ∈ ω.1.edges, Odd (n e)
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:69
Uses 1 · Used by 2
DefinitionOdd-current paths between two vertices#✓fully proved
The paths from x to y all of whose edges carry odd current.
noncomputable def shb_backboneSet (n : Current V) (x y : V) : Finset (G.Path x y) :=
Finset.univ.filter (fun ω => shb_IsBackboneOf G n x y ω)
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:69
def shb_IsBackboneOf (n : Current V) (x y : V) (ω : G.Path x y) : Prop :=
∀ e ∈ ω.1.edges, Odd (n e)
PhyslibExt/CondensedMatter/IsingModel/Sharpness/BackboneDecomposition.lean:69
Uses 2 · Used by 1
DefinitionOdd-current path as a backbone path#✓fully proved
A path with odd current on every edge as a backbone path.
noncomputable def shb_backboneOf_imp_isBackbonePath (n : Current V) (x y : V) (ω : G.Path x y)
(h : shb_IsBackboneOf G n x y ω) : IsBackbonePath G n x y := by
refine ⟨ω.1.transfer (oddSubgraph G n) ?_, ω.2.transfer _⟩
intro e he
have hG : e ∈ G.edgeSet := ω.1.edges_subset_edgeSet he
have hodd : Odd (n e) := h e he
revert hG hodd
refine Sym2.ind (fun a b => ?_) e
intro hG hodd
rw [SimpleGraph.mem_edgeSet] at hG ⊢
exact ⟨hG, hodd⟩
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:69
def shb_IsBackboneOf (n : Current V) (x y : V) (ω : G.Path x y) : Prop :=
∀ e ∈ ω.1.edges, Odd (n e)
PhyslibExt/CondensedMatter/IsingModel/Sharpness/BackboneDecomposition.lean:69
abbrev IsBackbonePath (n : Current V) (x y : V) : Type _ :=
(oddSubgraph G n).Path x y
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:179
DefinitionLeast backbone path between two vertices#✓fully proved
The least backbone path from x to y, if any.
noncomputable def shb_backboneSelect (n : Current V) (x y : V) : Option (G.Path x y) :=
if h : (shb_backboneSet G n x y).Nonempty then
some ((shb_backboneSet G n x y).min' h) else none
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:69
noncomputable def shb_backboneSet (n : Current V) (x y : V) : Finset (G.Path x y) :=
Finset.univ.filter (fun ω => shb_IsBackboneOf G n x y ω)
PhyslibExt/CondensedMatter/IsingModel/Sharpness/BackboneDecomposition.lean:78
Uses 2 · Used by 1
DefinitionWeight of currents with a given selected backbone#✓fully proved
Z_ω: the total weight of currents with sources {x, y} whose selected backbone is ω.
noncomputable def shb_backboneNum (β : ℝ) (J : Sym2 V → ℝ) (x y : V) (ω : G.Path x y) : ℝ :=
∑' m : ↥G.edgeFinset → ℕ,
if Sharpness.sources G (ofEdgeFun G m) = {x, y}
∧ shb_backboneSelect G (ofEdgeFun G m) x y = some ω then
weight G β J (ofEdgeFun G m) else 0
noncomputable def sources (n : Current V) : Finset V :=
Finset.univ.filter (fun x => Odd (incidentFlux G n x))
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:76
noncomputable def ofEdgeFun (m : ↥G.edgeFinset → ℕ) : Current V :=
fun e => if h : e ∈ G.edgeFinset then m ⟨e, h⟩ else 0
PhyslibExt/CondensedMatter/IsingModel/Sharpness/CurrentRep.lean:315
noncomputable def shb_backboneSelect (n : Current V) (x y : V) : Option (G.Path x y) :=
if h : (shb_backboneSet G n x y).Nonempty then
some ((shb_backboneSet G n x y).min' h) else none
PhyslibExt/CondensedMatter/IsingModel/Sharpness/BackboneDecomposition.lean:153
noncomputable def weight (β : ℝ) (J : Sym2 V → ℝ) (n : Current V) : ℝ :=
∏ e ∈ G.edgeFinset, (β * J e) ^ (n e) / (Nat.factorial (n e))
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:85
Uses 4 · Used by 1
DefinitionBackbone weight \(\rho(\omega)\)#✓fully proved
The backbone weight ρ(ω) = Z_ω/Z(∂ = ∅).
noncomputable def shb_rho (β : ℝ) (J : Sym2 V → ℝ) (x y : V) (ω : G.Path x y) : ℝ :=
shb_backboneNum G β J x y ω / currentSum G β J ∅
noncomputable def shb_backboneNum (β : ℝ) (J : Sym2 V → ℝ) (x y : V) (ω : G.Path x y) : ℝ :=
∑' m : ↥G.edgeFinset → ℕ,
if Sharpness.sources G (ofEdgeFun G m) = {x, y}
∧ shb_backboneSelect G (ofEdgeFun G m) x y = some ω then
weight G β J (ofEdgeFun G m) else 0
PhyslibExt/CondensedMatter/IsingModel/Sharpness/BackboneDecomposition.lean:174
noncomputable def currentSum (β : ℝ) (J : Sym2 V → ℝ) (A : Finset V) : ℝ :=
∑' m : ↥G.edgeFinset → ℕ,
if sources G (ofEdgeFun G m) = A then weight G β J (ofEdgeFun G m) else 0
PhyslibExt/CondensedMatter/IsingModel/Sharpness/CurrentRep.lean:335
Uses 2
DefinitionUnordered pair inside a set#✓fully proved
An unordered pair e is inside S if both of its endpoints lie in S.
Used by 28
DefinitionCurrent with no edge crossing a set's boundary#✓fully proved
The current n uses no edge joining S to Sᶜ: every edge with n e ≥ 1 is inside S or
inside Sᶜ.
def NoCrossing (n : Current V) (S : Finset V) : Prop :=
∀ e ∈ G.edgeFinset, 1 ≤ n e → edgeInside S e ∨ edgeInside Sᶜ e
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:69
def edgeInside (S : Finset V) (e : Sym2 V) : Prop := ∀ v ∈ e, v ∈ S
PhyslibExt/CondensedMatter/IsingModel/Sharpness/CurrentSplitting.lean:60
Uses 2 · Used by 4
DefinitionRestriction of a current to a set#✓fully proved
The restriction n|_S of a current to the edges inside S, zero elsewhere.
noncomputable def restrictTo (n : Current V) (S : Finset V) : Current V :=
fun e => if edgeInside S e then n e else 0
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:69
def edgeInside (S : Finset V) (e : Sym2 V) : Prop := ∀ v ∈ e, v ∈ S
PhyslibExt/CondensedMatter/IsingModel/Sharpness/CurrentSplitting.lean:60
Uses 2 · Used by 4
DefinitionSubsets of a sigma type as families of fibre subsets#✓fully proved
Subsets of Σ e, β e correspond to families of subsets of the fibres.
noncomputable def sigmaFinsetEquivPi : Finset (Σ e : E, β e) ≃ Π e : E, Finset (β e) where
toFun S := fun e => (univ : Finset (β e)).filter (fun b => (⟨e, b⟩ : Σ e, β e) ∈ S)
invFun f := univ.filter (fun i : Σ e, β e => i.2 ∈ f i.1)
left_inv := by intro S; ext i; obtain ⟨e, b⟩ := i; simp
right_inv := by intro f; ext e b; simp
AbbreviationEdge copies of a current#✓fully proved
The edge copies of a current m: m_e copies of each edge e.
abbrev Copy (m : ↥G.edgeFinset → ℕ) : Type _ := Σ e : ↥G.edgeFinset, Fin (m e)
Used by 8
DefinitionEndpoints of an edge copy#✓fully proved
The endpoints of an edge copy.
def endsM (m : ↥G.edgeFinset → ℕ) : Copy G m → Sym2 V := fun i => i.1.1
abbrev Copy (m : ↥G.edgeFinset → ℕ) : Type _ := Σ e : ↥G.edgeFinset, Fin (m e)
PhyslibExt/CondensedMatter/IsingModel/Sharpness/EdgeCopyEncoding.lean:125
Uses 1 · Used by 6
DefinitionProfile of a set of edge copies#✓fully proved
The profile of a set of copies: the number of copies of each edge it contains.
noncomputable def profileFlux (m : ↥G.edgeFinset → ℕ) (S : Finset (Copy G m)) :
↥G.edgeFinset → ℕ :=
fun e => #(S.filter (fun i : Copy G m => i.1 = e))
abbrev Copy (m : ↥G.edgeFinset → ℕ) : Type _ := Σ e : ↥G.edgeFinset, Fin (m e)
PhyslibExt/CondensedMatter/IsingModel/Sharpness/EdgeCopyEncoding.lean:125
Uses 1 · Used by 5
DefinitionDouble-current sum restricted to disconnection#✓fully proved
The double-current sum ∑_{∂n₁ = A, ∂n₂ = B} w(n₁) w(n₂) 1_{u ↮ v in n₁ + n₂}.
noncomputable def sourcePairDisconnSum (β : ℝ) (J : Sym2 V → ℝ) (A B : Finset V) (u v : V) : ℝ :=
∑' pq : (↥G.edgeFinset → ℕ) × (↥G.edgeFinset → ℕ),
((if sources G (ofEdgeFun G pq.1) = A then weight G β J (ofEdgeFun G pq.1) else 0)
* (if sources G (ofEdgeFun G pq.2) = B then weight G β J (ofEdgeFun G pq.2) else 0))
* (if ¬ CurrentConnected G (ofEdgeFun G (fun e => pq.1 e + pq.2 e)) u v then 1 else 0)
noncomputable def sources (n : Current V) : Finset V :=
Finset.univ.filter (fun x => Odd (incidentFlux G n x))
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:76
noncomputable def ofEdgeFun (m : ↥G.edgeFinset → ℕ) : Current V :=
fun e => if h : e ∈ G.edgeFinset then m ⟨e, h⟩ else 0
PhyslibExt/CondensedMatter/IsingModel/Sharpness/CurrentRep.lean:315
noncomputable def weight (β : ℝ) (J : Sym2 V → ℝ) (n : Current V) : ℝ :=
∏ e ∈ G.edgeFinset, (β * J e) ^ (n e) / (Nat.factorial (n e))
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:85
def CurrentConnected (n : Current V) (x y : V) : Prop :=
(currentSubgraph G n).Reachable x y
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:128
Uses 4 · Used by 7
DefinitionGraph edges as ghost-graph edges#✓fully proved
The edges of G, as edges of the ghost graph.
Used by 14
DefinitionGhost edges#✓fully proved
The ghost edges {x, ghost}.
noncomputable def ghostEdges (V : Type*) [Fintype V] [DecidableEq V] :
Finset (Sym2 (Option V)) := (univ : Finset V).image (fun x => s(some x, none))
Used by 20
DefinitionCoupling on the ghost graph with uniform field#✓fully proved
The coupling on the ghost graph: J on the edges of G and h on the ghost edges.
noncomputable def ghostCoupling (h _β : ℝ) (J : Sym2 V → ℝ) (e : Sym2 (Option V)) : ℝ :=
Sym2.lift ⟨fun a b =>
match a, b with
| some x, some y => J s(x, y)
| some _, none => h
| none, some _ => h
| none, none => 0,
by rintro (_ | x) (_ | y) <;> simp only []; rw [Sym2.eq_swap]⟩ e
Used by 15
DefinitionGlobal spin flip#✓fully proved
The global spin flip σ ↦ -σ.
def flipV (s : ConfigSpace V) : ConfigSpace V := fun v => ! s v
abbrev ConfigSpace (E : Type*) : Type _ := E → Bool
MathlibExt/Probability/Configuration/ConfigSpace.lean:40
Uses 1 · Used by 12
DefinitionEmbedding of vertices into the ghost graph#✓fully proved
The embedding V ↪ Option V.
def someEmb : V ↪ Option V := ⟨some, Option.some_injective V⟩
Used by 17
LemmaRandom-current representation with a field for even source sets#✓fully proved
The random-current representation with a field: for |A| even, ⟨σ_A⟩_{β,h} = Z_ghost(∂ =
A)/Z_ghost(∂ = ∅) on the ghost graph. Reference: M. Aizenman, D. J. Barsky, R. Fernández, "The
phase transition in a general class of Ising-type models is sharp", J. Stat. Phys. 47 (1987)
343–374; H. Duminil-Copin, "Random currents expansion of the Ising model", lecture notes (2016),
arXiv:1607.06933.
lemma fgd_isingExpectation_eq_currentSum_ratio (β h : ℝ) (A : Finset V) (hA : Even A.card) :
isingExpectation G β h (spinProd A)
= currentSum (withGhost G) β (ghostCoupling h β (fun _ => 1)) (A.map someEmb)
/ currentSum (withGhost G) β (ghostCoupling h β (fun _ => 1)) ∅
noncomputable def isingExpectation (β h : ℝ) (f : ConfigSpace V → ℝ) : ℝ :=
∑ s : ConfigSpace V, isingProb G β h s * f s
PhyslibExt/CondensedMatter/IsingModel/GKS.lean:208
def spinProd (A : Finset V) (s : ConfigSpace V) : ℝ := ∏ x ∈ A, spin s x
PhyslibExt/CondensedMatter/IsingModel/GKS.lean:186
noncomputable def currentSum (β : ℝ) (J : Sym2 V → ℝ) (A : Finset V) : ℝ :=
∑' m : ↥G.edgeFinset → ℕ,
if sources G (ofEdgeFun G m) = A then weight G β J (ofEdgeFun G m) else 0
PhyslibExt/CondensedMatter/IsingModel/Sharpness/CurrentRep.lean:335
def withGhost : SimpleGraph (Option V) where
Adj a b :=
match a, b with
| some x, some y => G.Adj x y
| some _, none => True
| none, some _ => True
| none, none => False
symm := by
constructor
rintro (_ | x) (_ | y) h
· exact h
· exact h
⋯
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:237
noncomputable def ghostCoupling (h _β : ℝ) (J : Sym2 V → ℝ) (e : Sym2 (Option V)) : ℝ :=
Sym2.lift ⟨fun a b =>
match a, b with
| some x, some y => J s(x, y)
| some _, none => h
| none, some _ => h
| none, none => 0,
by rintro (_ | x) (_ | y) <;> simp only []; rw [Sym2.eq_swap]⟩ e
PhyslibExt/CondensedMatter/IsingModel/Sharpness/FieldGhostDict.lean:122
def someEmb : V ↪ Option V := ⟨some, Option.some_injective V⟩
PhyslibExt/CondensedMatter/IsingModel/Sharpness/FieldGhostDict.lean:252
Uses 22 · Used by 1
DefinitionReparametrizing triples of functions by their sum and two summands#✓fully proved
Triples of functions to ℕ correspond to a sum m together with two functions with pointwise
sum ≤ m.
StatMech.Sharpness.tripleEquivSigma · 16 lines
def tripleEquivSigma {E : Type*} :
((E → ℕ) × (E → ℕ) × (E → ℕ)) ≃
Σ m : (E → ℕ), {pq : (E → ℕ) × (E → ℕ) // ∀ e, pq.1 e + pq.2 e ≤ m e} where
toFun klm :=
⟨fun e => klm.1 e + klm.2.1 e + klm.2.2 e,
⟨(klm.1, klm.2.1), fun e => by simp only; omega⟩⟩
invFun s := (s.2.1.1, s.2.1.2, fun e => s.1 e - s.2.1.1 e - s.2.1.2 e)
left_inv := by
rintro ⟨k, l, m⟩
refine Prod.ext rfl (Prod.ext rfl ?_)
funext e; simp only []; omega
right_inv := by
rintro ⟨m, ⟨⟨p, q⟩, hpq⟩⟩
have h1 : (fun e => p e + q e + (m e - p e - q e)) = m := by
ext e; have h := hpq e; simp only at h; omega
exact Sigma.subtype_ext h1 (by simp only)
DefinitionTriple-current sum with prescribed sources#✓fully proved
The triple-current sum ∑_{∂n₁ = A, ∂n₂ = B, ∂n₃ = C} w(n₁) w(n₂) w(n₃).
noncomputable def sourceTripleSum (β : ℝ) (J : Sym2 V → ℝ) (A B C : Finset V) : ℝ :=
∑' z : (↥G.edgeFinset → ℕ) × (↥G.edgeFinset → ℕ) × (↥G.edgeFinset → ℕ),
(if sources G (ofEdgeFun G z.1) = A then weight G β J (ofEdgeFun G z.1) else 0)
* (if sources G (ofEdgeFun G z.2.1) = B then weight G β J (ofEdgeFun G z.2.1) else 0)
* (if sources G (ofEdgeFun G z.2.2) = C then weight G β J (ofEdgeFun G z.2.2) else 0)
noncomputable def sources (n : Current V) : Finset V :=
Finset.univ.filter (fun x => Odd (incidentFlux G n x))
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:76
noncomputable def ofEdgeFun (m : ↥G.edgeFinset → ℕ) : Current V :=
fun e => if h : e ∈ G.edgeFinset then m ⟨e, h⟩ else 0
PhyslibExt/CondensedMatter/IsingModel/Sharpness/CurrentRep.lean:315
noncomputable def weight (β : ℝ) (J : Sym2 V → ℝ) (n : Current V) : ℝ :=
∏ e ∈ G.edgeFinset, (β * J e) ^ (n e) / (Nat.factorial (n e))
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:85
Uses 3
DefinitionDegree of a vertex in a multigraph edge set#✓fully proved
The degree of x in the multigraph edge set T.
Used by 8
DefinitionSources of a multigraph edge set#✓fully proved
The odd-degree vertices of the multigraph edge set T.
def sources (ends : ι → Sym2 V) (T : Finset ι) : Finset V :=
(Finset.univ : Finset V).filter (fun x => Odd (degK ends T x))
def degK (ends : ι → Sym2 V) (T : Finset ι) (x : V) : ℕ :=
#(T.filter (fun i => x ∈ ends i))
PhyslibExt/CondensedMatter/IsingModel/Sharpness/Switching.lean:73
Uses 1 · Used by 11
DefinitionAdjacency through an edge of a multigraph edge set#✓fully proved
a ≠ b are the endpoints of an edge of K.
def adjStep (ends : ι → Sym2 V) (K : Finset ι) (a b : V) : Prop :=
∃ i ∈ K, a ∈ ends i ∧ b ∈ ends i ∧ a ≠ b
Used by 8
DefinitionConnectivity in a multigraph edge set#✓fully proved
Connectivity in K: the reflexive transitive closure of adjStep.
def connK (ends : ι → Sym2 V) (K : Finset ι) : V → V → Prop :=
Relation.ReflTransGen (adjStep ends K)
def adjStep (ends : ι → Sym2 V) (K : Finset ι) (a b : V) : Prop :=
∃ i ∈ K, a ∈ ends i ∧ b ∈ ends i ∧ a ≠ b
PhyslibExt/CondensedMatter/IsingModel/Sharpness/Switching.lean:86
Uses 1 · Used by 12
DefinitionCluster of a vertex in a multigraph edge set#✓fully proved
The cluster of u in K.
noncomputable def compOf (ends : ι → Sym2 V) (K : Finset ι) (u : V) : Finset V :=
(Finset.univ : Finset V).filter (fun x => connK ends K u x)
def connK (ends : ι → Sym2 V) (K : Finset ι) : V → V → Prop :=
Relation.ReflTransGen (adjStep ends K)
PhyslibExt/CondensedMatter/IsingModel/Sharpness/Switching.lean:90
Uses 1 · Used by 7
TheoremSwitching lemma for multigraph currents#✓fully proved
The switching lemma: for m with sources A and u ≠ v, ∑_{K ⊆ m, ∂K = A ∆ {u, v}} F(m) =
∑_{K ⊆ m, ∂K = A} F(m) 1_{u ↔ v in m}. Reference: M. Aizenman, "Geometric analysis of φ⁴ fields and
Ising models", Comm. Math. Phys. 86 (1982) 1–48; H. Duminil-Copin, "Random currents expansion of the
Ising model", lecture notes (2016), arXiv:1607.06933.
theorem switching_lemma (ends : ι → Sym2 V) (m : Finset ι)
(hnd : ∀ i ∈ m, ¬ (ends i).IsDiag) (A : Finset V) (hm : sources ends m = A)
{u v : V} (huv : u ≠ v) (F : Finset ι → ℝ) :
∑ _K ∈ m.powerset.filter (fun K => sources ends K = A ∆ {u, v}), F m
= ∑ _K ∈ m.powerset.filter (fun K => sources ends K = A),
F m * (if connK ends m u v then 1 else 0)
def sources (ends : ι → Sym2 V) (T : Finset ι) : Finset V :=
(Finset.univ : Finset V).filter (fun x => Odd (degK ends T x))
PhyslibExt/CondensedMatter/IsingModel/Sharpness/Switching.lean:77
def connK (ends : ι → Sym2 V) (K : Finset ι) : V → V → Prop :=
Relation.ReflTransGen (adjStep ends K)
PhyslibExt/CondensedMatter/IsingModel/Sharpness/Switching.lean:90
Uses 5 · Used by 3
DefinitionSub-subset-weighted pair sum on a multigraph#✓fully proved
For a multigraph ends, the sum over edge subsets m with sources A of F m times the
number of sub-subsets K ⊆ m with sources A, restricted to m satisfying P.
noncomputable def drd_pairSum (ends : ι → Sym2 V) (A : Finset V) (F : Finset ι → ℝ)
(P : Finset ι → Prop) : ℝ :=
∑ m ∈ (Finset.univ.powerset.filter (fun m => RandomCurrent.sources ends m = A)),
(∑ _K ∈ m.powerset.filter (fun K => RandomCurrent.sources ends K = A),
F m * (if P m then 1 else 0))
def sources (ends : ι → Sym2 V) (T : Finset ι) : Finset V :=
(Finset.univ : Finset V).filter (fun x => Odd (degK ends T x))
PhyslibExt/CondensedMatter/IsingModel/Sharpness/Switching.lean:77
Uses 1
DefinitionVertices not connected to a root through a multigraph edge set#✓fully proved
The vertices not connected to o using edges of m in the multigraph ends.
noncomputable def notConnCompK (ends : ι → Sym2 V) (m : Finset ι) (o : V) : Finset V :=
(Finset.univ : Finset V).filter (fun w => ¬ connK ends m o w)
def connK (ends : ι → Sym2 V) (K : Finset ι) : V → V → Prop :=
Relation.ReflTransGen (adjStep ends K)
PhyslibExt/CondensedMatter/IsingModel/Sharpness/Switching.lean:90
Uses 1
DefinitionMultigraph edge lying inside a vertex set#✓fully proved
Both endpoints of the multigraph edge i lie in S.
Used by 1
DefinitionMultigraph edge set with no edge crossing a vertex set#✓fully proved
Every edge of m lies inside S or inside Sᶜ.
def NoCrossingK (ends : ι → Sym2 V) (m : Finset ι) (S : Finset V) : Prop :=
∀ i ∈ m, edgeInsideK ends S i ∨ edgeInsideK ends Sᶜ i
def edgeInsideK (ends : ι → Sym2 V) (S : Finset V) (i : ι) : Prop := ∀ w ∈ ends i, w ∈ S
PhyslibExt/CondensedMatter/IsingModel/Sharpness/MultigraphClusterSwitching.lean:75
Uses 1
DefinitionSum over edge sets split into parts with sources \(A\) and \(B\)#✓fully proved
The sum over edge sets m with sources A ∆ B and over splittings m = K ⊔ (m \ K) with
sources A and B of F m.
noncomputable def srcPairFamily (ends : ι → Sym2 V) (A B : Finset V) (F : Finset ι → ℝ) : ℝ :=
∑ m ∈ (Finset.univ.powerset.filter (fun m => sources ends m = A ∆ B)),
(∑ _K ∈ m.powerset.filter
(fun K => sources ends K = A ∧ sources ends (m \ K) = B), F m)
def sources (ends : ι → Sym2 V) (T : Finset ι) : Finset V :=
(Finset.univ : Finset V).filter (fun x => Odd (degK ends T x))
PhyslibExt/CondensedMatter/IsingModel/Sharpness/Switching.lean:77
Uses 1
DefinitionOdd-degree vertices in a cluster#✓fully proved
The odd-degree vertices of m in the cluster of u.
noncomputable def compOddVertices (ends : ι → Sym2 V) (m : Finset ι) (u : V) : Finset V :=
(compOf ends m u).filter (fun x => Odd (degK ends m x))
noncomputable def compOf (ends : ι → Sym2 V) (K : Finset ι) (u : V) : Finset V :=
(Finset.univ : Finset V).filter (fun x => connK ends K u x)
PhyslibExt/CondensedMatter/IsingModel/Sharpness/Switching.lean:108
def degK (ends : ι → Sym2 V) (T : Finset ι) (x : V) : ℕ :=
#(T.filter (fun i => x ∈ ends i))
PhyslibExt/CondensedMatter/IsingModel/Sharpness/Switching.lean:73
Uses 2 · Used by 2
DefinitionFour-vertex multigraph with edges \(\{0, 1\}\) and \(\{2, 3\}\)#✓fully proved
A multigraph on Fin 4 with the two edges {0, 1} and {2, 3}.
DefinitionFull edge set of the four-vertex multigraph#✓fully proved
All edges of witEnds.
def witM : Finset (Fin 2) := Finset.univ
DefinitionSingle-edge current weight \((\beta J_e)^k/k!\)#✓fully proved
The single-edge weight (βJ_e)^k / k!.
DefinitionReparametrizing pairs of functions by their sum and one summand#✓fully proved
Pairs (p, q) of functions to ℕ correspond to a sum m = p + q together with p ≤ m.
def pairEquivSigma {E : Type*} :
((E → ℕ) × (E → ℕ)) ≃ Σ m : (E → ℕ), {p : E → ℕ // p ≤ m} where
toFun pq := ⟨fun e => pq.1 e + pq.2 e, ⟨pq.1, fun e => Nat.le_add_right _ _⟩⟩
invFun mp := (mp.2.1, fun e => mp.1 e - mp.2.1 e)
left_inv := by rintro ⟨p, q⟩; ext e <;> simp
right_inv := by
rintro ⟨m, ⟨p, hp⟩⟩
have hm : (fun e => p e + (m e - p e)) = m := by
ext e; exact Nat.add_sub_cancel' (hp e)
simp only
exact Sigma.subtype_ext hm rfl
DefinitionDouble-current sum with prescribed sources#✓fully proved
The double-current sum ∑_{∂n₁ = A, ∂n₂ = B} w(n₁) w(n₂).
noncomputable def sourcePairSum (β : ℝ) (J : Sym2 V → ℝ) (A B : Finset V) : ℝ :=
∑' pq : (↥G.edgeFinset → ℕ) × (↥G.edgeFinset → ℕ),
(if sources G (ofEdgeFun G pq.1) = A then weight G β J (ofEdgeFun G pq.1) else 0)
* (if sources G (ofEdgeFun G pq.2) = B then weight G β J (ofEdgeFun G pq.2) else 0)
noncomputable def sources (n : Current V) : Finset V :=
Finset.univ.filter (fun x => Odd (incidentFlux G n x))
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:76
noncomputable def ofEdgeFun (m : ↥G.edgeFinset → ℕ) : Current V :=
fun e => if h : e ∈ G.edgeFinset then m ⟨e, h⟩ else 0
PhyslibExt/CondensedMatter/IsingModel/Sharpness/CurrentRep.lean:315
noncomputable def weight (β : ℝ) (J : Sym2 V → ℝ) (n : Current V) : ℝ :=
∏ e ∈ G.edgeFinset, (β * J e) ^ (n e) / (Nat.factorial (n e))
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:85
Uses 3 · Used by 3
AbbreviationCurrent as a multiplicity on unordered pairs#✓fully proved
A current: a multiplicity in ℕ on every unordered pair. See also
StatMech.Sharpness.Current.
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
Used by 15
DefinitionIncident flux of a current on an edge set#✓fully proved
The total multiplicity of the edges of E incident to x.
def incidentFlux (n : Current V) (x : V) : ℕ :=
∑ e ∈ E.filter (fun e => x ∈ e), n e
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
PhyslibExt/CondensedMatter/IsingModel/TwoReplica.lean:73
Uses 1 · Used by 7
DefinitionSource set of a current on an edge set#✓fully proved
The source set of a current: the sites with odd incident flux. See also
StatMech.Sharpness.sources and StatMech.Ising.sources_edgeFinset_eq.
def sources (n : Current V) : Finset V :=
Finset.univ.filter (fun x => Odd (incidentFlux E n x))
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
PhyslibExt/CondensedMatter/IsingModel/TwoReplica.lean:73
def incidentFlux (n : Current V) (x : V) : ℕ :=
∑ e ∈ E.filter (fun e => x ∈ e), n e
PhyslibExt/CondensedMatter/IsingModel/TwoReplica.lean:79
Uses 2 · Used by 7
DefinitionAdjacency through an edge of an edge set#✓fully proved
a and b are distinct endpoints of an edge in P.
DefinitionConnectivity through the edges of an edge set#✓fully proved
Connectivity through the edges of P: the reflexive-transitive closure of adjP P.
def connP (P : Finset (Sym2 V)) : V → V → Prop :=
Relation.ReflTransGen (adjP P)
def adjP (P : Finset (Sym2 V)) (a b : V) : Prop :=
∃ e ∈ P, a ∈ e ∧ b ∈ e ∧ a ≠ b
PhyslibExt/CondensedMatter/IsingModel/TwoReplica.lean:110
Uses 1 · Used by 7
DefinitionEdges of an edge set with positive multiplicity#✓fully proved
The edges of E with positive multiplicity.
DefinitionEdges of an edge set with odd multiplicity#✓fully proved
The edges of E with odd multiplicity.
def oddEdges (m : Current V) : Finset (Sym2 V) := E.filter (fun e => Odd (m e))
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
PhyslibExt/CondensedMatter/IsingModel/TwoReplica.lean:73
Uses 1 · Used by 6
DefinitionDegree of a site in an edge set#✓fully proved
The number of edges of P incident to x.
Used by 10
DefinitionOdd-degree sites of an edge set#✓fully proved
The sites of odd degree in the edge set P.
def srcP (P : Finset (Sym2 V)) : Finset V :=
Finset.univ.filter (fun x => Odd (degP P x))
def degP (P : Finset (Sym2 V)) (x : V) : ℕ := #(P.filter (fun e => x ∈ e))
PhyslibExt/CondensedMatter/IsingModel/TwoReplica.lean:158
Uses 1 · Used by 9
DefinitionCluster of a site in an edge set#✓fully proved
The cluster of u in the edge set P.
noncomputable def compOf (P : Finset (Sym2 V)) (u : V) : Finset V :=
Finset.univ.filter (fun x => connP P u x)
def connP (P : Finset (Sym2 V)) : V → V → Prop :=
Relation.ReflTransGen (adjP P)
PhyslibExt/CondensedMatter/IsingModel/TwoReplica.lean:114
DefinitionReflection of a sub-current along an edge set#✓fully proved
The reflection of a sub-current n ≤ m along P: m e - n e on P and n e elsewhere.
def reflect (m : Current V) (P : Finset (Sym2 V)) (n : Current V) : Current V :=
fun e => if e ∈ P then m e - n e else n e
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
PhyslibExt/CondensedMatter/IsingModel/TwoReplica.lean:73
Uses 1 · Used by 3
TheoremSwitching lemma#✓fully proved
Switching lemma (counting form). If u ≠ v are connected by the odd edges of n₁ + n₂,
the sub-currents of n₁ + n₂ with sources A ∆ {u, v} and with sources A are
equinumerous.
R. B. Griffiths, C. A. Hurst and S. Sherman, J. Math. Phys. 11 (1970); M. Aizenman, Geometric analysis of φ⁴ fields and Ising models, Comm. Math. Phys. 86 (1982).
theorem ising_switching_lemma_pair (n₁ n₂ : Current V)
{u v : V} (huv : u ≠ v)
(hconn : connP (oddEdges E (fun e => n₁ e + n₂ e)) u v) (A : Finset V) :
Nat.card {n : Current V //
(∀ e, n e ≤ n₁ e + n₂ e) ∧ sources E n = A ∆ {u, v}}
= Nat.card {n : Current V //
(∀ e, n e ≤ n₁ e + n₂ e) ∧ sources E n = A}
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
PhyslibExt/CondensedMatter/IsingModel/TwoReplica.lean:73
def connP (P : Finset (Sym2 V)) : V → V → Prop :=
Relation.ReflTransGen (adjP P)
PhyslibExt/CondensedMatter/IsingModel/TwoReplica.lean:114
def oddEdges (m : Current V) : Finset (Sym2 V) := E.filter (fun e => Odd (m e))
PhyslibExt/CondensedMatter/IsingModel/TwoReplica.lean:138
def sources (n : Current V) : Finset V :=
Finset.univ.filter (fun x => Odd (incidentFlux E n x))
PhyslibExt/CondensedMatter/IsingModel/TwoReplica.lean:84
DefinitionRestriction of a current to an edge predicate#✓fully proved
The restriction of the current n to the edges satisfying p (zero elsewhere).
noncomputable def acwRestrict (p : Sym2 V → Prop) [DecidablePred p] (n : Current V) : Current V :=
fun e => if p e then n e else 0
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
PhyslibExt/CondensedMatter/IsingModel/TwoReplica.lean:73
Uses 1
DefinitionInternal edge of a vertex set#✓fully proved
Both endpoints of e lie in S.
Used by 1
DefinitionVertex set that no edge of the graph crosses#✓fully proved
Every edge of G lies inside S or inside its complement.
def acwClosedCut (S : Finset V) : Prop :=
∀ e ∈ G.edgeFinset, acwInternal S e ∨ acwInternal Sᶜ e
def acwInternal (S : Finset V) (e : Sym2 V) : Prop := ∀ z ∈ e, z ∈ S
PhyslibExt/CondensedMatter/IsingModel/CurrentWeight.lean:71
Uses 1
LemmaSourced current sum as correlation times sourceless sum#✓fully proved
Z_A = ⟨σ_A⟩ Z_∅.
lemma acw_currentSum_eq_expectation (β : ℝ) (J : Sym2 V → ℝ) (A : Finset V)
(h0 : Sharpness.currentSum G β J ∅ ≠ 0) :
Sharpness.currentSum G β J A = Sharpness.expectationJ G β J A * Sharpness.currentSum G β J ∅
noncomputable def currentSum (β : ℝ) (J : Sym2 V → ℝ) (A : Finset V) : ℝ :=
∑' m : ↥G.edgeFinset → ℕ,
if sources G (ofEdgeFun G m) = A then weight G β J (ofEdgeFun G m) else 0
PhyslibExt/CondensedMatter/IsingModel/Sharpness/CurrentRep.lean:335
noncomputable def expectationJ (β : ℝ) (J : Sym2 V → ℝ) (A : Finset V) : ℝ :=
(∑ s : ConfigSpace V, spinProd A s * boltzmannJ G β J s) / partitionJ G β J
PhyslibExt/CondensedMatter/IsingModel/Sharpness/CurrentRep.lean:454
Uses 3 · Used by 3
LemmaSources on a graph's edge set agree with random-current sources#✓fully proved
The source set of a current on the edges of G is Sharpness.sources G.
lemma sources_edgeFinset_eq (n : Current V) : sources G.edgeFinset n = Sharpness.sources G n
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
PhyslibExt/CondensedMatter/IsingModel/TwoReplica.lean:73
def sources (n : Current V) : Finset V :=
Finset.univ.filter (fun x => Odd (incidentFlux E n x))
PhyslibExt/CondensedMatter/IsingModel/TwoReplica.lean:84
noncomputable def sources (n : Current V) : Finset V :=
Finset.univ.filter (fun x => Odd (incidentFlux G n x))
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:76
Uses 3
DefinitionReflection as an involution of the sub-currents of a current#✓fully proved
Reflection along P as an involutive equivalence of the sub-currents of m.
noncomputable def reflectEquiv (m : Current V) (P : Finset (Sym2 V)) :
{K : Current V // ∀ e, K e ≤ m e} ≃ {K : Current V // ∀ e, K e ≤ m e} where
toFun K := ⟨reflect m P K.1, reflect_le m P K.2⟩
invFun K := ⟨reflect m P K.1, reflect_le m P K.2⟩
left_inv K := Subtype.ext (reflect_involutive m P K.2)
right_inv K := Subtype.ext (reflect_involutive m P K.2)
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
PhyslibExt/CondensedMatter/IsingModel/TwoReplica.lean:73
def reflect (m : Current V) (P : Finset (Sym2 V)) (n : Current V) : Current V :=
fun e => if e ∈ P then m e - n e else n e
PhyslibExt/CondensedMatter/IsingModel/TwoReplica.lean:379
lemma reflect_le (m : Current V) (P : Finset (Sym2 V)) {n : Current V}
(hn : ∀ e, n e ≤ m e) : ∀ e, reflect m P n e ≤ m e
PhyslibExt/CondensedMatter/IsingModel/TwoReplica.lean:387
lemma reflect_involutive (m : Current V) (P : Finset (Sym2 V)) {n : Current V}
(hn : ∀ e, n e ≤ m e) : reflect m P (reflect m P n) = n
PhyslibExt/CondensedMatter/IsingModel/TwoReplica.lean:395
Uses 2 · Used by 1
DefinitionWeighted sum over splittings with prescribed sources#✓fully proved
The weighted sum F ∑_K w(K) w(m - K) over sub-currents K ≤ m with sources A.
noncomputable def splitWeightedSum (β : ℝ) (J : Sym2 V → ℝ) (m : Current V) (F : ℝ)
(A : Finset V) : ℝ :=
∑ K : {K : Current V // ∀ e, K e ≤ m e},
(if Sharpness.sources G K.1 = A
then F * (Sharpness.weight G β J K.1 * Sharpness.weight G β J (fun e => m e - K.1 e))
else 0)
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
PhyslibExt/CondensedMatter/IsingModel/TwoReplica.lean:73
noncomputable def sources (n : Current V) : Finset V :=
Finset.univ.filter (fun x => Odd (incidentFlux G n x))
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:76
noncomputable def weight (β : ℝ) (J : Sym2 V → ℝ) (n : Current V) : ℝ :=
∏ e ∈ G.edgeFinset, (β * J e) ^ (n e) / (Nat.factorial (n e))
PhyslibExt/CondensedMatter/IsingModel/Sharpness/RandomCurrent.lean:85
Uses 3 · Used by 1
TheoremSwitching lemma#✓fully proved
Switching lemma (weighted form). If u ≠ v are connected by odd edges of m, the
weighted sums over splittings with sources A ∆ {u, v} and A agree.
M. Aizenman, Geometric analysis of φ⁴ fields and Ising models, Comm. Math. Phys. 86 (1982).
theorem ising_switching_weighted (β : ℝ) (J : Sym2 V → ℝ) (m : Current V)
{u v : V} (huv : u ≠ v) (hconn : connP (oddEdges G.edgeFinset m) u v)
(F : ℝ) (A : Finset V) :
splitWeightedSum G β J m F (A ∆ {u, v}) = splitWeightedSum G β J m F A
abbrev Current (V : Type*) : Type _ := Sym2 V → ℕ
PhyslibExt/CondensedMatter/IsingModel/TwoReplica.lean:73
def connP (P : Finset (Sym2 V)) : V → V → Prop :=
Relation.ReflTransGen (adjP P)
PhyslibExt/CondensedMatter/IsingModel/TwoReplica.lean:114
def oddEdges (m : Current V) : Finset (Sym2 V) := E.filter (fun e => Odd (m e))
PhyslibExt/CondensedMatter/IsingModel/TwoReplica.lean:138
noncomputable def splitWeightedSum (β : ℝ) (J : Sym2 V → ℝ) (m : Current V) (F : ℝ)
(A : Finset V) : ℝ :=
∑ K : {K : Current V // ∀ e, K e ≤ m e},
(if Sharpness.sources G K.1 = A
then F * (Sharpness.weight G β J K.1 * Sharpness.weight G β J (fun e => m e - K.1 e))
else 0)
PhyslibExt/CondensedMatter/IsingModel/TwoReplicaWeighted.lean:100
Uses 14
Loading dependency explorer…
The dependency explorer needs JavaScript and its graph data.