import Mathlib namespace OAI section noncomputable section open Set Filter MeasureTheory ProbabilityTheory open scoped Topology ENNReal NNReal namespace BelowOne abbrev Time := Set.Icc (0 : ℝ) 1 abbrev Curve := C(Time, ℂ) abbrev GridPoint := ℤ × ℤ instance : MeasurableSpace Curve := borel Curve instance : BorelSpace Curve := ⟨rfl⟩ structure IncreasingReparam where homeomorph : Time ≃ₜ Time increasing : StrictMono homeomorph instance : Inhabited IncreasingReparam := ⟨⟨Homeomorph.refl _, fun _ _ h => h⟩⟩ def curveDistance (α β : Curve) : ℝ := sInf {r : ℝ | ∃ φ ψ : IncreasingReparam, r = sSup (Set.range fun t : Time => dist (α (φ.homeomorph t)) (β (ψ.homeomorph t)))} def IsCurveTest (f : Curve → ℝ) : Prop := (∃ C : ℝ, ∀ α, |f α| ≤ C) ∧ ∀ α, ∀ ε > 0, ∃ r > 0, ∀ β, curveDistance α β < r → |f α - f β| < ε def gridEmbed (δ : ℝ) (v : GridPoint) : ℂ := ⟨δ * v.1, δ * v.2⟩ def gridNeighbor (v w : GridPoint) : Prop := (v.1 = w.1 ∧ |v.2 - w.2| = 1) ∨ (v.2 = w.2 ∧ |v.1 - w.1| = 1) def interpolate (points : List ℂ) (t : Time) : ℂ := if (t : ℝ) = 1 then points.getLast?.getD 0 else let s := (t : ℝ) * (points.length - 1) let j := Nat.floor s let θ : ℂ := ((s - j : ℝ) : ℂ) (1 - θ) * points[j]?.getD 0 + θ * points[j + 1]?.getD 0 def cycleNext {n : ℕ} (hn : 0 < n) (i : Fin n) : Fin n := ⟨(i.val + 1) % n, Nat.mod_lt _ hn⟩ def cyclePrev {n : ℕ} (hn : 0 < n) (i : Fin n) : Fin n := ⟨(i.val + n - 1) % n, Nat.mod_lt _ hn⟩ structure SmoothMarkedJordan where domain : Set ℂ isOpen : IsOpen domain isConnected : IsConnected domain bounded : Bornology.IsBounded domain boundary : ℝ → ℂ smooth : ContDiff ℝ (↑(⊤ : ℕ∞)) boundary periodic : Function.Periodic boundary 1 simple : Set.InjOn boundary (Set.Ico 0 1) regular : ∀ t, deriv boundary t ≠ 0 frontier : frontier domain = boundary '' Set.Icc 0 1 positive_orientation : 0 < ∫ t in (0 : ℝ)..1, (boundary t).re * (deriv boundary t).im - (boundary t).im * (deriv boundary t).re secondMark : ℝ secondMark_pos : 0 < secondMark secondMark_lt : secondMark < 1 def SmoothMarkedJordan.a (D : SmoothMarkedJordan) := D.boundary 0 def SmoothMarkedJordan.b (D : SmoothMarkedJordan) := D.boundary D.secondMark structure LatticePolygon (δ : ℝ) where domain : Set ℂ isOpen : IsOpen domain isConnected : IsConnected domain bounded : Bornology.IsBounded domain nVertices : ℕ vertices : Fin nVertices → GridPoint vertices_injective : Function.Injective vertices all_vertices : ∀ v : GridPoint, (∃ i, vertices i = v) ↔ gridEmbed δ v ∈ closure domain nBoundary : ℕ boundary_pos : 0 < nBoundary boundary_three : 3 ≤ nBoundary boundaryVertex : Fin nBoundary → Fin nVertices boundary_injective : Function.Injective boundaryVertex boundary_neighbor : ∀ i, gridNeighbor (vertices (boundaryVertex i)) (vertices (boundaryVertex (cycleNext boundary_pos i))) boundary_segment : ∀ i, segment ℝ (gridEmbed δ (vertices (boundaryVertex i))) (gridEmbed δ (vertices (boundaryVertex (cycleNext boundary_pos i)))) ⊆ closure domain boundaryCurve : Curve boundary_interpolation : ∀ t, boundaryCurve t = interpolate ((List.ofFn fun i => gridEmbed δ (vertices (boundaryVertex i))) ++ [gridEmbed δ (vertices (boundaryVertex ⟨0, boundary_pos⟩))]) t boundary_simple : ∀ s t : Time, (s : ℝ) < 1 → (t : ℝ) < 1 → boundaryCurve s = boundaryCurve t → s = t frontier : frontier domain = Set.range boundaryCurve positive_orientation : 0 < ∑ i : Fin nBoundary, ((gridEmbed δ (vertices (boundaryVertex i))).re * (gridEmbed δ (vertices (boundaryVertex (cycleNext boundary_pos i)))).im - (gridEmbed δ (vertices (boundaryVertex i))).im * (gridEmbed δ (vertices (boundaryVertex (cycleNext boundary_pos i)))).re) secondMark : Fin nBoundary secondMark_ne : secondMark.val ≠ 0 wiredForward : Bool namespace LatticePolygon variable {δ : ℝ} (P : LatticePolygon δ) abbrev Vertex := Fin P.nVertices def position (v : P.Vertex) : ℂ := gridEmbed δ (P.vertices v) def graph : SimpleGraph P.Vertex := SimpleGraph.fromRel fun v w => gridNeighbor (P.vertices v) (P.vertices w) ∧ segment ℝ (P.position v) (P.position w) ⊆ closure P.domain def edges : Finset (Sym2 P.Vertex) := P.graph.edgeSet.toFinite.toFinset def first : Fin P.nBoundary := ⟨0, P.boundary_pos⟩ def aVertex : P.Vertex := P.boundaryVertex P.first def bVertex : P.Vertex := P.boundaryVertex P.secondMark def wiredVertices : Finset P.Vertex := Finset.univ.filter fun v => ∃ i : Fin P.nBoundary, P.boundaryVertex i = v ∧ if P.wiredForward then i.val ≤ P.secondMark.val else P.secondMark.val ≤ i.val ∨ i.val = 0 def wiredEdges : Finset (Sym2 P.Vertex) := ((Finset.univ : Finset (Fin P.nBoundary)).filter fun i => if P.wiredForward then i.val < P.secondMark.val else P.secondMark.val ≤ i.val).image fun i => s(P.boundaryVertex i, P.boundaryVertex (cycleNext P.boundary_pos i)) def wiredConfiguration (A : Finset (Sym2 P.Vertex)) : SimpleGraph P.Vertex := SimpleGraph.fromRel fun v w => (s(v,w) ∈ A) ∨ (v ∈ P.wiredVertices ∧ w ∈ P.wiredVertices) def componentCount (A : Finset (Sym2 P.Vertex)) : ℕ := Nat.card (P.wiredConfiguration A).ConnectedComponent def configurationWeight (q : ℝ) (A : Finset (Sym2 P.Vertex)) : ℝ := let p := Real.sqrt q / (1 + Real.sqrt q) p ^ A.card * (1 - p) ^ (P.edges.card - A.card) * q ^ P.componentCount A def partitionFunction (q : ℝ) : ℝ := ∑ A ∈ P.edges.powerset, P.configurationWeight q A structure Dart where source : P.Vertex target : P.Vertex adjacent : P.graph.Adj source target instance : Finite P.Dart := Finite.of_injective (fun e : P.Dart => (e.source, e.target)) (by rintro ⟨s, t, h⟩ ⟨s', t', h'⟩ he obtain ⟨rfl, rfl⟩ := Prod.mk.inj he rfl) instance : Fintype P.Dart := Fintype.ofFinite _ instance : DecidableEq P.Dart := Classical.decEq _ def Dart.reverse (e : P.Dart) : P.Dart := ⟨e.target, e.source, P.graph.adj_symm e.adjacent⟩ def dartPosition (e : P.Dart) : ℂ := (P.position e.source + P.position e.target) / 2 def dartDirection (e : P.Dart) : ℕ := if (P.vertices e.source).1 < (P.vertices e.target).1 then 0 else if (P.vertices e.source).2 < (P.vertices e.target).2 then 1 else if (P.vertices e.target).1 < (P.vertices e.source).1 then 2 else 3 def angularSteps (clockwise : Bool) (e f : P.Dart) : ℕ := let k := if clockwise then (P.dartDirection e + 4 - P.dartDirection f) % 4 else (P.dartDirection f + 4 - P.dartDirection e) % 4 if k = 0 then 4 else k def IsNextDart (clockwise : Bool) (e f : P.Dart) : Prop := e.source = f.source ∧ ∀ g : P.Dart, e.source = g.source → P.angularSteps clockwise e f ≤ P.angularSteps clockwise e g def IsSwitched (A : Finset (Sym2 P.Vertex)) (e f : P.Dart) : Prop := if s(e.source, e.target) ∈ A ∪ P.wiredEdges then f = e.reverse P else f = e def IsContourSuccessor (A : Finset (Sym2 P.Vertex)) (e f : P.Dart) : Prop := if P.wiredForward then ∃ h, P.IsNextDart true e h ∧ P.IsSwitched A h f else ∃ h, P.IsSwitched A e h ∧ P.IsNextDart false h f def IsInitialDart (A : Finset (Sym2 P.Vertex)) (e : P.Dart) : Prop := if P.wiredForward then ∃ h : P.Dart, h.source = P.aVertex ∧ h.target = P.boundaryVertex (cyclePrev P.boundary_pos P.first) ∧ P.IsSwitched A h e else e.source = P.aVertex ∧ e.target = P.boundaryVertex (cycleNext P.boundary_pos P.first) def IsFinalDart (A : Finset (Sym2 P.Vertex)) (e : P.Dart) : Prop := if P.wiredForward then e.source = P.bVertex ∧ e.target = P.boundaryVertex (cycleNext P.boundary_pos P.secondMark) else ∃ h : P.Dart, h.source = P.bVertex ∧ h.target = P.boundaryVertex (cyclePrev P.boundary_pos P.secondMark) ∧ P.IsSwitched A h e def IsInterface (A : Finset (Sym2 P.Vertex)) (η : Curve) : Prop := ∃ walk : List P.Dart, walk ≠ [] ∧ walk.Nodup ∧ (∃ e, walk.head? = some e ∧ P.IsInitialDart A e) ∧ (∃ e, walk.getLast? = some e ∧ P.IsFinalDart A e) ∧ walk.IsChain (P.IsContourSuccessor A) ∧ ∀ t, η t = interpolate (P.position P.aVertex :: walk.map P.dartPosition ++ [P.position P.bVertex]) t end LatticePolygon structure MarkedApproximation (D : SmoothMarkedJordan) where mesh : ℕ → ℝ mesh_pos : ∀ n, 0 < mesh n mesh_zero : Tendsto mesh atTop (𝓝 0) polygon : ∀ n, LatticePolygon (mesh n) boundaryReparam : ℕ → IncreasingReparam boundary_uniform : Tendsto (fun n => sSup (Set.range fun t : Time => dist ((polygon n).boundaryCurve ((boundaryReparam n).homeomorph t)) (D.boundary t))) atTop (𝓝 0) marked_uniform : Tendsto (fun n => (((boundaryReparam n).homeomorph.symm ⟨((polygon n).secondMark.val : ℝ) / (polygon n).nBoundary, by have hn : (0 : ℝ) < (polygon n).nBoundary := by exact_mod_cast (polygon n).boundary_pos constructor · exact div_nonneg (Nat.cast_nonneg _) hn.le · exact (div_le_one hn).2 (by exact_mod_cast (polygon n).secondMark.isLt.le)⟩ : Time) : ℝ)) atTop (𝓝 D.secondMark) interface : ∀ n, Finset (Sym2 (polygon n).Vertex) → Curve interface_drawing : ∀ n A, A ⊆ (polygon n).edges → (polygon n).IsInterface A (interface n A) def interfaceExpectation {D : SmoothMarkedJordan} (M : MarkedApproximation D) (q : ℝ) (n : ℕ) (f : Curve → ℝ) : ℝ := (∑ A ∈ (M.polygon n).edges.powerset, (M.polygon n).configurationWeight q A * f (M.interface n A)) / (M.polygon n).partitionFunction q def kappa (q : ℝ) : ℝ := 4 * Real.pi / Real.arccos (-Real.sqrt q / 2) def upperHalfPlane : Set ℂ := {z | 0 < z.im} def pastTrace (γ : ℝ≥0 → ℂ) (t : ℝ≥0) : Set ℂ := γ '' Set.Iic t def loewnerDomain (γ : ℝ≥0 → ℂ) (t : ℝ≥0) : Set ℂ := {z ∈ upperHalfPlane \ pastTrace γ t | ¬ Bornology.IsBounded (connectedComponentIn (upperHalfPlane \ pastTrace γ t) z)} def inverseOn (g : ℂ → ℂ) (U : Set ℂ) (w : ℂ) : ℂ := by classical exact if h : ∃ z ∈ U, g z = w then h.choose else 0 def IsLoewnerTrace (W : ℝ≥0 → ℝ) (γ : ℝ≥0 → ℂ) (g : ℝ≥0 → ℂ → ℂ) : Prop := Continuous γ ∧ γ 0 = 0 ∧ (∀ t, 0 ≤ (γ t).im) ∧ (∀ R : ℝ, ∃ T : ℝ≥0, ∀ t ≥ T, R ≤ ‖γ t‖) ∧ (∀ z ∈ upperHalfPlane, g 0 z = z) ∧ (∀ t, DifferentiableOn ℂ (g t) (loewnerDomain γ t)) ∧ (∀ t, Set.BijOn (g t) (loewnerDomain γ t) upperHalfPlane) ∧ (∀ t, Tendsto (fun z => g t z - z) (Filter.cocompact ℂ ⊓ Filter.principal (loewnerDomain γ t)) (𝓝 0)) ∧ (∀ t, Tendsto (fun z => z * (g t z - z)) (Filter.cocompact ℂ ⊓ Filter.principal (loewnerDomain γ t)) (𝓝 (2 * (t : ℝ) : ℂ))) ∧ (∀ t z, z ∈ loewnerDomain γ t → HasDerivWithinAt (fun s : ℝ => g (Real.toNNReal s) z) (2 / (g t z - (W t : ℂ))) (Set.Ici 0) (t : ℝ)) ∧ (∀ t, Tendsto (fun y : ℝ => inverseOn (g t) (loewnerDomain γ t) ((W t : ℂ) + Complex.I * y)) (𝓝[>] 0) (𝓝 (γ t))) def cayley (z : ℂ) : ℂ := (z - Complex.I) / (z + Complex.I) def IsDomainCoordinate (D : SmoothMarkedJordan) (φ : ℂ → ℂ) : Prop := DifferentiableOn ℂ φ (Metric.ball 0 1) ∧ Set.BijOn φ (Metric.ball 0 1) D.domain ∧ ContinuousOn φ (Metric.closedBall 0 1) ∧ Set.BijOn φ (Metric.closedBall 0 1) (closure D.domain) ∧ φ (-1) = D.a ∧ φ 1 = D.b abbrev BrownianSample := C(ℝ≥0, ℝ) instance : MeasurableSpace BrownianSample := borel BrownianSample instance : BorelSpace BrownianSample := ⟨rfl⟩ def IsChordalSLE (κ : ℝ) (D : SmoothMarkedJordan) (μ : Measure Curve) : Prop := IsProbabilityMeasure μ ∧ ∃ (P : Measure BrownianSample) (φ : ℂ → ℂ) (γ : BrownianSample → ℝ≥0 → ℂ) (g : BrownianSample → ℝ≥0 → ℂ → ℂ) (η : BrownianSample → Curve), IsProbabilityMeasure P ∧ IsBrownianReal (fun t ω => ω t) P ∧ IsDomainCoordinate D φ ∧ Measurable η ∧ μ = Measure.map η P ∧ (∀ᵐ ω ∂P, IsLoewnerTrace (fun t => Real.sqrt κ * ω t) (γ ω) (g ω) ∧ (∀ u : Time, (u : ℝ) < 1 → η ω u = φ (cayley (γ ω (Real.toNNReal ((u : ℝ) / (1 - (u : ℝ))))))) ∧ η ω ⟨1, by simp⟩ = D.b) end BelowOne noncomputable section open SimpleGraph Function namespace BelowOne.FKComponents variable {V : Type*} {G : SimpleGraph V} lemma eq_of_walk {β : Sort*} {f : V → β} (hf : ∀ ⦃v w⦄, G.Adj v w → f v = f w) {v w : V} (p : G.Walk v w) : f v = f w := by induction p with | nil => rfl | cons h p ih => exact (hf h).trans ih lemma component_card_sup_edge_of_reachable [Finite V] {a b : V} (hab : G.Reachable a b) : Nat.card (G ⊔ edge a b).ConnectedComponent = Nat.card G.ConnectedComponent := by classical let H := G ⊔ edge a b have hconst : ∀ ⦃v w⦄, H.Adj v w → G.connectedComponentMk v = G.connectedComponentMk w := by intro v w hvw rcases hvw with hG | he · exact ConnectedComponent.sound hG.reachable · rcases (edge_adj _ _ _ _).mp he with ⟨⟨rfl,rfl⟩ | ⟨rfl,rfl⟩,_⟩ · exact ConnectedComponent.sound hab · exact ConnectedComponent.sound hab.symm let f : H.ConnectedComponent → G.ConnectedComponent := ConnectedComponent.lift G.connectedComponentMk (fun _ _ p _ => eq_of_walk hconst p) let g : G.ConnectedComponent → H.ConnectedComponent := ConnectedComponent.map (Hom.ofLE le_sup_left) let e : H.ConnectedComponent ≃ G.ConnectedComponent := { toFun := f invFun := g left_inv := fun c => c.ind fun v => rfl right_inv := fun c => c.ind fun v => rfl } exact Nat.card_congr e lemma component_card_sup_edge_of_not_reachable [Finite V] {a b : V} (hab : ¬ G.Reachable a b) : Nat.card (G ⊔ edge a b).ConnectedComponent + 1 = Nat.card G.ConnectedComponent := by classical let H := G ⊔ edge a b let A := G.connectedComponentMk a let B := G.connectedComponentMk b have hAB : A ≠ B := fun h => hab (ConnectedComponent.exact h) let collapse : G.ConnectedComponent → {c : G.ConnectedComponent // c ≠ B} := fun c => ⟨if c = B then A else c, by split_ifs with h; exact hAB; exact h⟩ have hcollapse : collapse A = collapse B := by apply Subtype.ext simp [collapse,hAB] have hconst : ∀ ⦃v w⦄, H.Adj v w → collapse (G.connectedComponentMk v) = collapse (G.connectedComponentMk w) := by intro v w hvw rcases hvw with hG | he · exact congrArg collapse (ConnectedComponent.sound hG.reachable) · rcases (edge_adj _ _ _ _).mp he with ⟨⟨rfl,rfl⟩ | ⟨rfl,rfl⟩,_⟩ · exact hcollapse · exact hcollapse.symm let f : H.ConnectedComponent → {c : G.ConnectedComponent // c ≠ B} := ConnectedComponent.lift (fun v => collapse (G.connectedComponentMk v)) (fun _ _ p _ => eq_of_walk hconst p) let g : G.ConnectedComponent → H.ConnectedComponent := ConnectedComponent.map (Hom.ofLE le_sup_left) have hgab : g A = g B := by apply ConnectedComponent.sound apply SimpleGraph.Adj.reachable exact Or.inr ((edge_adj _ _ _ _).mpr ⟨Or.inl ⟨rfl,rfl⟩,fun h => hAB (congrArg G.connectedComponentMk h)⟩) have hfg (c : G.ConnectedComponent) : f (g c) = collapse c := by exact c.ind fun v => rfl let e : H.ConnectedComponent ≃ {c : G.ConnectedComponent // c ≠ B} := { toFun := f invFun := fun c => g c.val left_inv := by intro c induction c using ConnectedComponent.ind with | h v => change g (if G.connectedComponentMk v = B then A else G.connectedComponentMk v) = g (G.connectedComponentMk v) split_ifs with hv · rw [hv]; exact hgab · rfl right_inv := by intro c rw [hfg] apply Subtype.ext simp [collapse,c.property] } have hcard := Nat.card_congr e let := Fintype.ofFinite G.ConnectedComponent let := Fintype.ofFinite H.ConnectedComponent simp only [Nat.card_eq_fintype_card] at hcard ⊢ rw [hcard] have hsub := Fintype.card_subtype_compl (fun c : G.ConnectedComponent => c = B) have hpos : 0 < Fintype.card G.ConnectedComponent := Fintype.card_pos_iff.mpr ⟨A⟩ simp only [Fintype.card_unique] at hsub change Fintype.card {c : G.ConnectedComponent // c ≠ B} = Fintype.card G.ConnectedComponent - 1 at hsub omega lemma component_card_sup_edge [Finite V] (a b : V) : Nat.card (G ⊔ edge a b).ConnectedComponent = Nat.card G.ConnectedComponent ∨ Nat.card (G ⊔ edge a b).ConnectedComponent + 1 = Nat.card G.ConnectedComponent := by by_cases h : G.Reachable a b · exact Or.inl (component_card_sup_edge_of_reachable h) · exact Or.inr (component_card_sup_edge_of_not_reachable h) end BelowOne.FKComponents namespace BelowOne.FKFinite open Finset SimpleGraph attribute [local instance] Classical.propDecidable variable {V : Type*} def configuration (G : SimpleGraph V) (A : Finset (Sym2 V)) : SimpleGraph V := G ⊔ fromEdgeSet (A : Set (Sym2 V)) def count (G : SimpleGraph V) (A : Finset (Sym2 V)) : ℕ := Nat.card (configuration G A).ConnectedComponent def weight (G : SimpleGraph V) (q v : ℝ) (A : Finset (Sym2 V)) : ℝ := v ^ A.card * q ^ count G A def partition (G : SimpleGraph V) (q v : ℝ) (E : Finset (Sym2 V)) : ℝ := ∑ A ∈ E.powerset, weight G q v A lemma weight_pos (G : SimpleGraph V) {q v : ℝ} (hq : 0 < q) (hv : 0 < v) (A : Finset (Sym2 V)) : 0 < weight G q v A := by exact mul_pos (pow_pos hv _) (pow_pos hq _) lemma partition_pos (G : SimpleGraph V) {q v : ℝ} (hq : 0 < q) (hv : 0 < v) (E : Finset (Sym2 V)) : 0 < partition G q v E := by apply sum_pos · intro A hA exact weight_pos G hq hv A · exact ⟨∅,by simp⟩ lemma configuration_insert (G : SimpleGraph V) (A : Finset (Sym2 V)) (a b : V) : configuration G (insert s(a,b) A) = configuration G A ⊔ edge a b := by classical ext u w simp only [configuration, sup_adj, fromEdgeSet_adj, mem_coe, Finset.mem_insert, edge, Set.mem_singleton_iff] tauto lemma configuration_union (G : SimpleGraph V) (A F : Finset (Sym2 V)) : configuration G (A ∪ F) = configuration (configuration G F) A := by classical ext u w simp only [configuration,sup_adj,fromEdgeSet_adj,mem_coe,Finset.mem_union] tauto lemma weight_union (G : SimpleGraph V) (q v : ℝ) {A F : Finset (Sym2 V)} (hAF : Disjoint A F) : weight G q v (A ∪ F) = v ^ F.card * weight (configuration G F) q v A := by classical simp only [weight,count,configuration_union,card_union_of_disjoint hAF,pow_add] ring theorem domain_markov (G : SimpleGraph V) {q v : ℝ} (hv : 0 < v) {S F : Finset (Sym2 V)} (hSF : Disjoint S F) (f : Finset (Sym2 V) → ℝ) : (∑ A ∈ S.powerset, weight G q v (A ∪ F) * f A) / (∑ A ∈ S.powerset, weight G q v (A ∪ F)) = (∑ A ∈ S.powerset, weight (configuration G F) q v A * f A) / partition (configuration G F) q v S := by classical have hx : ∀ A ∈ S.powerset, weight G q v (A ∪ F) = v ^ F.card * weight (configuration G F) q v A := by intro A hA exact weight_union G q v (hSF.mono_left (mem_powerset.mp hA)) simp_rw [sum_congr rfl hx] have hn : (∑ A ∈ S.powerset, weight G q v (A ∪ F) * f A) = v ^ F.card * (∑ A ∈ S.powerset, weight (configuration G F) q v A * f A) := by rw [mul_sum] apply sum_congr rfl intro A hA rw [hx A hA] ring rw [hn,← mul_sum] change _ / (v ^ F.card * partition (configuration G F) q v S) = _ exact mul_div_mul_left _ _ (ne_of_gt (pow_pos hv _)) variable [Finite V] lemma weight_insert_connected (G : SimpleGraph V) (q v : ℝ) (A : Finset (Sym2 V)) {a b : V} (he : s(a,b) ∉ A) (hab : (configuration G A).Reachable a b) : weight G q v (insert s(a,b) A) = v * weight G q v A := by classical have hc := FKComponents.component_card_sup_edge_of_reachable hab simp only [weight,count,configuration_insert,card_insert_of_notMem he,pow_succ] rw [hc] ring lemma weight_insert_separated (G : SimpleGraph V) (q v : ℝ) (A : Finset (Sym2 V)) {a b : V} (he : s(a,b) ∉ A) (hab : ¬(configuration G A).Reachable a b) : q * weight G q v (insert s(a,b) A) = v * weight G q v A := by classical have hc := FKComponents.component_card_sup_edge_of_not_reachable hab unfold weight count rw [configuration_insert,card_insert_of_notMem he,← hc,pow_succ,pow_succ] ring theorem edge_conditional_probability (G : SimpleGraph V) {q v : ℝ} (hq : 0 < q) (hv : 0 < v) (A : Finset (Sym2 V)) {a b : V} (he : s(a,b) ∉ A) : weight G q v (insert s(a,b) A) / (weight G q v A + weight G q v (insert s(a,b) A)) = if (configuration G A).Reachable a b then v/(1+v) else v/(q+v) := by classical have hw := weight_pos G hq hv A split_ifs with hab · rw [weight_insert_connected G q v A he hab] apply (div_eq_div_iff (ne_of_gt (add_pos hw (mul_pos hv hw))) (ne_of_gt (add_pos zero_lt_one hv))).mpr ring · have hc := weight_insert_separated G q v A he hab have hi := weight_pos G hq hv (insert s(a,b) A) apply (div_eq_div_iff (ne_of_gt (add_pos hw hi)) (ne_of_gt (add_pos hq hv))).mpr nlinarith end BelowOne.FKFinite namespace BelowOne.LatticePolygon open Finset SimpleGraph variable {δ : ℝ} (P : LatticePolygon δ) def wireGraph : SimpleGraph P.Vertex := fromRel fun v w => v ∈ P.wiredVertices ∧ w ∈ P.wiredVertices lemma wiredConfiguration_eq (A : Finset (Sym2 P.Vertex)) : P.wiredConfiguration A = FKFinite.configuration P.wireGraph A := by classical ext v w simp only [wiredConfiguration,wireGraph,FKFinite.configuration,fromRel_adj, sup_adj,fromEdgeSet_adj,mem_coe,Sym2.eq_swap] tauto lemma componentCount_eq (A : Finset (Sym2 P.Vertex)) : P.componentCount A = FKFinite.count P.wireGraph A := by unfold componentCount FKFinite.count rw [P.wiredConfiguration_eq] lemma configurationWeight_odds {q : ℝ} (hq : 0 < q) (A : Finset (Sym2 P.Vertex)) (hA : A ⊆ P.edges) : P.configurationWeight q A = (1 / (1 + Real.sqrt q)) ^ P.edges.card * FKFinite.weight P.wireGraph q (Real.sqrt q) A := by have hs : 0 < Real.sqrt q := Real.sqrt_pos.mpr hq have hd : 1 + Real.sqrt q ≠ 0 := ne_of_gt (by linarith) have hp : 1 - Real.sqrt q / (1 + Real.sqrt q) = 1/(1+Real.sqrt q) := by field_simp ring have hc : A.card + (P.edges.card - A.card) = P.edges.card := Nat.add_sub_of_le (card_le_card hA) unfold configurationWeight FKFinite.weight dsimp only rw [P.componentCount_eq,hp] rw [div_eq_mul_one_div, mul_pow, ← hc, pow_add, Nat.add_sub_cancel_left] ring lemma partitionFunction_odds {q : ℝ} (hq : 0 < q) : P.partitionFunction q = (1 / (1 + Real.sqrt q)) ^ P.edges.card * FKFinite.partition P.wireGraph q (Real.sqrt q) P.edges := by unfold partitionFunction FKFinite.partition rw [mul_sum] apply sum_congr rfl intro A hA exact P.configurationWeight_odds hq A (mem_powerset.mp hA) theorem normalized_configurationWeight_odds {q : ℝ} (hq : 0 < q) (A : Finset (Sym2 P.Vertex)) (hA : A ⊆ P.edges) : P.configurationWeight q A / P.partitionFunction q = FKFinite.weight P.wireGraph q (Real.sqrt q) A / FKFinite.partition P.wireGraph q (Real.sqrt q) P.edges := by rw [P.configurationWeight_odds hq A hA,P.partitionFunction_odds hq] exact mul_div_mul_left _ _ (ne_of_gt (pow_pos (one_div_pos.mpr (by have := Real.sqrt_nonneg q; linarith)) _)) end BelowOne.LatticePolygon end end end section noncomputable section open Finset SimpleGraph attribute [local instance] Classical.propDecidable namespace BelowOne.FKPressure variable {V I : Type*} [Finite V] def graph (G : SimpleGraph V) (ends : I → V × V) (A : Finset I) : SimpleGraph V := G ⊔ A.sup (fun e => edge (ends e).1 (ends e).2) def components (G : SimpleGraph V) (ends : I → V × V) (A : Finset I) : ℕ := Nat.card (graph G ends A).ConnectedComponent def partition (G : SimpleGraph V) (ends : I → V × V) (s : ℝ) (w : I → ℝ) (E : Finset I) : ℝ := ∑ A ∈ E.powerset, (∏ e ∈ A, w e) * s ^ components G ends A omit [Finite V] in @[simp] lemma graph_empty (G : SimpleGraph V) (ends : I → V × V) : graph G ends ∅ = G := by simp [graph] omit [Finite V] in lemma graph_mono (G : SimpleGraph V) (ends : I → V × V) {A B : Finset I} (h : A ⊆ B) : graph G ends A ≤ graph G ends B := by exact sup_le_sup_left (Finset.sup_mono h) _ omit [Finite V] in lemma graph_insert (G : SimpleGraph V) (ends : I → V × V) (e : I) (A : Finset I) : graph G ends (insert e A) = graph G ends A ⊔ edge (ends e).1 (ends e).2 := by classical simp [graph, sup_left_comm, sup_comm] omit [Finite V] in lemma graph_contracted (G : SimpleGraph V) (ends : I → V × V) (e : I) (A : Finset I) : graph (G ⊔ edge (ends e).1 (ends e).2) ends A = graph G ends A ⊔ edge (ends e).1 (ends e).2 := by simp [graph, sup_assoc, sup_left_comm, sup_comm] omit [Finite V] in @[simp] lemma partition_empty (G : SimpleGraph V) (ends : I → V × V) (s : ℝ) (w : I → ℝ) : partition G ends s w ∅ = s ^ Nat.card G.ConnectedComponent := by simp [partition, components] omit [Finite V] in lemma deletion_contraction (G : SimpleGraph V) (ends : I → V × V) (s : ℝ) (w : I → ℝ) {e : I} {E : Finset I} (he : e ∉ E) : partition G ends s w (insert e E) = partition G ends s w E + w e * partition (G ⊔ edge (ends e).1 (ends e).2) ends s w E := by classical unfold partition rw [sum_powerset_insert he, mul_sum] congr 1 apply sum_congr rfl intro A hA have heA : e ∉ A := fun h => he (mem_powerset.mp hA h) rw [prod_insert heA] simp only [components,graph_insert,graph_contracted] ring lemma separating_edge_count (G : SimpleGraph V) (ends : I → V × V) {e : I} {E A : Finset I} (h : ¬(graph G ends E).Reachable (ends e).1 (ends e).2) (hA : A ⊆ E) : components (G ⊔ edge (ends e).1 (ends e).2) ends A + 1 = components G ends A := by unfold components rw [graph_contracted] apply FKComponents.component_card_sup_edge_of_not_reachable exact fun hr => h (hr.mono (graph_mono G ends hA)) lemma separating_edge_partition (G : SimpleGraph V) (ends : I → V × V) (s : ℝ) (w : I → ℝ) {e : I} {E : Finset I} (h : ¬(graph G ends E).Reachable (ends e).1 (ends e).2) : partition G ends s w E = s * partition (G ⊔ edge (ends e).1 (ends e).2) ends s w E := by unfold partition rw [mul_sum] apply sum_congr rfl intro A hA rw [← separating_edge_count G ends h (mem_powerset.mp hA),pow_succ] ring theorem negative_partition (G : SimpleGraph V) (ends : I → V × V) {u : ℝ} (hu : 0 < u) (hu1 : u < 1) (w : I → ℝ) (E : Finset I) (hw : ∀ e ∈ E, 1 ≤ w e) (hc : components G ends E = 1) : partition G ends (-u) w E < 0 := by classical induction E using Finset.induction_on generalizing G with | empty => simp only [components,graph_empty] at hc simpa [hc] using neg_neg_of_pos hu | @insert e E he ih => have hwE : ∀ f ∈ E, 1 ≤ w f := fun f hf => hw f (mem_insert_of_mem hf) have hwe : 1 ≤ w e := hw e (mem_insert_self _ _) let G' := G ⊔ edge (ends e).1 (ends e).2 have hc' : components G' ends E = 1 := by simpa only [components,G',graph_contracted,graph_insert] using hc have hp' : partition G' ends (-u) w E < 0 := ih G' hwE hc' rw [deletion_contraction G ends (-u) w he] by_cases hE : components G ends E = 1 · exact add_neg (ih G hwE hE) (mul_neg_of_pos_of_neg (by linarith) hp') · have hsep : ¬(graph G ends E).Reachable (ends e).1 (ends e).2 := by intro hr have hcards := FKComponents.component_card_sup_edge_of_reachable hr apply hE apply hcards.symm.trans simpa only [components,graph_insert] using hc rw [separating_edge_partition G ends (-u) w hsep] change (-u) * partition G' ends (-u) w E + w e * partition G' ends (-u) w E < 0 rw [← add_mul] exact mul_neg_of_pos_of_neg (by linarith) hp' theorem signed_partition_pos (G : SimpleGraph V) (ends : I → V × V) {u : ℝ} (hu : 0 < u) (hu1 : u < 1) (w : I → ℝ) (E : Finset I) (hw : ∀ e ∈ E, 1 ≤ w e) : 0 < (-1 : ℝ) ^ components G ends E * partition G ends (-u) w E := by classical induction E using Finset.induction_on generalizing G with | empty => simp only [components, graph_empty, partition_empty, ← mul_pow, neg_mul_neg, one_mul] exact pow_pos hu _ | @insert e E he ih => have hwE : ∀ f ∈ E, 1 ≤ w f := fun f hf => hw f (mem_insert_of_mem hf) have hwe : 1 ≤ w e := hw e (mem_insert_self _ _) let G' := G ⊔ edge (ends e).1 (ends e).2 have hc' : components G ends (insert e E) = components G' ends E := by simp only [components,G',graph_contracted,graph_insert] have hp' := ih G' hwE rw [hc', deletion_contraction G ends (-u) w he, mul_add] by_cases hr : (graph G ends E).Reachable (ends e).1 (ends e).2 · have hc : components G' ends E = components G ends E := by simp only [components,G',graph_contracted] exact FKComponents.component_card_sup_edge_of_reachable hr have hp := ih G hwE rw [← hc] at hp have hpw := mul_pos (lt_of_lt_of_le zero_lt_one hwe) hp' nlinarith · rw [separating_edge_partition G ends (-u) w hr] change 0 < (-1 : ℝ) ^ components G' ends E * ((-u) * partition G' ends (-u) w E) + (-1 : ℝ) ^ components G' ends E * (w e * partition G' ends (-u) w E) have hpw := mul_pos (show 0 < w e - u by linarith) hp' nlinarith def hardSum (G : SimpleGraph V) (ends : I → V × V) (E : Finset I) : ℝ := ∑ A ∈ E.powerset, if components G ends A = 1 then (-1 : ℝ)^A.card else 0 lemma components_contracted_of_reachable (G : SimpleGraph V) (ends : I → V × V) {e : I} (hr : G.Reachable (ends e).1 (ends e).2) (A : Finset I) : components (G ⊔ edge (ends e).1 (ends e).2) ends A = components G ends A := by unfold components rw [graph_contracted] exact FKComponents.component_card_sup_edge_of_reachable (hr.mono le_sup_left) omit [Finite V] in lemma hardSum_deletion_contraction (G : SimpleGraph V) (ends : I → V × V) {e : I} {E : Finset I} (he : e ∉ E) : hardSum G ends (insert e E) = hardSum G ends E - hardSum (G ⊔ edge (ends e).1 (ends e).2) ends E := by unfold hardSum rw [sum_powerset_insert he,sub_eq_add_neg,← sum_neg_distrib] congr 1 apply sum_congr rfl intro A hA have heA : e ∉ A := fun h => he (mem_powerset.mp hA h) simp only [components,graph_insert,graph_contracted,card_insert_of_notMem heA,pow_succ] split_ifs <;> ring lemma hardSum_eq_zero_of_reachable (G : SimpleGraph V) (ends : I → V × V) {e : I} {E : Finset I} (he : e ∉ E) (hr : G.Reachable (ends e).1 (ends e).2) : hardSum G ends (insert e E) = 0 := by rw [hardSum_deletion_contraction G ends he] have h : hardSum (G ⊔ edge (ends e).1 (ends e).2) ends E = hardSum G ends E := by unfold hardSum congr 1 funext A rw [components_contracted_of_reachable G ends hr] rw [h,sub_self] theorem hardSum_sign (G : SimpleGraph V) (ends : I → V × V) (E : Finset I) : (-1 : ℝ) ^ Nat.card G.ConnectedComponent * hardSum G ends E ≤ 0 := by induction E using Finset.induction_on generalizing G with | empty => simp only [hardSum,powerset_empty,sum_singleton,components,graph_empty,card_empty,pow_zero] split_ifs with h · simp [h] · simp | @insert e E he ih => by_cases hr : G.Reachable (ends e).1 (ends e).2 · rw [hardSum_eq_zero_of_reachable G ends he hr,mul_zero] · have hc := FKComponents.component_card_sup_edge_of_not_reachable hr have h0 := ih G have h1 := ih (G ⊔ edge (ends e).1 (ends e).2) rw [hardSum_deletion_contraction G ends he,mul_sub] have hsign : (-1 : ℝ) ^ Nat.card G.ConnectedComponent = - (-1 : ℝ) ^ Nat.card (G ⊔ edge (ends e).1 (ends e).2).ConnectedComponent := by rw [← hc,pow_succ] ring rw [hsign] at h0 ⊢ nlinarith lemma union_constrained_sum (v : I → ℝ) {A D : Finset I} (hA : A ⊆ D) : (∑ B ∈ D.powerset with A ∪ B = D, ∏ e ∈ B, v e) = (∏ e ∈ D \ A, v e) * ∏ e ∈ A, (1 + v e) := by classical rw [prod_one_add, mul_sum] apply sum_bij' (fun B _ => B ∩ A) (fun C _ => (D \ A) ∪ C) · intro B hB exact mem_powerset.mpr inter_subset_right · intro C hC have hc := mem_powerset.mp hC apply mem_filter.mpr constructor · exact mem_powerset.mpr (union_subset sdiff_subset (hc.trans hA)) · ext e simp only [mem_union, mem_sdiff] constructor · rintro (he | ⟨he, _⟩ | he) · exact hA he · exact he · exact hA (hc he) · intro he by_cases ha : e ∈ A · exact Or.inl ha · exact Or.inr (Or.inl ⟨he, ha⟩) · intro B hB obtain ⟨hb, hab⟩ := mem_filter.mp hB have hbD := mem_powerset.mp hb ext e simp only [mem_union, mem_sdiff, mem_inter] constructor · rintro (⟨hd, ha⟩ | ⟨hb, _⟩) · have he : e ∈ A ∪ B := by rw [hab]; exact hd exact (mem_union.mp he).resolve_left ha · exact hb · intro hb by_cases ha : e ∈ A · exact Or.inr ⟨hb, ha⟩ · exact Or.inl ⟨hbD hb, ha⟩ · intro C hC have hc := mem_powerset.mp hC ext e simp only [mem_inter, mem_union, mem_sdiff] constructor · rintro ⟨(⟨_, hn⟩ | he), ha⟩ · exact (hn ha).elim · exact he · intro he exact ⟨Or.inr he, hc he⟩ · intro B hB obtain ⟨hb, hab⟩ := mem_filter.mp hB have hbD := mem_powerset.mp hb have heq : B = (D \ A) ∪ (B ∩ A) := by ext e simp only [mem_union,mem_sdiff,mem_inter] constructor · intro he by_cases ha : e ∈ A · exact Or.inr ⟨he,ha⟩ · exact Or.inl ⟨hbD he,ha⟩ · rintro (⟨hd,hn⟩ | ⟨he,_⟩) · have he : e ∈ A ∪ B := by rw [hab]; exact hd exact (mem_union.mp he).resolve_left hn · exact he conv_lhs => rw [heq,prod_union (show Disjoint (D \ A) (B ∩ A) from disjoint_left.mpr fun e he he' => (mem_sdiff.mp he).2 (mem_inter.mp he').2)] omit [Finite V] in lemma fixed_union (G : SimpleGraph V) (ends : I → V × V) (v : I → ℝ) (s : ℝ) (D : Finset I) : (∑ A ∈ D.powerset, (∏ e ∈ A, v e) * s ^ components G ends A * ∑ B ∈ D.powerset with A ∪ B = D, ∏ e ∈ B, v e) = (∏ e ∈ D, v e) * partition G ends s (fun e => 1 + v e) D := by unfold partition rw [mul_sum] apply sum_congr rfl intro A hA have ha := mem_powerset.mp hA rw [union_constrained_sum v ha] have hp := prod_sdiff (f := v) ha calc _ = ((∏ e ∈ D \ A, v e) * ∏ e ∈ A, v e) * ((∏ e ∈ A, (1 + v e)) * s ^ components G ends A) := by ring _ = _ := by rw [hp] theorem fixed_union_hard_nonpos {J : Type*} (G : SimpleGraph V) (ends : I → V × V) (hardEnds : J → V × V) (v : I → ℝ) {u : ℝ} (hu : 0 < u) (hu1 : u < 1) (D : Finset I) (H : Finset J) (hv : ∀ e ∈ D, 0 ≤ v e) : (∏ e ∈ D, v e) * partition G ends (-u) (fun e => 1 + v e) D * hardSum (graph G ends D) hardEnds H ≤ 0 := by have hp := signed_partition_pos G ends hu hu1 (fun e => 1 + v e) D (fun e he => by linarith [hv e he]) have hh := hardSum_sign (graph G ends D) hardEnds H change (-1 : ℝ) ^ components G ends D * hardSum (graph G ends D) hardEnds H ≤ 0 at hh have hs : ((-1 : ℝ) ^ components G ends D) ^ 2 = 1 := by rw [← pow_mul, Nat.mul_comm, pow_mul] simp have hph := mul_nonpos_of_nonneg_of_nonpos (le_of_lt hp) hh have hprod : partition G ends (-u) (fun e => 1 + v e) D * hardSum (graph G ends D) hardEnds H ≤ 0 := by nlinarith [sq_nonneg ((-1 : ℝ) ^ components G ends D)] exact (by simpa only [mul_assoc] using mul_nonpos_of_nonneg_of_nonpos (prod_nonneg hv) hprod) end BelowOne.FKPressure end end section noncomputable section open Finset SimpleGraph attribute [local instance] Classical.propDecidable namespace BelowOne.FKPressure variable {V I J : Type*} [Finite V] lemma regroup_union (E : Finset I) (f : Finset I → Finset I → ℝ) : (∑ A ∈ E.powerset, ∑ B ∈ E.powerset, f A B) = ∑ D ∈ E.powerset, ∑ A ∈ D.powerset, ∑ B ∈ D.powerset with A ∪ B = D, f A B := by classical rw [← sum_product'] have hmap : ∀ p ∈ E.powerset ×ˢ E.powerset, p.1 ∪ p.2 ∈ E.powerset := by intro p hp obtain ⟨ha,hb⟩ := mem_product.mp hp exact mem_powerset.mpr (union_subset (mem_powerset.mp ha) (mem_powerset.mp hb)) rw [← sum_fiberwise_of_maps_to hmap] apply sum_congr rfl intro D hD have hd := mem_powerset.mp hD apply sum_finset_product' intro p simp only [mem_filter,mem_product,mem_powerset] constructor · rintro ⟨⟨ha,hb⟩, hab⟩ refine ⟨?_, ?_, hab⟩ · rw [← hab] exact subset_union_left · rw [← hab] exact subset_union_right · rintro ⟨ha,hb, hab⟩ exact ⟨⟨ha.trans hd, hb.trans hd⟩,hab⟩ def connectedSum (G : SimpleGraph V) (ends : I → V × V) (hardEnds : J → V × V) (E : Finset I) (H : Finset J) (s : ℝ) (v : I → ℝ) : ℝ := ∑ A ∈ E.powerset, ∑ B ∈ E.powerset, (∏ e ∈ A, v e) * (∏ e ∈ B, v e) * s ^ components G ends A * hardSum (graph G ends (A ∪ B)) hardEnds H omit [Finite V] in lemma connectedSum_grouped (G : SimpleGraph V) (ends : I → V × V) (hardEnds : J → V × V) (E : Finset I) (H : Finset J) (s : ℝ) (v : I → ℝ) : connectedSum G ends hardEnds E H s v = ∑ D ∈ E.powerset, (∏ e ∈ D, v e) * partition G ends s (fun e => 1 + v e) D * hardSum (graph G ends D) hardEnds H := by unfold connectedSum rw [regroup_union] apply sum_congr rfl intro D hD rw [← fixed_union, sum_mul] apply sum_congr rfl intro A hA rw [mul_sum, sum_mul] apply sum_congr rfl intro B hB have hab := (mem_filter.mp hB).2 rw [hab] ring theorem connectedSum_nonpos (G : SimpleGraph V) (ends : I → V × V) (hardEnds : J → V × V) (E : Finset I) (H : Finset J) {u : ℝ} (hu : 0 < u) (hu1 : u < 1) (v : I → ℝ) (hv : ∀ e ∈ E, 0 ≤ v e) : connectedSum G ends hardEnds E H (-u) v ≤ 0 := by rw [connectedSum_grouped] apply sum_nonpos intro D hD exact fixed_union_hard_nonpos G ends hardEnds v hu hu1 D H (fun e he => hv e (mem_powerset.mp hD he)) end BelowOne.FKPressure end end section noncomputable section open Finset attribute [local instance] Classical.propDecidable namespace BelowOne.PartitionCumulant instance finiteSetoid (α : Type*) [Finite α] : Finite (Setoid α) := Finite.of_injective (fun r : Setoid α => r.r) (fun _ _ h => Setoid.ext (by simp [h])) instance fintypeSetoid (α : Type*) [Finite α] : Fintype (Setoid α) := Fintype.ofFinite _ variable {α : Type*} def extendMap (r : Setoid α) (o : Option (Quotient r)) : Option α → Option (Quotient r) | none => o | some a => some (Quotient.mk r a) def extend (r : Setoid α) (o : Option (Quotient r)) : Setoid (Option α) := Setoid.ker (extendMap r o) @[simp] lemma extend_some (r : Setoid α) (o : Option (Quotient r)) (a b : α) : extend r o (some a) (some b) ↔ r a b := by change some (Quotient.mk r a) = some (Quotient.mk r b) ↔ r a b rw [Option.some.injEq, Quotient.eq] @[simp] lemma extend_none_some (r : Setoid α) (o : Option (Quotient r)) (a : α) : extend r o none (some a) ↔ o = some (Quotient.mk r a) := Iff.rfl @[simp] lemma restrict_extend (r : Setoid α) (o : Option (Quotient r)) : (extend r o).comap some = r := by ext a b exact extend_some r o a b lemma extend_injective (r : Setoid α) : Function.Injective (extend r) := by intro o p h have hh (a : α) : (o = some (Quotient.mk r a)) ↔ (p = some (Quotient.mk r a)) := by simpa only [extend_none_some] using Setoid.ext_iff.mp h none (some a) cases o with | none => cases p with | none => rfl | some q => obtain ⟨a,rfl⟩ := q.exists_rep simpa using (hh a).mpr rfl | some q => obtain ⟨a,rfl⟩ := q.exists_rep exact ((hh a).mp rfl).symm lemma extend_bijective : Function.Bijective (fun p : Σ r : Setoid α, Option (Quotient r) => extend p.1 p.2) := by constructor · rintro ⟨r,o⟩ ⟨s,p⟩ h have hrs : r = s := by simpa using congrArg (Setoid.comap (some : α → Option α)) h subst s have hop : o = p := extend_injective r h subst p rfl · intro s let r := s.comap (some : α → Option α) by_cases h : ∃ a, s none (some a) · obtain ⟨a,ha⟩ := h refine ⟨⟨r,some (Quotient.mk r a)⟩, ?_⟩ apply Setoid.ext intro x y cases x with | none => cases y with | none => simp | some b => simp only [extend_none_some, Option.some.injEq, Quotient.eq] change s (some a) (some b) ↔ s none (some b) exact ⟨fun h => s.trans ha h, fun h => s.trans (s.symm ha) h⟩ | some a' => cases y with | none => change some (Quotient.mk r a') = some (Quotient.mk r a) ↔ s (some a') none rw [Option.some.injEq, Quotient.eq] change s (some a') (some a) ↔ s (some a') none exact ⟨fun h => s.trans h (s.symm ha), fun h => s.trans h ha⟩ | some b => exact extend_some r _ _ _ · refine ⟨⟨r,none⟩, ?_⟩ apply Setoid.ext intro x y cases x with | none => cases y with | none => simp | some b => rw [extend_none_some] exact iff_of_false (by simp) (fun hb => h ⟨b,hb⟩) | some a => cases y with | none => change some (Quotient.mk r a) = none ↔ s (some a) none exact iff_of_false (by simp) (fun ha => h ⟨a,s.symm ha⟩) | some b => exact extend_some r _ _ _ def extensionEquiv : (Σ r : Setoid α, Option (Quotient r)) ≃ Setoid (Option α) := Equiv.ofBijective _ extend_bijective lemma card_extend_none [Finite α] (r : Setoid α) : Nat.card (Quotient (extend r none)) = Nat.card (Quotient r) + 1 := by have hs : Function.Surjective (extendMap r none) := by intro x cases x with | none => exact ⟨none,rfl⟩ | some q => obtain ⟨a,rfl⟩ := q.exists_rep exact ⟨some a,rfl⟩ change Nat.card (Quotient (Setoid.ker (extendMap r none))) = _ rw [Nat.card_congr (Setoid.quotientKerEquivOfSurjective (extendMap r none) hs)] let := Fintype.ofFinite (Quotient r) simp only [Nat.card_eq_fintype_card, Fintype.card_option] lemma card_extend_some [Finite α] (r : Setoid α) (q : Quotient r) : Nat.card (Quotient (extend r (some q))) = Nat.card (Quotient r) := by let f : Option α → Quotient r := Option.elim' q (Quotient.mk r) have he : extend r (some q) = Setoid.ker f := by apply Setoid.ext intro x y change extendMap r (some q) x = extendMap r (some q) y ↔ f x = f y cases x <;> cases y <;> simp [extendMap, f] have hs : Function.Surjective f := by intro p obtain ⟨a,rfl⟩ := p.exists_rep exact ⟨some a,rfl⟩ rw [he] exact Nat.card_congr (Setoid.quotientKerEquivOfSurjective f hs) theorem sum_option [Finite α] (f : ℕ → ℝ) : (∑ s : Setoid (Option α), f (Nat.card (Quotient s))) = ∑ r : Setoid α, (f (Nat.card (Quotient r) + 1) + (Nat.card (Quotient r) : ℝ) * f (Nat.card (Quotient r))) := by classical let := Fintype.ofFinite α let (r : Setoid α) := Fintype.ofFinite (Quotient r) rw [← extensionEquiv.sum_comp, Fintype.sum_sigma] apply sum_congr rfl intro r _ rw [Fintype.sum_option] change f (Nat.card (Quotient (extend r none))) + (∑ x : Quotient r, f (Nat.card (Quotient (extend r (some x))))) = _ simp only [card_extend_none, card_extend_some] simp only [sum_const, card_univ, nsmul_eq_mul, Nat.card_eq_fintype_card] def coefficient (n : ℕ) : ℝ := (-1) ^ (n - 1) * (n - 1).factorial lemma coefficient_recurrence {n : ℕ} (hn : 0 < n) : coefficient (n+1) + (n : ℝ) * coefficient n = 0 := by have hn' : n = (n-1)+1 := by omega simp only [coefficient, Nat.add_sub_cancel] conv_lhs => arg 1; arg 1; rw [hn',pow_succ] have hf : n.factorial = n * (n-1).factorial := by conv_lhs => rw [hn', Nat.factorial_succ] rw [← hn'] rw [hf] push_cast ring theorem sum_coefficient_option [Finite α] [Nonempty α] : (∑ r : Setoid (Option α), coefficient (Nat.card (Quotient r))) = 0 := by rw [sum_option] apply sum_eq_zero intro r _ let : Nonempty (Quotient r) := ⟨Quotient.mk r (Classical.arbitrary α)⟩ exact coefficient_recurrence Nat.card_pos def setoidEquiv {β : Type*} (e : α ≃ β) : Setoid α ≃ Setoid β where toFun r := r.comap e.symm invFun s := s.comap e left_inv r := by apply Setoid.ext intro a b change r (e.symm (e a)) (e.symm (e b)) ↔ r a b simp only [e.symm_apply_apply] right_inv s := by apply Setoid.ext intro a b change s (e (e.symm a)) (e (e.symm b)) ↔ s a b simp only [e.apply_symm_apply] lemma card_relabel {β : Type*} (e : α ≃ β) (r : Setoid α) : Nat.card (Quotient (setoidEquiv e r)) = Nat.card (Quotient r) := by apply Nat.card_congr exact Quotient.congr e.symm (fun _ _ => Iff.rfl) lemma sum_relabel {β : Type*} [Finite α] [Finite β] (e : α ≃ β) (f : ℕ → ℝ) : (∑ r : Setoid α, f (Nat.card (Quotient r))) = ∑ s : Setoid β, f (Nat.card (Quotient s)) := by exact Fintype.sum_equiv (setoidEquiv e) _ _ (fun r => by rw [card_relabel]) lemma sum_coefficient_nontrivial [Finite α] [Nontrivial α] : (∑ r : Setoid α, coefficient (Nat.card (Quotient r))) = 0 := by classical obtain ⟨a,b,hab⟩ := exists_pair_ne α let : Nonempty {x : α // x ≠ a} := ⟨⟨b,hab.symm⟩⟩ rw [← sum_relabel (Equiv.optionSubtypeNe a)] exact sum_coefficient_option lemma sum_coefficient_subsingleton [Finite α] [Subsingleton α] [Nonempty α] : (∑ r : Setoid α, coefficient (Nat.card (Quotient r))) = 1 := by let : Unique (Setoid α) := { default := ⊤ uniq := fun r => Setoid.ext (fun a b => by rw [Subsingleton.elim b a] simp) } rw [Fintype.sum_unique] have hcard : Nat.card (Quotient (default : Setoid α)) = 1 := by apply Nat.card_eq_one_iff_unique.mpr refine ⟨?_, ⟨Quotient.mk _ (Classical.arbitrary α)⟩⟩ refine ⟨fun x y => ?_⟩ induction x using Quotient.inductionOn with | h a => induction y using Quotient.inductionOn with | h b => rw [Subsingleton.elim b a] rw [hcard] norm_num [coefficient] lemma sum_coefficient [Finite α] [Nonempty α] : (∑ r : Setoid α, coefficient (Nat.card (Quotient r))) = if Nat.card α = 1 then 1 else 0 := by classical cases subsingleton_or_nontrivial α with | inl h => let := h rw [sum_coefficient_subsingleton, ite_eq_left (Nat.card_eq_one_iff_unique.mpr ⟨h,inferInstance⟩)] | inr h => let := h rw [sum_coefficient_nontrivial, ite_eq_right] exact fun he => not_subsingleton α (Nat.card_eq_one_iff_unique.mp he).1 def coarseningQuotientEquiv (r s : Setoid α) (h : r ≤ s) : Quotient (Setoid.correspondence r ⟨s,h⟩) ≃ Quotient s := by apply Equiv.trans _ (Setoid.quotientQuotientEquivQuotient r s h) apply Quotient.congrRight intro a b induction a using Quotient.inductionOn with | h x => induction b using Quotient.inductionOn with | h y => change s x y ↔ Quotient.mk s x = Quotient.mk s y exact Quotient.eq.symm theorem sum_coarsenings [Finite α] [Nonempty α] (r : Setoid α) : (∑ s : {s : Setoid α // r ≤ s}, coefficient (Nat.card (Quotient s.1))) = if Nat.card (Quotient r) = 1 then 1 else 0 := by classical let := Fintype.ofFinite (Quotient r) let : Nonempty (Quotient r) := ⟨Quotient.mk r (Classical.arbitrary α)⟩ rw [← sum_coefficient (α := Quotient r)] apply Fintype.sum_equiv (Setoid.correspondence r).toEquiv intro s exact congrArg coefficient (Nat.card_congr (coarseningQuotientEquiv r s.1 s.2)).symm theorem connected_cancellation [Finite α] [Nonempty α] {Ω : Type*} [Fintype Ω] (component : Ω → Setoid α) (weight : Ω → ℝ) : (∑ r : Setoid α, coefficient (Nat.card (Quotient r)) * ∑ ω : Ω, if component ω ≤ r then weight ω else 0) = ∑ ω : Ω, if Nat.card (Quotient (component ω)) = 1 then weight ω else 0 := by classical simp only [mul_sum] rw [sum_comm] apply sum_congr rfl intro ω _ have he : (∑ r : Setoid α, coefficient (Nat.card (Quotient r)) * (if component ω ≤ r then weight ω else 0)) = (∑ r : {r : Setoid α // component ω ≤ r}, coefficient (Nat.card (Quotient r.1))) * weight ω := by rw [sum_mul, ← Finset.sum_subtype (univ.filter (fun r => component ω ≤ r)) (by simp) (fun r => coefficient (Nat.card (Quotient r)) * weight ω), sum_filter] apply sum_congr rfl intro r _ split_ifs <;> simp_all rw [he, sum_coarsenings] split_ifs <;> simp end BelowOne.PartitionCumulant end end section noncomputable section open Finset SimpleGraph attribute [local instance] Classical.propDecidable namespace BelowOne.FKPressure variable {V I J : Type*} [Finite V] def blockStructureSum (G : SimpleGraph V) (ends : I → V × V) (hardEnds : J → V × V) (E : Finset I) (H : Finset J) (s : ℝ) (v : I → ℝ) (r : Setoid V) : ℝ := ∑ A ∈ E.powerset, ∑ B ∈ E.powerset, ∑ L ∈ H.powerset, if (graph (graph G ends (A ∪ B)) hardEnds L).reachableSetoid ≤ r then (∏ e ∈ A, v e) * (∏ e ∈ B, v e) * s ^ components G ends A * (-1 : ℝ)^L.card else 0 theorem exponential_cancellation [Nonempty V] (G : SimpleGraph V) (ends : I → V × V) (hardEnds : J → V × V) (E : Finset I) (H : Finset J) (s : ℝ) (v : I → ℝ) : (∑ r : Setoid V, PartitionCumulant.coefficient (Nat.card (Quotient r)) * blockStructureSum G ends hardEnds E H s v r) = connectedSum G ends hardEnds E H s v := by classical let Ω := (E.powerset ×ˢ E.powerset) ×ˢ H.powerset let component (ω : ((Finset I × Finset I) × Finset J)) : Setoid V := (graph (graph G ends (ω.1.1 ∪ ω.1.2)) hardEnds ω.2).reachableSetoid let weight (ω : ((Finset I × Finset I) × Finset J)) : ℝ := (∏ e ∈ ω.1.1, v e) * (∏ e ∈ ω.1.2, v e) * s ^ components G ends ω.1.1 * (-1 : ℝ)^ω.2.card have hsum (f : ((Finset I × Finset I) × Finset J) → ℝ) : (∑ ω : Ω, f ω.1) = ∑ A ∈ E.powerset, ∑ B ∈ E.powerset, ∑ L ∈ H.powerset, f ((A,B),L) := by rw [Finset.sum_coe_sort Ω f] simp only [Ω, sum_product] have h := PartitionCumulant.connected_cancellation (fun ω : Ω => component ω.1) (fun ω : Ω => weight ω.1) have hs (r : Setoid V) : (∑ ω : Ω, if component ω.1 ≤ r then weight ω.1 else 0) = blockStructureSum G ends hardEnds E H s v r := by exact hsum (fun ω => if component ω ≤ r then weight ω else 0) have hc : (∑ ω : Ω, if Nat.card (Quotient (component ω.1)) = 1 then weight ω.1 else 0) = connectedSum G ends hardEnds E H s v := by rw [hsum (fun ω => if Nat.card (Quotient (component ω)) = 1 then weight ω else 0)] unfold connectedSum hardSum apply sum_congr rfl intro A hA apply sum_congr rfl intro B hB rw [mul_sum] apply sum_congr rfl intro L hL change (if components (graph G ends (A ∪ B)) hardEnds L = 1 then _ else _) = _ split_ifs <;> simp [weight] simpa only [hs, hc] using h theorem logarithmic_structure_nonpos [Nonempty V] (G : SimpleGraph V) (ends : I → V × V) (hardEnds : J → V × V) (E : Finset I) (H : Finset J) {u : ℝ} (hu : 0 < u) (hu1 : u < 1) (v : I → ℝ) (hv : ∀ e ∈ E, 0 ≤ v e) : (∑ r : Setoid V, PartitionCumulant.coefficient (Nat.card (Quotient r)) * blockStructureSum G ends hardEnds E H (-u) v r) ≤ 0 := by rw [exponential_cancellation] exact connectedSum_nonpos G ends hardEnds E H hu hu1 v hv end BelowOne.FKPressure end end section noncomputable section open Finset SimpleGraph Set namespace BelowOne.FKPressure attribute [local instance] Classical.propDecidable variable {V : Type*} [Fintype V] lemma component_card_block_sum (G : SimpleGraph V) (r : Setoid V) (h : G.reachableSetoid ≤ r) : Nat.card G.ConnectedComponent = ∑ q : Quotient r, Nat.card (Quotient (G.reachableSetoid.comap (Subtype.val : Quotient.mk r ⁻¹' {q} → V))) := by classical change Nat.card (Quotient G.reachableSetoid) = _ rw [← Nat.card_congr (Setoid.sigmaQuotientEquivOfLe h)] exact Nat.card_sigma omit [Fintype V] in lemma reachable_induce_block (G : SimpleGraph V) (r : Setoid V) (h : G.reachableSetoid ≤ r) (q : Quotient r) (x y : Quotient.mk r ⁻¹' {q}) : (G.induce (Quotient.mk r ⁻¹' {q})).Reachable x y ↔ G.Reachable x.1 y.1 := by constructor · intro hxy exact hxy.map (SimpleGraph.Embedding.induce _).toHom · rintro ⟨p⟩ have hp : ∀ z ∈ p.support, z ∈ Quotient.mk r ⁻¹' {q} := by intro z hz have hr : r x.1 z := h ⟨p.takeUntil z hz⟩ change Quotient.mk r z = q exact (Quotient.sound hr).symm.trans x.property exact ⟨p.induce _ hp⟩ lemma components_induce_block_sum (G : SimpleGraph V) (r : Setoid V) (h : G.reachableSetoid ≤ r) : Nat.card G.ConnectedComponent = ∑ q : Quotient r, Nat.card (G.induce (Quotient.mk r ⁻¹' {q})).ConnectedComponent := by classical rw [component_card_block_sum G r h] apply sum_congr rfl intro q hq have he : G.reachableSetoid.comap (Subtype.val : Quotient.mk r ⁻¹' {q} → V) = (G.induce (Quotient.mk r ⁻¹' {q})).reachableSetoid := by apply Setoid.ext intro x y exact (reachable_induce_block G r h q x y).symm rw [he] rfl lemma component_weight_block_prod (G : SimpleGraph V) (r : Setoid V) (h : G.reachableSetoid ≤ r) (s : ℝ) : s ^ Nat.card G.ConnectedComponent = ∏ q : Quotient r, s ^ Nat.card (G.induce (Quotient.mk r ⁻¹' {q})).ConnectedComponent := by classical rw [components_induce_block_sum G r h,← Finset.prod_pow_eq_pow_sum] variable {I : Type*} omit [Fintype V] in lemma graph_adj_iff (G : SimpleGraph V) (ends : I → V × V) (A : Finset I) (x y : V) : (graph G ends A).Adj x y ↔ G.Adj x y ∨ ∃ e ∈ A, (edge (ends e).1 (ends e).2).Adj x y := by classical induction A using Finset.induction_on with | empty => simp | @insert e A he ih => simp only [graph_insert,SimpleGraph.sup_adj,ih] aesop omit [Fintype V] in lemma endpoints_reachable (G : SimpleGraph V) (ends : I → V × V) {A : Finset I} {e : I} (he : e ∈ A) : (graph G ends A).Reachable (ends e).1 (ends e).2 := by by_cases h : (ends e).1 = (ends e).2 · rw [h] · apply SimpleGraph.Adj.reachable apply (graph_adj_iff G ends A _ _).mpr exact Or.inr ⟨e,he,(edge_adj _ _ _ _).mpr ⟨Or.inl ⟨rfl,rfl⟩,h⟩⟩ omit [Fintype V] in lemma graph_reachable_le_iff (G : SimpleGraph V) (ends : I → V × V) (A : Finset I) (r : Setoid V) : (graph G ends A).reachableSetoid ≤ r ↔ G.reachableSetoid ≤ r ∧ ∀ e ∈ A, r (ends e).1 (ends e).2 := by constructor · intro h exact ⟨fun x y hxy => h (hxy.mono le_sup_left),fun e he => h (endpoints_reachable G ends he)⟩ · rintro ⟨hG,hA⟩ x y ⟨p⟩ apply Quotient.exact apply FKComponents.eq_of_walk (f := Quotient.mk r) (p := p) intro x y hxy apply Quotient.sound rcases (graph_adj_iff G ends A x y).mp hxy with hxy | ⟨e,he,hexy⟩ · exact hG hxy.reachable · rcases (edge_adj _ _ _ _).mp hexy with ⟨⟨rfl,rfl⟩ | ⟨rfl,rfl⟩,_⟩ · exact hA e he · exact r.symm (hA e he) def edgeBlock (r : Setoid V) (ends : I → V × V) (e : I) : Quotient r := Quotient.mk r (ends e).1 omit [Fintype V] in lemma graph_induce_filter (G : SimpleGraph V) (r : Setoid V) (ends : I → V × V) (A : Finset I) (q : Quotient r) : (graph G ends (A.filter (edgeBlock r ends · = q))).induce (Quotient.mk r ⁻¹' {q}) = (graph G ends A).induce (Quotient.mk r ⁻¹' {q}) := by classical ext x y simp only [SimpleGraph.induce_adj,graph_adj_iff,mem_filter] constructor · rintro (h | ⟨e,⟨he,_⟩,hxy⟩) · exact Or.inl h · exact Or.inr ⟨e,he,hxy⟩ · rintro (h | ⟨e,he,hxy⟩) · exact Or.inl h · refine Or.inr ⟨e,⟨he,?_⟩,hxy⟩ rcases (edge_adj _ _ _ _).mp hxy with ⟨h | h,_⟩ · change Quotient.mk r (ends e).1 = q rw [← h.1] exact x.2 · change Quotient.mk r (ends e).1 = q rw [← h.2] exact y.2 end BelowOne.FKPressure end end section noncomputable section open Finset namespace BelowOne.SubsetSplitting variable {I Q : Type*} [Fintype Q] attribute [local instance] Classical.propDecidable abbrev Selection (E : Finset I) := ↥E.powerset def fiber (E : Finset I) (f : I → Q) (q : Q) : Finset I := E.filter (f · = q) def split (E : Finset I) (f : I → Q) (A : Selection E) (q : Q) : Selection (fiber E f q) := ⟨A.1.filter (f · = q), mem_powerset.mpr (by intro e he have h := mem_filter.mp he exact mem_filter.mpr ⟨mem_powerset.mp A.2 h.1,h.2⟩)⟩ def join (E : Finset I) (f : I → Q) (B : ∀ q, Selection (fiber E f q)) : Selection E := ⟨univ.biUnion (fun q => (B q).1),mem_powerset.mpr (by intro e he obtain ⟨q,_,hq⟩ := mem_biUnion.mp he exact mem_filter.mp (mem_powerset.mp (B q).2 hq) |>.1)⟩ lemma join_split (E : Finset I) (f : I → Q) (A : Selection E) : join E f (split E f A) = A := by classical apply Subtype.ext ext e simp only [join,split,mem_biUnion,mem_univ,true_and,mem_filter] constructor · rintro ⟨q,he,_⟩ exact he · intro he exact ⟨f e,he,rfl⟩ lemma split_join (E : Finset I) (f : I → Q) (B : ∀ q, Selection (fiber E f q)) : split E f (join E f B) = B := by classical funext q apply Subtype.ext ext e simp only [split,join,mem_filter,mem_biUnion,mem_univ,true_and] constructor · rintro ⟨⟨r,he⟩,hq⟩ have hr := mem_filter.mp (mem_powerset.mp (B r).2 he) |>.2 have hqr : q = r := hq.symm.trans hr cases hqr exact he · intro he exact ⟨⟨q,he⟩,mem_filter.mp (mem_powerset.mp (B q).2 he) |>.2⟩ def selectionEquiv (E : Finset I) (f : I → Q) : Selection E ≃ (∀ q, Selection (fiber E f q)) where toFun := split E f invFun := join E f left_inv := join_split E f right_inv := split_join E f lemma sum_factorization (E : Finset I) (f : I → Q) (W : Finset I → ℝ) (w : Q → Finset I → ℝ) (hW : ∀ A ⊆ E, W A = ∏ q, w q (A.filter (f · = q))) : (∑ A ∈ E.powerset, W A) = ∏ q, ∑ A ∈ (fiber E f q).powerset, w q A := by classical have hs : (∑ A : Selection E, W A.1) = ∑ B : (∀ q, Selection (fiber E f q)), ∏ q, w q (B q).1 := by apply Fintype.sum_equiv (selectionEquiv E f) intro A exact hW A.1 (mem_powerset.mp A.2) have hp := Fintype.prod_sum (fun q (A : Selection (fiber E f q)) => w q A.1) simpa only [Selection,Finset.sum_coe_sort] using hs.trans hp.symm def piTripleEquiv {Q : Type*} (A B C : Q → Type*) : ((∀ q, A q) × (∀ q, B q) × (∀ q, C q)) ≃ (∀ q, A q × B q × C q) where toFun p q := (p.1 q,p.2.1 q,p.2.2 q) invFun p := (fun q => (p q).1, fun q => (p q).2.1, fun q => (p q).2.2) left_inv p := rfl right_inv p := by funext q; rfl lemma sum_triple_coe {I J K : Type*} (E : Finset I) (F : Finset J) (H : Finset K) (W : I → J → K → ℝ) : (∑ p : E × F × H, W p.1.1 p.2.1.1 p.2.2.1) = ∑ a ∈ E, ∑ b ∈ F, ∑ c ∈ H, W a b c := by simp only [Fintype.sum_prod_type] rw [show (∑ a : E, ∑ b : F, ∑ c : H, W a.1 b.1 c.1) = ∑ a ∈ E, ∑ b : F, ∑ c : H, W a b.1 c.1 from Finset.sum_coe_sort E (fun a => ∑ b : F, ∑ c : H, W a b.1 c.1)] apply sum_congr rfl intro a ha rw [show (∑ b : F, ∑ c : H, W a b.1 c.1) = ∑ b ∈ F, ∑ c : H, W a b c.1 from Finset.sum_coe_sort F (fun b => ∑ c : H, W a b c.1)] simp only [Finset.sum_coe_sort] lemma sum_factorization_three {J K : Type*} (E : Finset I) (F : Finset J) (H : Finset K) (f : I → Q) (g : J → Q) (h : K → Q) (W : Finset I → Finset J → Finset K → ℝ) (w : Q → Finset I → Finset J → Finset K → ℝ) (hW : ∀ A ⊆ E, ∀ B ⊆ F, ∀ C ⊆ H, W A B C = ∏ q, w q (A.filter (f · = q)) (B.filter (g · = q)) (C.filter (h · = q))) : (∑ A ∈ E.powerset, ∑ B ∈ F.powerset, ∑ C ∈ H.powerset, W A B C) = ∏ q, ∑ A ∈ (fiber E f q).powerset, ∑ B ∈ (fiber F g q).powerset, ∑ C ∈ (fiber H h q).powerset, w q A B C := by classical let e := (Equiv.prodCongr (selectionEquiv E f) (Equiv.prodCongr (selectionEquiv F g) (selectionEquiv H h))).trans (piTripleEquiv _ _ _) have hs : (∑ p : Selection E × Selection F × Selection H, W p.1.1 p.2.1.1 p.2.2.1) = ∑ p : (∀ q, Selection (fiber E f q) × Selection (fiber F g q) × Selection (fiber H h q)), ∏ q, w q (p q).1.1 (p q).2.1.1 (p q).2.2.1 := by apply Fintype.sum_equiv e intro p exact hW p.1.1 (mem_powerset.mp p.1.2) p.2.1.1 (mem_powerset.mp p.2.1.2) p.2.2.1 (mem_powerset.mp p.2.2.2) have hp := Fintype.prod_sum (fun q (p : Selection (fiber E f q) × Selection (fiber F g q) × Selection (fiber H h q)) => w q p.1.1 p.2.1.1 p.2.2.1) have hh := hs.trans hp.symm change (∑ p : E.powerset × F.powerset × H.powerset, _) = ∏ q, ∑ p : (fiber E f q).powerset × (fiber F g q).powerset × (fiber H h q).powerset, _ at hh rw [sum_triple_coe] at hh simpa only [sum_triple_coe] using hh end BelowOne.SubsetSplitting end end section noncomputable section open Finset SimpleGraph namespace BelowOne.FKPressure attribute [local instance] Classical.propDecidable variable {V I J : Type*} [Fintype V] lemma filter_classical (E : Finset I) (p : I → Prop) (d : DecidablePred p) : @Finset.filter I p d E = @Finset.filter I p (fun e => Classical.propDecidable (p e)) E := by exact @Finset.filter_congr_decidable I E p d (fun e => Classical.propDecidable (p e)) lemma powerset_filter_eq (E : Finset I) (p : I → Prop) : (E.filter p).powerset = E.powerset.filter (fun A => ∀ e ∈ A, p e) := by classical ext A simp only [mem_powerset,mem_filter] constructor · intro h exact ⟨fun e he => (mem_filter.mp (h he)).1,fun e he => (mem_filter.mp (h he)).2⟩ · rintro ⟨h₁,h₂⟩ e he exact mem_filter.mpr ⟨h₁ he,h₂ e he⟩ lemma sum_powerset_filter (E : Finset I) (p : I → Prop) (W : Finset I → ℝ) : (∑ A ∈ E.powerset, if ∀ e ∈ A, p e then W A else 0) = ∑ A ∈ (E.filter p).powerset, W A := by rw [powerset_filter_eq,sum_filter] omit [Fintype V] in lemma confinement_iff (G : SimpleGraph V) (ends : I → V × V) (hardEnds : J → V × V) (A B : Finset I) (L : Finset J) (r : Setoid V) (hG : G.reachableSetoid ≤ r) : (graph (graph G ends (A ∪ B)) hardEnds L).reachableSetoid ≤ r ↔ (∀ e ∈ A, r (ends e).1 (ends e).2) ∧ (∀ e ∈ B, r (ends e).1 (ends e).2) ∧ (∀ e ∈ L, r (hardEnds e).1 (hardEnds e).2) := by rw [graph_reachable_le_iff,graph_reachable_le_iff] simp only [hG,true_and,mem_union,or_imp,forall_and,and_assoc] omit [Fintype V] in lemma blockStructureSum_restrict (G : SimpleGraph V) (ends : I → V × V) (hardEnds : J → V × V) (E : Finset I) (H : Finset J) (s : ℝ) (v : I → ℝ) (r : Setoid V) (hG : G.reachableSetoid ≤ r) : blockStructureSum G ends hardEnds E H s v r = ∑ A ∈ (E.filter (fun e => r (ends e).1 (ends e).2)).powerset, ∑ B ∈ (E.filter (fun e => r (ends e).1 (ends e).2)).powerset, ∑ L ∈ (H.filter (fun e => r (hardEnds e).1 (hardEnds e).2)).powerset, (∏ e ∈ A, v e) * (∏ e ∈ B, v e) * s ^ components G ends A * (-1 : ℝ)^L.card := by unfold blockStructureSum simp_rw [confinement_iff G ends hardEnds _ _ _ r hG] rw [← sum_powerset_filter E (fun e => r (ends e).1 (ends e).2)] apply sum_congr rfl intro A hA by_cases ha : ∀ e ∈ A, r (ends e).1 (ends e).2 · have eqa : (∀ e ∈ A, r (ends e).1 (ends e).2) = True := propext (iff_true_intro ha) simp only [eqa,true_and,ite_true] rw [← sum_powerset_filter E (fun e => r (ends e).1 (ends e).2)] apply sum_congr rfl intro B hB by_cases hb : ∀ e ∈ B, r (ends e).1 (ends e).2 · have eqb : (∀ e ∈ B, r (ends e).1 (ends e).2) = True := propext (iff_true_intro hb) simp only [eqb,true_and,ite_true] rw [sum_powerset_filter] · simp [hb] · simp [ha] def inducedBlockMoment (G : SimpleGraph V) (ends : I → V × V) (hardEnds : J → V × V) (E : Finset I) (H : Finset J) (s : ℝ) (v : I → ℝ) (r : Setoid V) (q : Quotient r) : ℝ := ∑ A ∈ (E.filter (fun e => r (ends e).1 (ends e).2 ∧ edgeBlock r ends e = q)).powerset, ∑ B ∈ (E.filter (fun e => r (ends e).1 (ends e).2 ∧ edgeBlock r ends e = q)).powerset, ∑ L ∈ (H.filter (fun e => r (hardEnds e).1 (hardEnds e).2 ∧ edgeBlock r hardEnds e = q)).powerset, (∏ e ∈ A, v e) * (∏ e ∈ B, v e) * s ^ Nat.card ((graph G ends A).induce (Quotient.mk r ⁻¹' {q})).ConnectedComponent * (-1 : ℝ)^L.card lemma structure_weight_factor (G : SimpleGraph V) (ends : I → V × V) (hardEnds : J → V × V) (A B : Finset I) (L : Finset J) (s : ℝ) (v : I → ℝ) (r : Setoid V) (hA : (graph G ends A).reachableSetoid ≤ r) : (∏ e ∈ A, v e) * (∏ e ∈ B, v e) * s ^ components G ends A * (-1 : ℝ)^L.card = ∏ q : Quotient r, (∏ e ∈ A.filter (edgeBlock r ends · = q), v e) * (∏ e ∈ B.filter (edgeBlock r ends · = q), v e) * s ^ Nat.card ((graph G ends (A.filter (edgeBlock r ends · = q))).induce (Quotient.mk r ⁻¹' {q})).ConnectedComponent * (-1 : ℝ)^(L.filter (edgeBlock r hardEnds · = q)).card := by classical simp_rw [graph_induce_filter,Finset.prod_mul_distrib] rw [prod_fiberwise,prod_fiberwise] congr 1 · congr 1 exact component_weight_block_prod (graph G ends A) r hA s · simpa only [prod_const] using (prod_fiberwise L (edgeBlock r hardEnds) (fun _ => (-1:ℝ))).symm lemma blockStructureSum_factorization (G : SimpleGraph V) (ends : I → V × V) (hardEnds : J → V × V) (E : Finset I) (H : Finset J) (s : ℝ) (v : I → ℝ) (r : Setoid V) (hG : G.reachableSetoid ≤ r) : blockStructureSum G ends hardEnds E H s v r = ∏ q : Quotient r, inducedBlockMoment G ends hardEnds E H s v r q := by rw [blockStructureSum_restrict G ends hardEnds E H s v r hG] have hf := SubsetSplitting.sum_factorization_three (E.filter (fun e => r (ends e).1 (ends e).2)) (E.filter (fun e => r (ends e).1 (ends e).2)) (H.filter (fun e => r (hardEnds e).1 (hardEnds e).2)) (edgeBlock r ends) (edgeBlock r ends) (edgeBlock r hardEnds) (fun A B L => (∏ e ∈ A, v e) * (∏ e ∈ B, v e) * s ^ components G ends A * (-1 : ℝ)^L.card) (fun q A B L => (∏ e ∈ A, v e) * (∏ e ∈ B, v e) * s ^ Nat.card ((graph G ends A).induce (Quotient.mk r ⁻¹' {q})).ConnectedComponent * (-1 : ℝ)^L.card) (by intro A hA B hB L hL simpa only [filter_classical] using structure_weight_factor G ends hardEnds A B L s v r ((graph_reachable_le_iff G ends A r).mpr ⟨hG,fun e he => (mem_filter.mp (hA he)).2⟩)) simpa only [SubsetSplitting.fiber,filter_filter,inducedBlockMoment,filter_classical] using hf end BelowOne.FKPressure end end section noncomputable section open Finset open scoped Classical namespace BelowOne.MultiaffineDerivative variable {V : Type*} [Fintype V] abbrev coordinate (i : V) : (V → ℝ) := Pi.single i 1 def restrict (T : Finset V) : (V → ℝ) →L[ℝ] (T → ℝ) := ContinuousLinearMap.pi (fun i => ContinuousLinearMap.proj i.1) omit [Fintype V] in lemma restrict_apply (T : Finset V) (x : V → ℝ) (i : T) : restrict T x i = x i.1 := rfl def Matches {n : ℕ} (τ : Fin n → V) {T : Finset V} (e : Fin n ↪ T) : Prop := ∀ t : T, ∃ i, e i = t ∧ τ i = t.1 omit [Fintype V] in lemma matches_iff {n : ℕ} (τ : Fin n → V) {T : Finset V} (e : Fin n ↪ T) : Matches τ e ↔ (∀ i, τ i = (e i).1) ∧ Function.Surjective e := by constructor · intro h constructor · intro i obtain ⟨j,hj,hτ⟩ := h (e i) have hji := e.injective hj simpa [hji] using hτ · intro t obtain ⟨i,hi,_⟩ := h t exact ⟨i,hi⟩ · rintro ⟨hτ,he⟩ t obtain ⟨i,rfl⟩ := he t exact ⟨i,rfl,hτ i⟩ omit [Fintype V] in lemma matches_data {n : ℕ} {τ : Fin n → V} {T : Finset V} {e : Fin n ↪ T} (h : Matches τ e) : Function.Injective τ ∧ univ.image τ = T := by obtain ⟨hτ,he⟩ := (matches_iff τ e).mp h constructor · intro i j hij apply e.injective apply Subtype.ext rw [←hτ i,←hτ j,hij] · ext t simp only [mem_image,mem_univ,true_and] constructor · rintro ⟨i,rfl⟩ rw [hτ i] exact (e i).2 · intro ht obtain ⟨i,hi⟩ := he ⟨t,ht⟩ exact ⟨i,(hτ i).trans (congrArg Subtype.val hi)⟩ omit [Fintype V] in lemma matches_unique {n : ℕ} {τ : Fin n → V} {T : Finset V} {e f : Fin n ↪ T} (he : Matches τ e) (hf : Matches τ f) : e = f := by ext i exact ((matches_iff τ e).mp he).1 i |>.symm.trans (((matches_iff τ f).mp hf).1 i) def matchingEmbedding {n : ℕ} (τ : Fin n → V) (T : Finset V) (h : Function.Injective τ ∧ univ.image τ = T) : Fin n ↪ T where toFun i := ⟨τ i,by rw [←h.2]; exact mem_image_of_mem τ (mem_univ i)⟩ inj' := fun i j hij => h.1 (congrArg Subtype.val hij) omit [Fintype V] in lemma matchingEmbedding_matches {n : ℕ} (τ : Fin n → V) (T : Finset V) (h : Function.Injective τ ∧ univ.image τ = T) : Matches τ (matchingEmbedding τ T h) := by intro t have ht : t.1 ∈ univ.image τ := by rw [h.2]; exact t.2 obtain ⟨i,_,hi⟩ := mem_image.mp ht refine ⟨i,?_,hi⟩ exact Subtype.ext hi omit [Fintype V] in lemma sum_matches {n : ℕ} (τ : Fin n → V) (T : Finset V) : (∑ e : Fin n ↪ T, if Matches τ e then (1:ℝ) else 0) = if Function.Injective τ ∧ univ.image τ = T then 1 else 0 := by by_cases h : Function.Injective τ ∧ univ.image τ = T · rw [ite_eq_left h] let e := matchingEmbedding τ T h have he := matchingEmbedding_matches τ T h rw [Fintype.sum_eq_single e] · exact ite_eq_left he · intro f hf exact ite_eq_right (fun hh => hf (matches_unique hh he)) · rw [ite_eq_right h] apply sum_eq_zero intro e he exact ite_eq_right (fun hh => h (matches_data hh)) omit [Fintype V] in lemma factor_indicator {n : ℕ} (τ : Fin n → V) (T : Finset V) (e : Fin n ↪ T) (t : T) : (if ht : t ∈ Set.range e then coordinate (τ (e.toEquivRange.symm ⟨t,ht⟩)) t.1 else 0) = if ∃ i, e i = t ∧ τ i = t.1 then (1:ℝ) else 0 := by by_cases ht : t ∈ Set.range e · obtain ⟨i,rfl⟩ := ht rw [dite_eq_left (Set.mem_range_self i)] have hi : e.toEquivRange.symm ⟨e i, Set.mem_range_self i⟩ = i := e.toEquivRange.symm_apply_apply i rw [hi] simp [coordinate,Pi.single_apply,e.injective.eq_iff,eq_comm] · rw [dite_eq_right ht,ite_eq_right] rintro ⟨i,hi,_⟩ exact ht ⟨i,hi⟩ lemma prod_indicator {T : Type*} [Fintype T] (p : T → Prop) : (∏ t : T, if p t then (1:ℝ) else 0) = if ∀ t, p t then 1 else 0 := by by_cases h : ∀ t, p t · simp [h] · rw [ite_eq_right h] obtain ⟨t,ht⟩ := not_forall.mp h exact Finset.prod_eq_zero (mem_univ t) (ite_eq_right ht) lemma ite_classical {α : Sort*} (p : Prop) (d : Decidable p) (a b : α) : @ite α p d a b = @ite α p (Classical.propDecidable p) a b := by cases d <;> simp_all lemma dite_classical {α : Sort*} (p : Prop) (d : Decidable p) (a : p → α) (b : ¬p → α) : @dite α p d a b = @dite α p (Classical.propDecidable p) a b := by cases d <;> simp_all lemma range_equiv_classical {α β : Type*} [Fintype α] (d : DecidableEq β) (e : α ↪ β) : @Function.Embedding.toEquivRange α β _ d e = @Function.Embedding.toEquivRange α β _ (fun a b => Classical.propDecidable (a = b)) e := by ext i rfl lemma monomial_derivative {n : ℕ} (τ : Fin n → V) (T : Finset V) : iteratedFDeriv ℝ n (fun x : V → ℝ => ∏ i ∈ T, x i) 0 (coordinate ∘ τ) = if Function.Injective τ ∧ univ.image τ = T then 1 else 0 := by let f := ContinuousMultilinearMap.mkPiAlgebra ℝ T ℝ have hf : (fun x : V → ℝ => ∏ i ∈ T, x i) = f ∘ restrict T := by funext x simp only [Function.comp_apply,f,ContinuousMultilinearMap.mkPiAlgebra_apply,restrict_apply] exact (Finset.prod_coe_sort T x).symm rw [hf,ContinuousLinearMap.iteratedFDeriv_comp_right _ f.contDiff _ le_rfl] rw [f.iteratedFDeriv_eq] simp only [ContinuousMultilinearMap.compContinuousLinearMap_apply, ContinuousMultilinearMap.iteratedFDeriv,_root_.sum_apply, ContinuousMultilinearMap.iteratedFDerivComponent_apply, ContinuousLinearMap.map_zero,Pi.zero_apply, Function.comp_apply,restrict_apply,f,ContinuousMultilinearMap.mkPiAlgebra_apply] trans ∑ e : Fin n ↪ T, if Matches τ e then (1:ℝ) else 0 · apply sum_congr rfl intro e he trans ∏ t : T, if ∃ i, e i = t ∧ τ i = t.1 then (1:ℝ) else 0 · apply prod_congr rfl intro t ht simpa only [range_equiv_classical,ite_classical,dite_classical] using factor_indicator τ T e t · by_cases hm : Matches τ e · rw [ite_eq_left hm] apply prod_eq_one intro t ht exact ite_eq_left (hm t) · rw [ite_eq_right hm] obtain ⟨t,ht⟩ := not_forall.mp hm exact prod_eq_zero (mem_univ t) (ite_eq_right ht) · exact sum_matches τ T end BelowOne.MultiaffineDerivative end end section noncomputable section open Finset open scoped Classical ContDiff namespace BelowOne.MultiaffineDerivative variable {V : Type*} [Fintype V] lemma contDiff_monomial (T : Finset V) (n : ℕ∞ω) : ContDiff ℝ n (fun x : V → ℝ => ∏ i ∈ T, x i) := by fun_prop lemma weighted_monomial_derivative {n : ℕ} (τ : Fin n → V) (T : Finset V) (c : ℝ) : iteratedFDeriv ℝ n (fun x : V → ℝ => c * ∏ i ∈ T, x i) 0 (coordinate ∘ τ) = if Function.Injective τ ∧ univ.image τ = T then c else 0 := by change iteratedFDeriv ℝ n (fun x : V → ℝ => c • ∏ i ∈ T, x i) 0 (coordinate ∘ τ) = _ rw [iteratedFDeriv_const_smul_apply' (contDiff_monomial T n).contDiffAt] simp only [_root_.smul_apply,smul_eq_mul,monomial_derivative] split_ifs <;> simp def polynomial (W : Finset V → ℝ) (x : V → ℝ) : ℝ := ∑ T : Finset V, W T * ∏ i ∈ T, x i lemma contDiff_polynomial (W : Finset V → ℝ) (n : ℕ∞ω) : ContDiff ℝ n (polynomial W) := by unfold polynomial fun_prop lemma polynomial_derivative (W : Finset V → ℝ) {n : ℕ} (τ : Fin n → V) : iteratedFDeriv ℝ n (polynomial W) 0 (coordinate ∘ τ) = if Function.Injective τ then W (univ.image τ) else 0 := by unfold polynomial rw [iteratedFDeriv_fun_sum_apply (fun T hT => (contDiff_const.mul (contDiff_monomial T n)).contDiffAt)] simp only [_root_.sum_apply,weighted_monomial_derivative] by_cases hτ : Function.Injective τ · simp only [hτ,true_and,ite_true] simp [eq_comm] · simp [hτ] lemma polynomial_zero (W : Finset V → ℝ) : polynomial W 0 = W ∅ := by have h := polynomial_derivative W (fun i : Fin 0 => i.elim0) simpa only [iteratedFDeriv_zero_apply,Finset.univ_eq_empty,Finset.image_empty, Function.injective_of_subsingleton,ite_true] using h end BelowOne.MultiaffineDerivative end end section noncomputable section open Finset Function Set namespace BelowOne.OrderedPartitionBridge variable {n : ℕ} def partition (c : OrderedFinpartition n) : Setoid (Fin n) := Setoid.ker c.index lemma index_emb (c : OrderedFinpartition n) (i : Fin c.length) (j : Fin (c.partSize i)) : c.index (c.emb i j) = i := by exact congrArg Sigma.fst (c.equivSigma.left_inv ⟨i,j⟩) lemma index_surjective (c : OrderedFinpartition n) : Surjective c.index := by intro i exact ⟨c.emb i ⟨0,c.partSize_pos i⟩,index_emb c i _⟩ lemma card_partition (c : OrderedFinpartition n) : Nat.card (Quotient (partition c)) = c.length := by unfold partition rw [Nat.card_congr (Setoid.quotientKerEquivOfSurjective c.index (index_surjective c)),Nat.card_fin] def maximum (c : OrderedFinpartition n) (i : Fin c.length) : Fin n := c.emb i ⟨c.partSize i - 1, Nat.sub_one_lt_of_lt (c.partSize_pos i)⟩ lemma index_maximum (c : OrderedFinpartition n) (i : Fin c.length) : c.index (maximum c i) = i := index_emb c _ _ lemma le_maximum (c : OrderedFinpartition n) (x : Fin n) : x ≤ maximum c (c.index x) := by nth_rw 1 [← c.emb_invEmbedding x] exact (c.emb_strictMono _).monotone (Fin.le_iff_val_le_val.mpr (Nat.le_sub_one_of_lt (c.invEmbedding x).isLt)) lemma relation_iff_range (c : OrderedFinpartition n) (i : Fin c.length) (x : Fin n) : c.index x = i ↔ x ∈ Set.range (c.emb i) := by constructor · intro h subst i exact ⟨c.invEmbedding x,c.emb_invEmbedding x⟩ · rintro ⟨j,rfl⟩ exact index_emb c _ _ lemma maximum_eq_of_partition_eq (c d : OrderedFinpartition n) (h : partition c = partition d) (x : Fin n) : maximum c (c.index x) = maximum d (d.index x) := by apply le_antisymm · have hr : d.index (maximum c (c.index x)) = d.index x := by apply (Setoid.ext_iff.mp h _ _).mp exact index_maximum c _ simpa only [hr] using le_maximum d (maximum c (c.index x)) · have hr : c.index (maximum d (d.index x)) = c.index x := by apply (Setoid.ext_iff.mp h _ _).mpr exact index_maximum d _ simpa only [hr] using le_maximum c (maximum d (d.index x)) lemma partition_injective : Injective (partition (n := n)) := by intro c d h have hl : c.length = d.length := (card_partition c).symm.trans ((congrArg (fun r : Setoid (Fin n) => Nat.card (Quotient r)) h).trans (card_partition d)) have hm : Set.range (maximum c) = Set.range (maximum d) := by ext x constructor · rintro ⟨i,rfl⟩ refine ⟨d.index (maximum c i),?_⟩ simpa only [index_maximum] using (maximum_eq_of_partition_eq c d h (maximum c i)).symm · rintro ⟨i,rfl⟩ refine ⟨c.index (maximum d i),?_⟩ simpa only [index_maximum] using maximum_eq_of_partition_eq c d h (maximum d i) cases c with | mk cl cs cp ce cm co cd cc => cases d with | mk dl ds dp de dm do' dd dc => dsimp only at hl subst dl have hmax : (fun i => ce i ⟨cs i - 1,Nat.sub_one_lt_of_lt (cp i)⟩) = (fun i => de i ⟨ds i - 1,Nat.sub_one_lt_of_lt (dp i)⟩) := co.range_inj_of_wellFoundedLT do' |>.mp hm have hr (i : Fin cl) : Set.range (ce i) = Set.range (de i) := by ext x let c' : OrderedFinpartition n := ⟨cl,cs,cp,ce,cm,co,cd,cc⟩ let d' : OrderedFinpartition n := ⟨cl,ds,dp,de,dm,do',dd,dc⟩ rw [← relation_iff_range c' i x,← relation_iff_range d' i x] have hx := Setoid.ext_iff.mp h x (ce i ⟨cs i-1,Nat.sub_one_lt_of_lt (cp i)⟩) change (c'.index x = c'.index (ce i ⟨cs i-1,Nat.sub_one_lt_of_lt (cp i)⟩)) ↔ (d'.index x = d'.index (ce i ⟨cs i-1,Nat.sub_one_lt_of_lt (cp i)⟩)) at hx have hci : c'.index (ce i ⟨cs i-1,Nat.sub_one_lt_of_lt (cp i)⟩) = i := index_emb c' _ _ have hdi : d'.index (ce i ⟨cs i-1,Nat.sub_one_lt_of_lt (cp i)⟩) = i := by rw [congrFun hmax i] exact index_emb d' _ _ simpa only [hci,hdi] using hx have hs : cs = ds := by funext i have hh := Nat.card_congr (Set.equivOfEq (hr i)) simpa only [Nat.card_range_of_injective (cm i).injective, Nat.card_range_of_injective (dm i).injective, Nat.card_fin] using hh subst ds have he : ce = de := by funext i exact ((cm i).range_inj_of_wellFoundedLT (dm i)).mp (hr i) subst de rfl def block (r : Setoid (Fin n)) (x : Fin n) : Finset (Fin n) := by classical exact univ.filter (r x) @[simp] lemma mem_block (r : Setoid (Fin n)) (x y : Fin n) : y ∈ block r x ↔ r x y := by classical simp [block] lemma block_nonempty (r : Setoid (Fin n)) (x : Fin n) : (block r x).Nonempty := ⟨x,(mem_block r x x).mpr (r.refl x)⟩ lemma block_eq (r : Setoid (Fin n)) {x y : Fin n} (h : r x y) : block r x = block r y := by ext z simp only [mem_block] exact ⟨fun hx => r.trans (r.symm h) hx,fun hy => r.trans h hy⟩ def blockMax (r : Setoid (Fin n)) (x : Fin n) : Fin n := (block r x).max' (block_nonempty r x) lemma blockMax_related (r : Setoid (Fin n)) (x : Fin n) : r x (blockMax r x) := (mem_block r x _).mp (max'_mem _ _) lemma blockMax_eq (r : Setoid (Fin n)) {x y : Fin n} (h : r x y) : blockMax r x = blockMax r y := by simp only [blockMax,block_eq r h] def maxima (r : Setoid (Fin n)) : Finset (Fin n) := by classical exact univ.image (blockMax r) lemma maximum_fixed (r : Setoid (Fin n)) {x : Fin n} (h : x ∈ maxima r) : blockMax r x = x := by classical obtain ⟨y,_,rfl⟩ := mem_image.mp h exact (blockMax_eq r (blockMax_related r y)).symm lemma blockMax_mem (r : Setoid (Fin n)) (x : Fin n) : blockMax r x ∈ maxima r := by classical exact mem_image_of_mem _ (mem_univ x) def ofSetoid (r : Setoid (Fin n)) : OrderedFinpartition n where length := (maxima r).card partSize i := (block r ((maxima r).orderEmbOfFin rfl i)).card partSize_pos i := card_pos.mpr (block_nonempty r _) emb i := (block r ((maxima r).orderEmbOfFin rfl i)).orderEmbOfFin rfl emb_strictMono i := OrderEmbedding.strictMono _ parts_strictMono := by have hm (i : Fin (maxima r).card) : (block r ((maxima r).orderEmbOfFin rfl i)).orderEmbOfFin rfl ⟨(block r ((maxima r).orderEmbOfFin rfl i)).card-1, Nat.sub_one_lt_of_lt (card_pos.mpr (block_nonempty r _))⟩ = (maxima r).orderEmbOfFin rfl i := by rw [orderEmbOfFin_last rfl (card_pos.mpr (block_nonempty r _))] exact maximum_fixed r (orderEmbOfFin_mem _ _ _) simpa only [hm] using (maxima r).orderEmbOfFin rfl |>.strictMono disjoint := by intro i _ j _ hij dsimp only [Function.onFun] rw [range_orderEmbOfFin,range_orderEmbOfFin] apply Set.disjoint_left.mpr intro x hi hj have hr := r.trans (mem_block r _ x |>.mp hi) (r.symm (mem_block r _ x |>.mp hj)) have he := blockMax_eq r hr rw [maximum_fixed r (orderEmbOfFin_mem _ _ _), maximum_fixed r (orderEmbOfFin_mem _ _ _)] at he exact hij ((maxima r).orderEmbOfFin rfl |>.injective he) cover := by intro x obtain ⟨i,hi⟩ : ∃ i : Fin (maxima r).card, (maxima r).orderEmbOfFin rfl i = blockMax r x := by apply Set.mem_range.mp rw [range_orderEmbOfFin] exact blockMax_mem r x refine ⟨i,?_⟩ rw [range_orderEmbOfFin] apply (mem_block r _ x).mpr rw [hi] exact r.symm (blockMax_related r x) lemma range_ofSetoid (r : Setoid (Fin n)) (i : Fin (ofSetoid r).length) : Set.range ((ofSetoid r).emb i) = block r ((maxima r).orderEmbOfFin rfl i) := range_orderEmbOfFin _ _ @[simp] lemma partition_ofSetoid (r : Setoid (Fin n)) : partition (ofSetoid r) = r := by apply Setoid.ext intro x y change (ofSetoid r).index x = (ofSetoid r).index y ↔ r x y have hx := (relation_iff_range (ofSetoid r) ((ofSetoid r).index x) x).mp rfl rw [range_ofSetoid] at hx have hy := (relation_iff_range (ofSetoid r) ((ofSetoid r).index y) y).mp rfl rw [range_ofSetoid] at hy constructor · intro h rw [← h] at hy exact r.trans (r.symm ((mem_block r _ _).mp hx)) ((mem_block r _ _).mp hy) · intro h apply Eq.symm apply (relation_iff_range (ofSetoid r) ((ofSetoid r).index x) y).mpr rw [range_ofSetoid] exact (mem_block r _ _).mpr (r.trans ((mem_block r _ _).mp hx) h) def partitionEquiv (n : ℕ) : OrderedFinpartition n ≃ Setoid (Fin n) := Equiv.ofBijective partition ⟨partition_injective,fun r => ⟨ofSetoid r,partition_ofSetoid r⟩⟩ end BelowOne.OrderedPartitionBridge end end section noncomputable section open Finset Filter open scoped Topology namespace BelowOne.PartitionCumulant lemma iteratedDeriv_succ_log {n : ℕ} {x : ℝ} (hx : x ≠ 0) : iteratedDeriv (n+1) Real.log x = (-1 : ℝ)^n * n.factorial * x^(-(n:ℤ)-1) := by have heq : deriv Real.log =ᶠ[𝓝 x] Inv.inv := by filter_upwards [eventually_ne_nhds hx] with y hy simp [Real.deriv_log] rw [iteratedDeriv_succ',heq.iteratedDeriv_eq,iteratedDeriv_eq_iterate,iter_deriv_inv] grind lemma iteratedDeriv_log_one {n : ℕ} (hn : 0 < n) : iteratedDeriv n Real.log 1 = coefficient n := by obtain ⟨k,rfl⟩ := Nat.exists_eq_succ_of_ne_zero (Nat.ne_zero_of_lt hn) simp [iteratedDeriv_succ_log (by norm_num : (1:ℝ) ≠ 0),coefficient] variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] lemma iteratedFDeriv_log_comp {f : E → ℝ} {x : E} {n : ℕ} (hf : ContDiffAt ℝ n f x) (hx : f x = 1) (hn : 0 < n) (v : Fin n → E) : iteratedFDeriv ℝ n (Real.log ∘ f) x v = ∑ c : OrderedFinpartition n, coefficient c.length * ∏ i : Fin c.length, iteratedFDeriv ℝ (c.partSize i) f x (v ∘ c.emb i) := by have hg : ContDiffAt ℝ n Real.log (f x) := by rw [hx] exact Real.contDiffAt_log.mpr (by norm_num) rw [iteratedFDeriv_comp hg hf (le_refl _)] simp only [FormalMultilinearSeries.taylorComp,_root_.sum_apply, FormalMultilinearSeries.compAlongOrderedFinpartition_apply,ftaylorSeries] apply sum_congr rfl intro c hc have hcl : 0 < c.length := Nat.pos_of_ne_zero (fun h => by have hi := (c.index ⟨0,hn⟩).isLt omega) rw [hx,iteratedFDeriv_apply_eq_iteratedDeriv_mul_prod, iteratedDeriv_log_one hcl] simp only [smul_eq_mul,mul_comm] rfl def blockDerivative {n : ℕ} (f : E → ℝ) (x : E) (v : Fin n → E) (r : Setoid (Fin n)) : ℝ := let c := OrderedPartitionBridge.ofSetoid r ∏ i : Fin c.length, iteratedFDeriv ℝ (c.partSize i) f x (v ∘ c.emb i) lemma logarithmic_derivative_partition_sum {f : E → ℝ} {x : E} {n : ℕ} (hf : ContDiffAt ℝ n f x) (hx : f x = 1) (hn : 0 < n) (v : Fin n → E) : iteratedFDeriv ℝ n (Real.log ∘ f) x v = ∑ r : Setoid (Fin n), coefficient (Nat.card (Quotient r)) * blockDerivative f x v r := by rw [iteratedFDeriv_log_comp hf hx hn] apply Fintype.sum_equiv (OrderedPartitionBridge.partitionEquiv n) intro c have hc : OrderedPartitionBridge.ofSetoid (OrderedPartitionBridge.partition c) = c := by apply OrderedPartitionBridge.partition_injective simp change coefficient c.length * _ = coefficient (Nat.card (Quotient (OrderedPartitionBridge.partition c))) * _ rw [OrderedPartitionBridge.card_partition] change _ = coefficient c.length * blockDerivative f x v (OrderedPartitionBridge.partition c) unfold blockDerivative rw [hc] end BelowOne.PartitionCumulant end end section noncomputable section open Finset SimpleGraph open scoped Classical ContDiff namespace BelowOne.FKPressure variable {V I J : Type*} [Fintype V] def siteMoment (ends : I → V × V) (hardEnds : J → V × V) (E : Finset I) (H : Finset J) (s : ℝ) (v : I → ℝ) (T : Set V) : ℝ := ∑ A ∈ (E.filter (fun e => (ends e).1 ∈ T ∧ (ends e).2 ∈ T)).powerset, ∑ B ∈ (E.filter (fun e => (ends e).1 ∈ T ∧ (ends e).2 ∈ T)).powerset, ∑ L ∈ (H.filter (fun e => (hardEnds e).1 ∈ T ∧ (hardEnds e).2 ∈ T)).powerset, (∏ e ∈ A, v e) * (∏ e ∈ B, v e) * s ^ Nat.card ((graph (⊥ : SimpleGraph V) ends A).induce T).ConnectedComponent * (-1 : ℝ)^L.card omit [Fintype V] in lemma siteMoment_empty (ends : I → V × V) (hardEnds : J → V × V) (E : Finset I) (H : Finset J) (s : ℝ) (v : I → ℝ) : siteMoment ends hardEnds E H s v ∅ = 1 := by simp [siteMoment,Nat.card_eq_fintype_card] omit [Fintype V] in lemma block_edge_iff (r : Setoid V) (ends : I → V × V) (q : Quotient r) (e : I) : r (ends e).1 (ends e).2 ∧ edgeBlock r ends e = q ↔ (ends e).1 ∈ Quotient.mk r ⁻¹' {q} ∧ (ends e).2 ∈ Quotient.mk r ⁻¹' {q} := by change (r (ends e).1 (ends e).2 ∧ Quotient.mk r (ends e).1 = q) ↔ Quotient.mk r (ends e).1 = q ∧ Quotient.mk r (ends e).2 = q constructor · rintro ⟨h,e⟩ exact ⟨e,(Quotient.sound h).symm.trans e⟩ · rintro ⟨h₁,h₂⟩ exact ⟨Quotient.exact (h₁.trans h₂.symm),h₁⟩ omit [Fintype V] in lemma inducedBlockMoment_eq_siteMoment (ends : I → V × V) (hardEnds : J → V × V) (E : Finset I) (H : Finset J) (s : ℝ) (v : I → ℝ) (r : Setoid V) (q : Quotient r) : inducedBlockMoment ⊥ ends hardEnds E H s v r q = siteMoment ends hardEnds E H s v (Quotient.mk r ⁻¹' {q}) := by unfold inducedBlockMoment siteMoment simp_rw [block_edge_iff] omit [Fintype V] in lemma bot_reachable_le (r : Setoid V) : (⊥ : SimpleGraph V).reachableSetoid ≤ r := by intro x y h have hx := SimpleGraph.reachable_bot.mp h exact hx ▸ r.refl x lemma blockStructureSum_siteMoment (ends : I → V × V) (hardEnds : J → V × V) (E : Finset I) (H : Finset J) (s : ℝ) (v : I → ℝ) (r : Setoid V) : blockStructureSum ⊥ ends hardEnds E H s v r = ∏ q : Quotient r, siteMoment ends hardEnds E H s v (Quotient.mk r ⁻¹' {q}) := by rw [blockStructureSum_factorization _ ends hardEnds E H s v r (bot_reachable_le r)] simp_rw [inducedBlockMoment_eq_siteMoment] def sitePolynomial (ends : I → V × V) (hardEnds : J → V × V) (E : Finset I) (H : Finset J) (s : ℝ) (v : I → ℝ) : (V → ℝ) → ℝ := MultiaffineDerivative.polynomial (fun T : Finset V => siteMoment ends hardEnds E H s v T) lemma sitePolynomial_zero (ends : I → V × V) (hardEnds : J → V × V) (E : Finset I) (H : Finset J) (s : ℝ) (v : I → ℝ) : sitePolynomial ends hardEnds E H s v 0 = 1 := by rw [sitePolynomial,MultiaffineDerivative.polynomial_zero] simpa only [Finset.coe_empty] using siteMoment_empty ends hardEnds E H s v lemma coe_image_emb {n : ℕ} (c : OrderedFinpartition n) (i : Fin c.length) : ((univ.image (c.emb i) : Finset (Fin n)) : Set (Fin n)) = Set.range (c.emb i) := by ext x simp lemma product_moments_partition {n : ℕ} (W : Set (Fin n) → ℝ) (c : OrderedFinpartition n) : (∏ q : Quotient (OrderedPartitionBridge.partition c), W (Quotient.mk (OrderedPartitionBridge.partition c) ⁻¹' {q})) = ∏ i : Fin c.length, W (Set.range (c.emb i)) := by unfold OrderedPartitionBridge.partition let e := Setoid.quotientKerEquivOfSurjective c.index (OrderedPartitionBridge.index_surjective c) apply Fintype.prod_equiv e intro q congr 1 ext x change Quotient.mk (Setoid.ker c.index) x = q ↔ _ constructor · intro hx exact (OrderedPartitionBridge.relation_iff_range c (e q) x).mp (congrArg e hx) · intro hx apply e.injective exact (OrderedPartitionBridge.relation_iff_range c (e q) x).mpr hx lemma blockDerivative_sitePolynomial {n : ℕ} (ends : I → Fin n × Fin n) (hardEnds : J → Fin n × Fin n) (E : Finset I) (H : Finset J) (s : ℝ) (v : I → ℝ) (r : Setoid (Fin n)) : PartitionCumulant.blockDerivative (sitePolynomial ends hardEnds E H s v) 0 MultiaffineDerivative.coordinate r = blockStructureSum ⊥ ends hardEnds E H s v r := by unfold PartitionCumulant.blockDerivative let c := OrderedPartitionBridge.ofSetoid r have hp : OrderedPartitionBridge.partition c = r := OrderedPartitionBridge.partition_ofSetoid r have heq : (∏ q : Quotient r, siteMoment ends hardEnds E H s v (Quotient.mk r ⁻¹' {q})) = ∏ i : Fin c.length, siteMoment ends hardEnds E H s v (Set.range (c.emb i)) := by rw [← hp] exact product_moments_partition _ c rw [blockStructureSum_siteMoment,heq] change (∏ i : Fin c.length, _) = _ apply prod_congr rfl intro i hi rw [sitePolynomial,MultiaffineDerivative.polynomial_derivative, ite_eq_left (c.emb_strictMono i).injective] simp only [Finset.coe_image,Finset.coe_univ,Set.image_univ,c] theorem sitePolynomial_log_derivative {n : ℕ} (hn : 0 < n) (ends : I → Fin n × Fin n) (hardEnds : J → Fin n × Fin n) (E : Finset I) (H : Finset J) (s : ℝ) (v : I → ℝ) : iteratedFDeriv ℝ n (Real.log ∘ sitePolynomial ends hardEnds E H s v) 0 MultiaffineDerivative.coordinate = connectedSum ⊥ ends hardEnds E H s v := by have : NeZero n := ⟨Nat.ne_zero_of_lt hn⟩ have hf : ContDiffAt ℝ n (sitePolynomial ends hardEnds E H s v) 0 := (MultiaffineDerivative.contDiff_polynomial _ n).contDiffAt rw [PartitionCumulant.logarithmic_derivative_partition_sum hf (sitePolynomial_zero ends hardEnds E H s v) hn] simp_rw [blockDerivative_sitePolynomial] exact exponential_cancellation ⊥ ends hardEnds E H s v theorem sitePolynomial_log_derivative_nonpos {n : ℕ} (hn : 0 < n) (ends : I → Fin n × Fin n) (hardEnds : J → Fin n × Fin n) (E : Finset I) (H : Finset J) {u : ℝ} (hu : 0 < u) (hu1 : u < 1) (v : I → ℝ) (hv : ∀ e ∈ E, 0 ≤ v e) : iteratedFDeriv ℝ n (Real.log ∘ sitePolynomial ends hardEnds E H (-u) v) 0 MultiaffineDerivative.coordinate ≤ 0 := by rw [sitePolynomial_log_derivative hn] exact connectedSum_nonpos ⊥ ends hardEnds E H hu hu1 v hv end BelowOne.FKPressure end end section noncomputable section open Finset SimpleGraph open scoped Classical namespace BelowOne.FKPressure variable {V I J : Type*} [Fintype V] def inducedPartition (ends : I → V × V) (E : Finset I) (s : ℝ) (v : I → ℝ) (T : Set V) : ℝ := ∑ A ∈ (E.filter (fun e => (ends e).1 ∈ T ∧ (ends e).2 ∈ T)).powerset, (∏ e ∈ A, v e) * s ^ Nat.card ((graph (⊥ : SimpleGraph V) ends A).induce T).ConnectedComponent lemma alternating_powerset (H : Finset J) : (∑ L ∈ H.powerset, (-1 : ℝ)^L.card) = if H = ∅ then 1 else 0 := by have hh : (∑ L ∈ H.powerset, (-1 : ℝ)^L.card) = ∏ h ∈ H, (1 + (-1 : ℝ)) := by simpa only [prod_const] using (prod_one_add (f := fun _ : J => (-1:ℝ)) H).symm rw [hh] by_cases h : H = ∅ · simp [h] · rw [ite_eq_right h] obtain ⟨e,he⟩ := nonempty_iff_ne_empty.mpr h exact prod_eq_zero he (by norm_num) omit [Fintype V] in lemma siteMoment_separate (ends : I → V × V) (hardEnds : J → V × V) (E : Finset I) (H : Finset J) (s : ℝ) (v : I → ℝ) (T : Set V) : siteMoment ends hardEnds E H s v T = inducedPartition ends E s v T * (∑ B ∈ (E.filter (fun e => (ends e).1 ∈ T ∧ (ends e).2 ∈ T)).powerset, ∏ e ∈ B, v e) * (∑ L ∈ (H.filter (fun e => (hardEnds e).1 ∈ T ∧ (hardEnds e).2 ∈ T)).powerset, (-1:ℝ)^L.card) := by unfold siteMoment inducedPartition rw [sum_mul,sum_mul] apply sum_congr rfl intro A hA rw [show (∏ e ∈ A, v e) * s ^ Nat.card (induce T (graph ⊥ ends A)).ConnectedComponent * (∑ B ∈ (E.filter (fun e => (ends e).1 ∈ T ∧ (ends e).2 ∈ T)).powerset, ∏ e ∈ B, v e) = ∑ B ∈ (E.filter (fun e => (ends e).1 ∈ T ∧ (ends e).2 ∈ T)).powerset, (∏ e ∈ A, v e) * s ^ Nat.card (induce T (graph ⊥ ends A)).ConnectedComponent * (∏ e ∈ B, v e) from mul_sum _ _ _] rw [sum_mul] apply sum_congr rfl intro B hB rw [mul_sum] apply sum_congr rfl intro L hL ring omit [Fintype V] in lemma siteMoment_squarefree (ends : I → V × V) (hardEnds : J → V × V) (E : Finset I) (H : Finset J) (s : ℝ) (v : I → ℝ) (T : Set V) : siteMoment ends hardEnds E H s v T = if (H.filter (fun e => (hardEnds e).1 ∈ T ∧ (hardEnds e).2 ∈ T)) = ∅ then (∏ e ∈ E.filter (fun e => (ends e).1 ∈ T ∧ (ends e).2 ∈ T), (1 + v e)) * inducedPartition ends E s v T else 0 := by rw [siteMoment_separate,alternating_powerset,← prod_one_add] split_ifs <;> ring omit [Fintype V] in lemma siteMoment_collision_zero (ends : I → V × V) (hardEnds : J → V × V) (E : Finset I) (H : Finset J) (s : ℝ) (v : I → ℝ) (T : Set V) {e : J} (he : e ∈ H) (h₁ : (hardEnds e).1 ∈ T) (h₂ : (hardEnds e).2 ∈ T) : siteMoment ends hardEnds E H s v T = 0 := by rw [siteMoment_squarefree,ite_eq_right] exact nonempty_iff_ne_empty.mp ⟨e,mem_filter.mpr ⟨he,h₁,h₂⟩⟩ end BelowOne.FKPressure end end section noncomputable section open Finset SimpleGraph open scoped Classical namespace BelowOne.FKPressure variable {V W I J : Type*} [Fintype V] [Fintype W] def imageEquiv (f : V → W) (T : Set V) (hf : Set.InjOn f T) : T ≃ f '' T := Equiv.ofBijective (fun x => ⟨f x, Set.mem_image_of_mem f x.property⟩) (by constructor · intro x y h exact Subtype.ext (hf x.property y.property (congrArg Subtype.val h)) · rintro ⟨y,x,hx,rfl⟩ exact ⟨⟨x,hx⟩,rfl⟩) omit [Fintype V] [Fintype W] in lemma induced_graph_image_iso (f : V → W) (T : Set V) (hf : Set.InjOn f T) (ends : I → V × V) (ends' : J → W × W) (g : I → J) (A : Finset I) (hT : ∀ e ∈ A, (ends e).1 ∈ T ∧ (ends e).2 ∈ T) (he : ∀ e ∈ A, ends' (g e) = (f (ends e).1, f (ends e).2)) : Nonempty ((graph ⊥ ends A).induce T ≃g (graph ⊥ ends' (A.image g)).induce (f '' T)) := by refine ⟨{ toEquiv := imageEquiv f T hf, map_rel_iff' := ?_ }⟩ intro x y change (graph ⊥ ends' (A.image g)).Adj (f x) (f y) ↔ (graph ⊥ ends A).Adj x y simp only [graph_adj_iff,SimpleGraph.bot_adj,false_or] constructor · rintro ⟨j,hj,hxy⟩ obtain ⟨e,heA,rfl⟩ := mem_image.mp hj rw [he e heA] at hxy obtain ⟨h,hne⟩ := (edge_adj _ _ _ _).mp hxy refine ⟨e,heA,(edge_adj _ _ _ _).mpr ⟨?_,?_⟩⟩ · rcases h with ⟨hx,hy⟩ | ⟨hx,hy⟩ · exact Or.inl ⟨hf x.property (hT e heA).1 hx,hf y.property (hT e heA).2 hy⟩ · exact Or.inr ⟨hf x.property (hT e heA).2 hx,hf y.property (hT e heA).1 hy⟩ · intro h exact hne (congrArg f h) · rintro ⟨e,heA,hxy⟩ refine ⟨g e,mem_image_of_mem g heA,?_⟩ rw [he e heA] obtain ⟨h,hne⟩ := (edge_adj _ _ _ _).mp hxy apply (edge_adj _ _ _ _).mpr constructor · rcases h with ⟨hx,hy⟩ | ⟨hx,hy⟩ · exact Or.inl ⟨congrArg f hx,congrArg f hy⟩ · exact Or.inr ⟨congrArg f hx,congrArg f hy⟩ · exact fun h => hne (hf x.property y.property h) omit [Fintype V] [Fintype W] in lemma induced_component_image (f : V → W) (T : Set V) (hf : Set.InjOn f T) (ends : I → V × V) (ends' : J → W × W) (g : I → J) (A : Finset I) (hT : ∀ e ∈ A, (ends e).1 ∈ T ∧ (ends e).2 ∈ T) (he : ∀ e ∈ A, ends' (g e) = (f (ends e).1, f (ends e).2)) : Nat.card ((graph ⊥ ends A).induce T).ConnectedComponent = Nat.card ((graph ⊥ ends' (A.image g)).induce (f '' T)).ConnectedComponent := by obtain ⟨e⟩ := induced_graph_image_iso f T hf ends ends' g A hT he exact Nat.card_congr e.connectedComponentEquiv omit [Fintype V] [Fintype W] in lemma inducedPartition_reindex (f : V → W) (T : Set V) (hf : Set.InjOn f T) (ends : I → V × V) (ends' : J → W × W) (g : I → J) (E : Finset I) (s : ℝ) (v : J → ℝ) (hT : ∀ e ∈ E, (ends e).1 ∈ T ∧ (ends e).2 ∈ T) (he : ∀ e ∈ E, ends' (g e) = (f (ends e).1, f (ends e).2)) (hg : Set.InjOn g E) : inducedPartition ends E s (v ∘ g) T = inducedPartition ends' (E.image g) s v (f '' T) := by have hfilter : E.filter (fun e => (ends e).1 ∈ T ∧ (ends e).2 ∈ T) = E := by exact filter_eq_self.mpr hT have hfilter' : (E.image g).filter (fun e => (ends' e).1 ∈ f '' T ∧ (ends' e).2 ∈ f '' T) = E.image g := by apply filter_eq_self.mpr intro j hj obtain ⟨e,heE,rfl⟩ := mem_image.mp hj rw [he e heE] exact ⟨Set.mem_image_of_mem f (hT e heE).1,Set.mem_image_of_mem f (hT e heE).2⟩ unfold inducedPartition rw [hfilter,hfilter',powerset_image,sum_image] · apply sum_congr rfl intro A hA have hAE := mem_powerset.mp hA rw [induced_component_image f T hf ends ends' g A (fun e heA => hT e (hAE heA)) (fun e heA => he e (hAE heA)),prod_image] · rfl · intro a ha b hb hab exact hg (hAE ha) (hAE hb) hab · intro A hA B hB hAB exact (Finset.image_eq_image_iff_of_injOn hg (mem_powerset.mp hA) (mem_powerset.mp hB)).mp hAB end BelowOne.FKPressure end end section noncomputable section open Finset SimpleGraph open scoped Classical namespace BelowOne.FKPressure attribute [local instance] Classical.propDecidable variable {V U I : Type*} [Fintype V] [Fintype U] [LinearOrder U] def liftEdges (τ : U → V) (ends : I → V × V) (E : Finset I) : Finset (I × U × U) := (E ×ˢ (univ ×ˢ univ)).filter (fun e => τ e.2.1 = (ends e.1).1 ∧ τ e.2.2 = (ends e.1).2) def hardEdges (τ : U → V) : Finset (U × U) := univ.filter (fun e => e.1 < e.2 ∧ τ e.1 = τ e.2) def squarefreeMoment (ends : I → V × V) (E : Finset I) (s : ℝ) (v : I → ℝ) (T : Set V) : ℝ := (∏ e ∈ E.filter (fun e => (ends e).1 ∈ T ∧ (ends e).2 ∈ T), (1 + v e)) * inducedPartition ends E s v T omit [Fintype V] [LinearOrder U] in lemma mem_liftEdges (τ : U → V) (ends : I → V × V) (E : Finset I) (e : I × U × U) : e ∈ liftEdges τ ends E ↔ e.1 ∈ E ∧ τ e.2.1 = (ends e.1).1 ∧ τ e.2.2 = (ends e.1).2 := by simp [liftEdges] omit [Fintype V] [LinearOrder U] in lemma liftEdges_filter_image (τ : U → V) (ends : I → V × V) (E : Finset I) (T : Set U) : ((liftEdges τ ends E).filter (fun e => e.2.1 ∈ T ∧ e.2.2 ∈ T)).image Prod.fst = E.filter (fun e => (ends e).1 ∈ τ '' T ∧ (ends e).2 ∈ τ '' T) := by ext e constructor · intro h obtain ⟨⟨d,i,j⟩,hlift,heq⟩ := mem_image.mp h change d = e at heq subst e obtain ⟨he,hij⟩ := mem_filter.mp hlift obtain ⟨hd,hi,hj⟩ := (mem_liftEdges _ _ _ _).mp he exact mem_filter.mpr ⟨hd,⟨i,hij.1,hi⟩,⟨j,hij.2,hj⟩⟩ · intro h obtain ⟨he,⟨i,hi,hei⟩,⟨j,hj,hej⟩⟩ := mem_filter.mp h exact mem_image.mpr ⟨(e,i,j),mem_filter.mpr ⟨(mem_liftEdges _ _ _ _).mpr ⟨he,hei,hej⟩,hi,hj⟩,rfl⟩ omit [Fintype V] [LinearOrder U] in lemma liftEdges_filter_inj (τ : U → V) (ends : I → V × V) (E : Finset I) (T : Set U) (hτ : Set.InjOn τ T) : Set.InjOn Prod.fst (↑((liftEdges τ ends E).filter (fun e => e.2.1 ∈ T ∧ e.2.2 ∈ T)) : Set (I × U × U)) := by rintro ⟨e,i,j⟩ h ⟨e',i',j'⟩ h' he obtain ⟨hm,hi,hj⟩ := mem_filter.mp h obtain ⟨hm',hi',hj'⟩ := mem_filter.mp h' obtain ⟨_,hei,hej⟩ := (mem_liftEdges _ _ _ _).mp hm obtain ⟨_,hei',hej'⟩ := (mem_liftEdges _ _ _ _).mp hm' change e = e' at he subst e' have hii := hτ hi hi' (hei.trans hei'.symm) have hjj := hτ hj hj' (hej.trans hej'.symm) exact Prod.ext rfl (Prod.ext hii hjj) omit [Fintype V] in lemma hardEdges_filter_empty_iff (τ : U → V) (T : Set U) : (hardEdges τ).filter (fun e => e.1 ∈ T ∧ e.2 ∈ T) = ∅ ↔ Set.InjOn τ T := by rw [Finset.eq_empty_iff_forall_notMem] simp only [mem_filter,hardEdges,mem_univ,true_and] constructor · intro h a ha b hb hab by_contra hne rcases lt_or_gt_of_ne hne with hab' | hba' · exact h (a,b) ⟨⟨hab',hab⟩,ha,hb⟩ · exact h (b,a) ⟨⟨hba',hab.symm⟩,hb,ha⟩ · intro h e he exact (ne_of_lt he.1.1) (h he.2.1 he.2.2 he.1.2) omit [Fintype V] in lemma inducedPartition_filter (ends : I → V × V) (E : Finset I) (s : ℝ) (v : I → ℝ) (T : Set V) : inducedPartition ends (E.filter (fun e => (ends e).1 ∈ T ∧ (ends e).2 ∈ T)) s v T = inducedPartition ends E s v T := by unfold inducedPartition rw [filter_filter] simp only [and_self] omit [Fintype V] in lemma siteMoment_lift (τ : U → V) (ends : I → V × V) (E : Finset I) (s : ℝ) (v : I → ℝ) (T : Set U) : siteMoment Prod.snd id (liftEdges τ ends E) (hardEdges τ) s (v ∘ Prod.fst) T = if Set.InjOn τ T then squarefreeMoment ends E s v (τ '' T) else 0 := by rw [siteMoment_squarefree] simp only [id_eq] simp only [hardEdges_filter_empty_iff] split_ifs with hτ · let F := (liftEdges τ ends E).filter (fun e => e.2.1 ∈ T ∧ e.2.2 ∈ T) have hF : ∀ e ∈ F, e.2.1 ∈ T ∧ e.2.2 ∈ T := fun e he => (mem_filter.mp he).2 have he : ∀ e ∈ F, ends (Prod.fst e) = (τ e.2.1,τ e.2.2) := by intro e he have h := (mem_liftEdges _ _ _ _).mp (mem_filter.mp he).1 exact Prod.ext h.2.1.symm h.2.2.symm have hpart := inducedPartition_reindex τ T hτ Prod.snd ends Prod.fst F s v hF he (liftEdges_filter_inj τ ends E T hτ) rw [inducedPartition_filter] at hpart rw [liftEdges_filter_image] at hpart rw [inducedPartition_filter] at hpart unfold squarefreeMoment rw [hpart] congr 1 rw [← liftEdges_filter_image τ ends E T,prod_image] · rfl · exact liftEdges_filter_inj τ ends E T hτ · rfl end BelowOne.FKPressure end end section noncomputable section open Finset SimpleGraph open scoped Classical namespace BelowOne.FKPressure variable {V I : Type*} [Fintype V] def unscaledSitePolynomial (ends : I → V × V) (E : Finset I) (s : ℝ) (v : I → ℝ) : (V → ℝ) → ℝ := MultiaffineDerivative.polynomial (fun T => squarefreeMoment ends E s v (T : Set V)) lemma unscaledSitePolynomial_zero (ends : I → V × V) (E : Finset I) (s : ℝ) (v : I → ℝ) : unscaledSitePolynomial ends E s v 0 = 1 := by rw [unscaledSitePolynomial,MultiaffineDerivative.polynomial_zero] simp [squarefreeMoment,inducedPartition,Nat.card_eq_fintype_card] lemma injOn_range_iff {X Y Z : Type*} (f : Y → Z) (e : X ↪ Y) : Set.InjOn f (Set.range e) ↔ Function.Injective (f ∘ e) := by constructor · intro h x y hxy exact e.injective (h ⟨x,rfl⟩ ⟨y,rfl⟩ hxy) · intro h x hx y hy hxy obtain ⟨a,rfl⟩ := hx obtain ⟨b,rfl⟩ := hy exact congrArg e (h hxy) lemma lifted_derivative {n k : ℕ} (τ : Fin n → V) (e : Fin k ↪ Fin n) (ends : I → V × V) (E : Finset I) (s : ℝ) (v : I → ℝ) : iteratedFDeriv ℝ k (unscaledSitePolynomial ends E s v) 0 (MultiaffineDerivative.coordinate ∘ (τ ∘ e)) = siteMoment Prod.snd id (liftEdges τ ends E) (hardEdges τ) s (v ∘ Prod.fst) (Set.range e) := by rw [unscaledSitePolynomial,MultiaffineDerivative.polynomial_derivative, siteMoment_lift,injOn_range_iff] simp only [Finset.coe_image,Finset.coe_univ,Set.image_univ,Set.range_comp] split_ifs <;> rfl lemma blockDerivative_lift {n : ℕ} (τ : Fin n → V) (ends : I → V × V) (E : Finset I) (s : ℝ) (v : I → ℝ) (r : Setoid (Fin n)) : PartitionCumulant.blockDerivative (unscaledSitePolynomial ends E s v) 0 (MultiaffineDerivative.coordinate ∘ τ) r = PartitionCumulant.blockDerivative (sitePolynomial Prod.snd id (liftEdges τ ends E) (hardEdges τ) s (v ∘ Prod.fst)) 0 MultiaffineDerivative.coordinate r := by unfold PartitionCumulant.blockDerivative apply prod_congr rfl intro i hi let c := OrderedPartitionBridge.ofSetoid r let e : Fin (c.partSize i) ↪ Fin n := ⟨c.emb i,(c.emb_strictMono i).injective⟩ change iteratedFDeriv ℝ _ (unscaledSitePolynomial ends E s v) 0 (MultiaffineDerivative.coordinate ∘ (τ ∘ e)) = _ rw [lifted_derivative] rw [sitePolynomial,MultiaffineDerivative.polynomial_derivative, ite_eq_left (c.emb_strictMono i).injective] simp only [Finset.coe_image,Finset.coe_univ,Set.image_univ] rfl theorem unscaledSitePolynomial_log_derivative {n : ℕ} (hn : 0 < n) (τ : Fin n → V) (ends : I → V × V) (E : Finset I) (s : ℝ) (v : I → ℝ) : iteratedFDeriv ℝ n (Real.log ∘ unscaledSitePolynomial ends E s v) 0 (MultiaffineDerivative.coordinate ∘ τ) = connectedSum ⊥ Prod.snd id (liftEdges τ ends E) (hardEdges τ) s (v ∘ Prod.fst) := by rw [← sitePolynomial_log_derivative hn] have hf : ContDiffAt ℝ n (unscaledSitePolynomial ends E s v) 0 := (MultiaffineDerivative.contDiff_polynomial _ n).contDiffAt have hg : ContDiffAt ℝ n (sitePolynomial Prod.snd id (liftEdges τ ends E) (hardEdges τ) s (v ∘ Prod.fst)) 0 := (MultiaffineDerivative.contDiff_polynomial _ n).contDiffAt rw [PartitionCumulant.logarithmic_derivative_partition_sum hf (unscaledSitePolynomial_zero ends E s v) hn, PartitionCumulant.logarithmic_derivative_partition_sum hg (sitePolynomial_zero _ _ _ _ _ _) hn] simp_rw [blockDerivative_lift] theorem unscaledSitePolynomial_log_derivative_nonpos {n : ℕ} (hn : 0 < n) (τ : Fin n → V) (ends : I → V × V) (E : Finset I) {u : ℝ} (hu : 0 < u) (hu1 : u < 1) (v : I → ℝ) (hv : ∀ e ∈ E, 0 ≤ v e) : iteratedFDeriv ℝ n (Real.log ∘ unscaledSitePolynomial ends E (-u) v) 0 (MultiaffineDerivative.coordinate ∘ τ) ≤ 0 := by have : NeZero n := ⟨Nat.ne_zero_of_lt hn⟩ rw [unscaledSitePolynomial_log_derivative hn] apply connectedSum_nonpos ⊥ Prod.snd id _ _ hu hu1 intro e he exact hv e.1 ((mem_liftEdges _ _ _ _).mp he).1 end BelowOne.FKPressure end end section noncomputable section open Finset namespace BelowOne.ComponentProduct attribute [local instance] Classical.propDecidable variable {V Q : Type*} [Fintype V] [Fintype Q] def saturated (f : V → Q) (T : Finset V) : Prop := ∀ a b, f a = f b → (a ∈ T ↔ b ∈ T) def preimage (f : V → Q) (J : Finset Q) : Finset V := univ.filter (fun v => f v ∈ J) omit [Fintype Q] in lemma mem_preimage (f : V → Q) (J : Finset Q) (v : V) : v ∈ preimage f J ↔ f v ∈ J := by simp [preimage] omit [Fintype Q] in lemma preimage_saturated (f : V → Q) (J : Finset Q) : saturated f (preimage f J) := by intro a b hab simp only [mem_preimage,hab] omit [Fintype Q] in lemma image_preimage (f : V → Q) (hf : Function.Surjective f) (J : Finset Q) : (preimage f J).image f = J := by ext q simp only [mem_image,mem_preimage] constructor · rintro ⟨v,hv,rfl⟩ exact hv · intro hq obtain ⟨v,rfl⟩ := hf q exact ⟨v,hq,rfl⟩ omit [Fintype Q] in lemma preimage_image (f : V → Q) (T : Finset V) (hT : saturated f T) : preimage f (T.image f) = T := by ext v simp only [mem_preimage,mem_image] constructor · rintro ⟨w,hw,hwv⟩ exact (hT w v hwv).mp hw · intro hv exact ⟨v,hv,rfl⟩ omit [Fintype Q] in lemma selected_product (f : V → Q) (J : Finset Q) (s : ℝ) (x : V → ℝ) : (∏ q ∈ J, s * ∏ v ∈ univ.filter (fun v => f v = q), x v) = s ^ J.card * ∏ v ∈ preimage f J, x v := by rw [prod_mul_distrib,prod_const] congr 1 exact Finset.prod_fiberwise_eq_prod_filter univ J f x lemma expansion (f : V → Q) (hf : Function.Surjective f) (s : ℝ) (x : V → ℝ) : (∏ q : Q, (1 + s * ∏ v ∈ univ.filter (fun v => f v = q), x v)) = ∑ T : Finset V, if saturated f T then s ^ (T.image f).card * ∏ v ∈ T, x v else 0 := by rw [prod_one_add] symm rw [← sum_filter] symm apply sum_bij (fun J hJ => preimage f J) · intro J hJ exact mem_filter.mpr ⟨mem_univ _,preimage_saturated f J⟩ · intro J hJ K hK hJK have h := congrArg (Finset.image f) hJK simpa only [image_preimage f hf] using h · intro T hT refine ⟨T.image f,mem_powerset.mpr (subset_univ _),?_⟩ exact preimage_image f T (mem_filter.mp hT).2 · intro J hJ rw [selected_product,image_preimage f hf] end BelowOne.ComponentProduct end end section noncomputable section open Finset SimpleGraph namespace BelowOne.FKPressure attribute [local instance] Classical.propDecidable variable {V I : Type*} [Fintype V] omit [Fintype V] in lemma reachable_induce_saturated (G : SimpleGraph V) (T : Finset V) (hT : ComponentProduct.saturated G.connectedComponentMk T) (x y : (T : Set V)) : (G.induce T).Reachable x y ↔ G.Reachable x.1 y.1 := by constructor · exact fun h => h.map (SimpleGraph.Embedding.induce _).toHom · rintro ⟨p⟩ have hp : ∀ z ∈ p.support, z ∈ (T : Set V) := by intro z hz have he : G.connectedComponentMk x = G.connectedComponentMk z := ConnectedComponent.sound ⟨p.takeUntil z hz⟩ exact (hT x z he).mp x.property exact ⟨p.induce (T : Set V) hp⟩ omit [Fintype V] in lemma component_card_induce_saturated (G : SimpleGraph V) (T : Finset V) (hT : ComponentProduct.saturated G.connectedComponentMk T) : Nat.card (G.induce T).ConnectedComponent = (T.image G.connectedComponentMk).card := by let f : ↥(T : Set V) → G.ConnectedComponent := fun x => G.connectedComponentMk x have hr : (G.induce T).reachableSetoid = Setoid.ker f := by apply Setoid.ext intro x y change (G.induce T).Reachable x y ↔ G.connectedComponentMk x = G.connectedComponentMk y rw [reachable_induce_saturated G T hT] exact ⟨ConnectedComponent.sound,ConnectedComponent.exact⟩ have him : Set.range f = (↑(T.image G.connectedComponentMk) : Set G.ConnectedComponent) := by ext q simp only [Set.mem_range,Finset.mem_coe,mem_image,f] constructor · rintro ⟨x,rfl⟩ exact ⟨x,x.property,rfl⟩ · rintro ⟨x,hx,rfl⟩ exact ⟨⟨x,hx⟩,rfl⟩ change Nat.card (Quotient (G.induce T).reachableSetoid) = _ rw [hr,Nat.card_congr (Setoid.quotientKerEquivRange f),him,Nat.card_eq_fintype_card] exact Fintype.card_coe _ omit [Fintype V] in lemma saturated_graph_iff (ends : I → V × V) (A : Finset I) (T : Finset V) : ComponentProduct.saturated (graph ⊥ ends A).connectedComponentMk T ↔ ∀ e ∈ A, ((ends e).1 ∈ T ↔ (ends e).2 ∈ T) := by constructor · intro h e he exact h _ _ (ConnectedComponent.sound (endpoints_reachable ⊥ ends he)) · intro h a b hab have hr : (graph ⊥ ends A).Reachable a b := ConnectedComponent.exact hab obtain ⟨p⟩ := hr clear hab induction p with | nil => rfl | @cons a b c hab p ih => have heq : a ∈ T ↔ b ∈ T := by obtain hfalse | ⟨e,he,hxy⟩ := (graph_adj_iff ⊥ ends A a b).mp hab · exact False.elim hfalse obtain ⟨hxy,_⟩ := (edge_adj _ _ _ _).mp hxy rcases hxy with ⟨rfl,rfl⟩ | ⟨rfl,rfl⟩ · exact h e he · exact (h e he).symm exact heq.trans ih def componentProduct (G : SimpleGraph V) (s : ℝ) (x : V → ℝ) : ℝ := ∏ c : G.ConnectedComponent, (1 + s * ∏ v ∈ univ.filter (fun v => G.connectedComponentMk v = c), x v) lemma componentProduct_expansion (ends : I → V × V) (A : Finset I) (s : ℝ) (x : V → ℝ) : componentProduct (graph ⊥ ends A) s x = ∑ T : Finset V, if ∀ e ∈ A, ((ends e).1 ∈ T ↔ (ends e).2 ∈ T) then s ^ Nat.card ((graph ⊥ ends A).induce T).ConnectedComponent * ∏ v ∈ T, x v else 0 := by rw [componentProduct,ComponentProduct.expansion (graph ⊥ ends A).connectedComponentMk (fun q => Quot.mk_surjective q)] apply sum_congr rfl intro T hT by_cases h : ComponentProduct.saturated (graph ⊥ ends A).connectedComponentMk T · rw [ite_eq_left h,ite_eq_left ((saturated_graph_iff ends A T).mp h),component_card_induce_saturated _ T h] · rw [ite_eq_right h,ite_eq_right (fun hh => h ((saturated_graph_iff ends A T).mpr hh))] end BelowOne.FKPressure end end section noncomputable section open Finset namespace BelowOne.SubsetSplitting attribute [local instance] Classical.propDecidable variable {I : Type*} lemma sum_factorization_binary (E : Finset I) (p : I → Prop) (W W₁ W₂ : Finset I → ℝ) (hW : ∀ A ⊆ E, W A = W₁ (A.filter p) * W₂ (A.filter (fun e => ¬p e))) : (∑ A ∈ E.powerset, W A) = (∑ A ∈ (E.filter p).powerset, W₁ A) * (∑ A ∈ (E.filter (fun e => ¬p e)).powerset, W₂ A) := by have h := sum_factorization E (fun e => decide (p e)) W (fun b A => if b then W₁ A else W₂ A) (by intro A hA rw [Fintype.prod_bool] simpa only [Bool.false_eq_true,ite_false,ite_true,decide_eq_false_iff_not, decide_eq_true_eq] using hW A hA) simpa only [Fintype.prod_bool,fiber,Bool.false_eq_true,ite_false,ite_true, decide_eq_false_iff_not,decide_eq_true_eq,mul_comm] using h end BelowOne.SubsetSplitting end end section noncomputable section open Finset SimpleGraph namespace BelowOne.FKPressure attribute [local instance] Classical.propDecidable variable {V I : Type*} [Fintype V] omit [Fintype V] in lemma graph_induce_inside_filter (G : SimpleGraph V) (ends : I → V × V) (A : Finset I) (T : Set V) : (graph G ends (A.filter (fun e => (ends e).1 ∈ T ∧ (ends e).2 ∈ T))).induce T = (graph G ends A).induce T := by ext x y simp only [SimpleGraph.induce_adj,graph_adj_iff,mem_filter] constructor · rintro (h | ⟨e,⟨he,_⟩,hxy⟩) · exact Or.inl h · exact Or.inr ⟨e,he,hxy⟩ · rintro (h | ⟨e,he,hxy⟩) · exact Or.inl h · refine Or.inr ⟨e,⟨he,?_⟩,hxy⟩ rcases (edge_adj _ _ _ _).mp hxy with ⟨⟨hx,hy⟩ | ⟨hx,hy⟩,_⟩ · exact ⟨hx ▸ x.property,hy ▸ y.property⟩ · exact ⟨hy ▸ y.property,hx ▸ x.property⟩ omit [Fintype V] in lemma confined_edge_sum (ends : I → V × V) (E : Finset I) (T : Set V) (s : ℝ) (v : I → ℝ) : (∑ A ∈ E.powerset, if ∀ e ∈ A, ((ends e).1 ∈ T ↔ (ends e).2 ∈ T) then (∏ e ∈ A, v e) * s ^ Nat.card ((graph ⊥ ends A).induce T).ConnectedComponent else 0) = inducedPartition ends E s v T * ∏ e ∈ E.filter (fun e => (ends e).1 ∉ T ∧ (ends e).2 ∉ T), (1 + v e) := by trans ∑ A ∈ (E.filter (fun e => (ends e).1 ∈ T ↔ (ends e).2 ∈ T)).powerset, (∏ e ∈ A, v e) * s ^ Nat.card ((graph ⊥ ends A).induce T).ConnectedComponent · have hh := sum_powerset_filter E (fun e => (ends e).1 ∈ T ↔ (ends e).2 ∈ T) (fun A => (∏ e ∈ A, v e) * s ^ Nat.card ((graph ⊥ ends A).induce T).ConnectedComponent) simpa only [MultiaffineDerivative.ite_classical,filter_classical] using hh let F := E.filter (fun e => (ends e).1 ∈ T ↔ (ends e).2 ∈ T) have h := SubsetSplitting.sum_factorization_binary F (fun e => (ends e).1 ∈ T ∧ (ends e).2 ∈ T) (fun A => (∏ e ∈ A, v e) * s ^ Nat.card ((graph ⊥ ends A).induce T).ConnectedComponent) (fun A => (∏ e ∈ A, v e) * s ^ Nat.card ((graph ⊥ ends A).induce T).ConnectedComponent) (fun A => ∏ e ∈ A, v e) (by intro A hA simp only [filter_classical] have hg := graph_induce_inside_filter (⊥ : SimpleGraph V) ends A T simp only [filter_classical] at hg rw [hg] rw [← Finset.prod_filter_mul_prod_filter_not A (fun e => (ends e).1 ∈ T ∧ (ends e).2 ∈ T) v] simp only [filter_classical] ring) have hi : F.filter (fun e => (ends e).1 ∈ T ∧ (ends e).2 ∈ T) = E.filter (fun e => (ends e).1 ∈ T ∧ (ends e).2 ∈ T) := by ext e simp only [F,mem_filter] tauto have ho : F.filter (fun e => ¬((ends e).1 ∈ T ∧ (ends e).2 ∈ T)) = E.filter (fun e => (ends e).1 ∉ T ∧ (ends e).2 ∉ T) := by ext e simp only [F,mem_filter] tauto simp only [filter_classical] at h hi ho ⊢ rw [hi,ho,← prod_one_add] at h simpa only [F,inducedPartition,filter_classical] using h def percolationSitePolynomial (ends : I → V × V) (E : Finset I) (s : ℝ) (v : I → ℝ) (x : V → ℝ) : ℝ := (∑ A ∈ E.powerset, (∏ e ∈ A, v e) * componentProduct (graph ⊥ ends A) s x) / ∏ e ∈ E, (1 + v e) def percolationCoefficient (ends : I → V × V) (E : Finset I) (s : ℝ) (v : I → ℝ) (T : Finset V) : ℝ := (inducedPartition ends E s v T * ∏ e ∈ E.filter (fun e => (ends e).1 ∉ T ∧ (ends e).2 ∉ T), (1 + v e)) / ∏ e ∈ E, (1 + v e) lemma percolationSitePolynomial_eq (ends : I → V × V) (E : Finset I) (s : ℝ) (v : I → ℝ) : percolationSitePolynomial ends E s v = MultiaffineDerivative.polynomial (percolationCoefficient ends E s v) := by funext x unfold percolationSitePolynomial simp_rw [componentProduct_expansion,mul_sum] rw [sum_comm] unfold MultiaffineDerivative.polynomial percolationCoefficient rw [sum_div] apply sum_congr rfl intro T hT rw [div_mul_eq_mul_div] congr 1 have hh := confined_edge_sum ends E (T : Set V) s v simp only [Finset.mem_coe,filter_classical] at hh ⊢ rw [← hh,sum_mul] apply sum_congr rfl intro A hA split_ifs <;> ring end BelowOne.FKPressure end end section noncomputable section open Finset namespace BelowOne.FKPressure attribute [local instance] Classical.propDecidable variable {V I : Type*} [Fintype V] def incidentProduct (ends : I → V × V) (E : Finset I) (v : I → ℝ) (i : V) : ℝ := ∏ e ∈ E, (if (ends e).1 = i then 1 + v e else 1) * (if (ends e).2 = i then 1 + v e else 1) def incidentScale (ends : I → V × V) (E : Finset I) (v : I → ℝ) (i : V) : ℝ := (incidentProduct ends E v i)⁻¹ omit [Fintype V] in lemma incidentProduct_pos (ends : I → V × V) (E : Finset I) (v : I → ℝ) (hv : ∀ e ∈ E, 0 ≤ v e) (i : V) : 0 < incidentProduct ends E v i := by unfold incidentProduct apply prod_pos intro e he apply mul_pos <;> split_ifs <;> linarith [hv e he] omit [Fintype V] in lemma incidentProduct_subprod (ends : I → V × V) (E : Finset I) (v : I → ℝ) (T : Finset V) : (∏ i ∈ T, incidentProduct ends E v i) = ∏ e ∈ E, (if (ends e).1 ∈ T then 1 + v e else 1) * (if (ends e).2 ∈ T then 1 + v e else 1) := by unfold incidentProduct rw [prod_comm] apply prod_congr rfl intro e he rw [prod_mul_distrib] simp only [prod_ite_eq] omit [Fintype V] in lemma incident_product_identity (ends : I → V × V) (E : Finset I) (v : I → ℝ) (T : Finset V) : (∏ e ∈ E, (1 + v e)) * (∏ e ∈ E.filter (fun e => (ends e).1 ∈ T ∧ (ends e).2 ∈ T), (1 + v e)) = (∏ i ∈ T, incidentProduct ends E v i) * (∏ e ∈ E.filter (fun e => (ends e).1 ∉ T ∧ (ends e).2 ∉ T), (1 + v e)) := by rw [incidentProduct_subprod] simp only [prod_filter] rw [← prod_mul_distrib,← prod_mul_distrib] apply prod_congr rfl intro e he split_ifs <;> simp_all omit [Fintype V] in lemma percolationCoefficient_rescale (ends : I → V × V) (E : Finset I) (s : ℝ) (v : I → ℝ) (hv : ∀ e ∈ E, 0 ≤ v e) (T : Finset V) : percolationCoefficient ends E s v T = (∏ i ∈ T, incidentScale ends E v i) * squarefreeMoment ends E s v T := by have hP : (∏ e ∈ E, (1 + v e)) ≠ 0 := ne_of_gt (prod_pos (fun e he => by linarith [hv e he])) have hD : (∏ i ∈ T, incidentProduct ends E v i) ≠ 0 := ne_of_gt (prod_pos (fun i hi => incidentProduct_pos ends E v hv i)) have hid := incident_product_identity ends E v T unfold percolationCoefficient squarefreeMoment incidentScale rw [prod_inv_distrib] simp only [Finset.mem_coe,filter_classical] at hid ⊢ field_simp nlinarith [congrArg (fun r : ℝ => r * inducedPartition ends E s v T) hid] lemma percolationSitePolynomial_rescale (ends : I → V × V) (E : Finset I) (s : ℝ) (v : I → ℝ) (hv : ∀ e ∈ E, 0 ≤ v e) (x : V → ℝ) : percolationSitePolynomial ends E s v x = unscaledSitePolynomial ends E s v (fun i => incidentScale ends E v i * x i) := by rw [percolationSitePolynomial_eq] unfold unscaledSitePolynomial MultiaffineDerivative.polynomial apply sum_congr rfl intro T hT rw [percolationCoefficient_rescale ends E s v hv T,prod_mul_distrib] ring end BelowOne.FKPressure end end section noncomputable section open Finset open scoped Classical namespace BelowOne.MultiaffineDerivative variable {V : Type*} [Fintype V] def diagonalEquiv (c : V → ℝ) (hc : ∀ i, c i ≠ 0) : (V → ℝ) ≃L[ℝ] (V → ℝ) where toFun x i := c i * x i invFun x i := (c i)⁻¹ * x i left_inv x := by ext i; simp [hc i] right_inv x := by ext i; simp [hc i] map_add' x y := by ext i; exact mul_add _ _ _ map_smul' a x := by ext i; simp only [Pi.smul_apply,smul_eq_mul,RingHom.id_apply]; ring continuous_toFun := by fun_prop continuous_invFun := by fun_prop omit [Fintype V] in lemma diagonalEquiv_coordinate (c : V → ℝ) (hc : ∀ i, c i ≠ 0) (i : V) : diagonalEquiv c hc (coordinate i) = c i • coordinate i := by ext j by_cases h : i = j · subst j; simp [diagonalEquiv,coordinate] · simp [diagonalEquiv,coordinate,h] lemma iteratedFDeriv_diagonal (f : (V → ℝ) → ℝ) (c : V → ℝ) (hc : ∀ i, c i ≠ 0) (n : ℕ) (τ : Fin n → V) : iteratedFDeriv ℝ n (fun x => f (fun i => c i * x i)) 0 (coordinate ∘ τ) = (∏ j, c (τ j)) * iteratedFDeriv ℝ n f 0 (coordinate ∘ τ) := by have h := (diagonalEquiv c hc).iteratedFDerivWithin_comp_right f (s := Set.univ) uniqueDiffOn_univ (x := 0) (Set.mem_univ _) n simp only [Set.preimage_univ,iteratedFDerivWithin_univ,map_zero] at h change iteratedFDeriv ℝ n (f ∘ diagonalEquiv c hc) 0 (coordinate ∘ τ) = _ rw [h,ContinuousMultilinearMap.compContinuousLinearMap_apply] change iteratedFDeriv ℝ n f 0 (fun j => diagonalEquiv c hc (coordinate (τ j))) = _ simp_rw [diagonalEquiv_coordinate] rw [ContinuousMultilinearMap.map_smul_univ] rfl end BelowOne.MultiaffineDerivative end end section noncomputable section open Finset SimpleGraph open scoped Classical namespace BelowOne.FKPressure variable {V I : Type*} [Fintype V] lemma percolationSitePolynomial_zero (ends : I → V × V) (E : Finset I) (s : ℝ) (v : I → ℝ) (hv : ∀ e ∈ E, 0 ≤ v e) : percolationSitePolynomial ends E s v 0 = 1 := by rw [percolationSitePolynomial_rescale ends E s v hv] simp only [Pi.zero_apply,mul_zero] exact unscaledSitePolynomial_zero ends E s v lemma percolationSitePolynomial_log_derivative_nonpos {n : ℕ} (hn : 0 < n) (τ : Fin n → V) (ends : I → V × V) (E : Finset I) {u : ℝ} (hu : 0 < u) (hu1 : u < 1) (v : I → ℝ) (hv : ∀ e ∈ E, 0 ≤ v e) : iteratedFDeriv ℝ n (Real.log ∘ percolationSitePolynomial ends E (-u) v) 0 (MultiaffineDerivative.coordinate ∘ τ) ≤ 0 := by have heq : Real.log ∘ percolationSitePolynomial ends E (-u) v = fun x => (Real.log ∘ unscaledSitePolynomial ends E (-u) v) (fun i => incidentScale ends E v i * x i) := by funext x simp only [Function.comp_apply,percolationSitePolynomial_rescale ends E (-u) v hv] rw [heq,MultiaffineDerivative.iteratedFDeriv_diagonal] · apply mul_nonpos_of_nonneg_of_nonpos · exact prod_nonneg (fun i _ => (inv_pos.mpr (incidentProduct_pos ends E v hv (τ i))).le) · exact unscaledSitePolynomial_log_derivative_nonpos hn τ ends E hu hu1 v hv · intro i exact ne_of_gt (inv_pos.mpr (incidentProduct_pos ends E v hv i)) lemma componentProduct_pos (G : SimpleGraph V) {u : ℝ} (hu : 0 ≤ u) (hu1 : u < 1) (x : V → ℝ) (hx : ∀ i, x i ∈ Set.Icc 0 1) : 0 < componentProduct G (-u) x := by unfold componentProduct apply prod_pos intro c hc have hb : (∏ i ∈ univ.filter (fun i => G.connectedComponentMk i = c), x i) ≤ 1 := prod_le_one₀ (fun i _ => (hx i).1) (fun i _ => (hx i).2) nlinarith lemma percolationSitePolynomial_pos (ends : I → V × V) (E : Finset I) {u : ℝ} (hu : 0 ≤ u) (hu1 : u < 1) (v : I → ℝ) (hv : ∀ e ∈ E, 0 ≤ v e) (x : V → ℝ) (hx : ∀ i, x i ∈ Set.Icc 0 1) : 0 < percolationSitePolynomial ends E (-u) v x := by unfold percolationSitePolynomial apply div_pos · apply sum_pos' · intro A hA exact mul_nonneg (prod_nonneg (fun e he => hv e ((mem_powerset.mp hA) he))) (componentProduct_pos _ hu hu1 x hx).le · refine ⟨∅,mem_powerset.mpr (empty_subset E),?_⟩ simpa only [prod_empty,one_mul] using componentProduct_pos (graph ⊥ ends ∅) hu hu1 x hx · exact prod_pos (fun e he => by linarith [hv e he]) end BelowOne.FKPressure end end section noncomputable section open Finset open scoped Classical namespace BelowOne.PositiveMultilinear open MultiaffineDerivative variable {V : Type*} [Fintype V] {n : ℕ} lemma sum_coordinates (x : V → ℝ) : ∑ i, x i • coordinate i = x := by ext j simp [coordinate,Pi.single_apply] lemma expansion (F : ContinuousMultilinearMap ℝ (fun _ : Fin n => V → ℝ) ℝ) (x : Fin n → V → ℝ) : F x = ∑ τ : Fin n → V, (∏ j, x j (τ j)) * F (coordinate ∘ τ) := by conv_lhs => rw [show x = fun j => ∑ i, x j i • coordinate i by simp only [sum_coordinates]] rw [F.map_sum] apply sum_congr rfl intro τ hτ rw [F.map_smul_univ] rfl lemma nonneg (F : ContinuousMultilinearMap ℝ (fun _ : Fin n => V → ℝ) ℝ) (hF : ∀ τ : Fin n → V, 0 ≤ F (coordinate ∘ τ)) (x : Fin n → V → ℝ) (hx : ∀ j i, 0 ≤ x j i) : 0 ≤ F x := by rw [expansion] exact sum_nonneg (fun τ _ => mul_nonneg (prod_nonneg (fun j _ => hx j (τ j))) (hF τ)) lemma ones_eq_sum (F : ContinuousMultilinearMap ℝ (fun _ : Fin n => V → ℝ) ℝ) : F (fun _ _ => 1) = ∑ τ : Fin n → V, F (coordinate ∘ τ) := by rw [expansion] simp only [prod_const_one,one_mul] lemma norm_le_ones (F : ContinuousMultilinearMap ℝ (fun _ : Fin n => V → ℝ) ℝ) (hF : ∀ τ : Fin n → V, 0 ≤ F (coordinate ∘ τ)) : ‖F‖ ≤ F (fun _ _ => 1) := by apply F.opNorm_le_bound (nonneg F hF _ (fun _ _ => zero_le_one)) intro x rw [expansion,ones_eq_sum,sum_mul] refine (norm_sum_le _ _).trans (sum_le_sum ?_) intro τ hτ rw [norm_mul,Real.norm_of_nonneg (hF τ),mul_comm] apply mul_le_mul_of_nonneg_left _ (hF τ) rw [norm_prod] apply prod_le_prod₀ (fun j _ => norm_nonneg _) (fun j _ => ?_) exact norm_le_pi_norm (x j) (τ j) end BelowOne.PositiveMultilinear end end section noncomputable section open scoped Topology NNReal ENNReal open Filter Set FormalMultilinearSeries namespace BelowOne.PositiveSeries lemma scalar_apply_nonneg (c : ℕ → ℝ) (hc : ∀ n, 0 ≤ c n) (n : ℕ) (v : Fin n → ℝ) (hv : ∀ i, 0 ≤ v i) : 0 ≤ ofScalars ℝ c n v := by simp only [ofScalars, _root_.smul_apply, ContinuousMultilinearMap.mkPiAlgebraFin_apply, smul_eq_mul, List.prod_ofFn] exact mul_nonneg (hc n) (Finset.prod_nonneg (fun i _ => hv i)) lemma summable_add_of_shift (c : ℕ → ℝ) (hc : ∀ n, 0 ≤ c n) {x y : ℝ} (hx : 0 ≤ x) (hy : 0 ≤ y) (hxr : (‖x‖₊ : ℝ≥0∞) < (ofScalars ℝ c).radius) (hshift : Summable fun k => (ofScalars ℝ c).changeOrigin x k (fun _ => y)) : Summable fun n => ofScalars ℝ c n (fun _ => x+y) := by let p := ofScalars ℝ c let f : (Σ k l : ℕ, {s : Finset (Fin (k+l)) // s.card = l}) → ℝ := fun s => p.changeOriginSeriesTerm s.1 s.2.1 s.2.2 s.2.2.2 (fun _ => x) (fun _ => y) have fnonneg : ∀ s, 0 ≤ f s := by intro s dsimp [f] rw [changeOriginSeriesTerm_apply] apply scalar_apply_nonneg c hc intro i dsimp only [Finset.piecewise] split_ifs <;> assumption have hinner (k : ℕ) : HasSum (fun s => f ⟨k,s⟩) (p.changeOrigin x k (fun _ => y)) := by apply ContinuousMultilinearMap.hasSum_eval have ht := (p.hasFPowerSeriesOnBall_changeOrigin k hxr.pos).hasSum (mem_eball_zero_iff.mpr hxr) rw [zero_add] at ht refine HasSum.sigma_of_hasSum ht (fun l => ?_) ?_ · simp only [changeOriginSeries, sum_apply] exact hasSum_fintype _ · refine .of_nnnorm_bounded (p.changeOriginSeries_summable_aux₂ hxr k) ?_ intro s refine (ContinuousMultilinearMap.le_opNNNorm _ _).trans_eq ?_ simp have hsf : Summable f := (summable_sigma_of_nonneg fnonneg).mpr ⟨fun k => (hinner k).summable, by simpa only [(hinner _).tsum_eq] using hshift⟩ have hs := (changeOriginIndexEquiv.symm.summable_iff.mpr hsf).sigma apply hs.congr intro n change (∑' s : Finset (Fin n), f (changeOriginIndexEquiv.symm ⟨n,s⟩)) = p n (fun _ => x+y) rw [tsum_fintype, ← Pi.add_def, (p n).map_add_univ (fun _ => x) (fun _ => y)] simp_rw [← changeOriginSeriesTerm_changeOriginIndexEquiv_symm] rfl lemma radius_add_le (c : ℕ → ℝ) (hc : ∀ n, 0 ≤ c n) (x y : ℝ≥0) (hx : (x : ℝ≥0∞) < (ofScalars ℝ c).radius) (hy : (y : ℝ≥0∞) < ((ofScalars ℝ c).changeOrigin (x : ℝ)).radius) : ((x+y : ℝ≥0) : ℝ≥0∞) ≤ (ofScalars ℝ c).radius := by have hs := summable_add_of_shift c hc x.coe_nonneg y.coe_nonneg (by simpa using hx) (((ofScalars ℝ c).changeOrigin (x : ℝ)).summable (by simpa only [mem_eball_zero_iff, enorm_eq_nnnorm, NNReal.nnnorm_eq] using hy)) apply (ofScalars ℝ c).le_radius_of_summable (r := x+y) simpa only [ofScalars_norm, Real.norm_eq_abs, abs_of_nonneg (hc _), NNReal.coe_add, ofScalars_apply_eq, smul_eq_mul] using hs theorem not_analytic_at_radius (c : ℕ → ℝ) (hc : ∀ n, 0 ≤ c n) (R : ℝ≥0) (hR : 0 < R) (hr : (ofScalars ℝ c).radius = R) (f : ℝ → ℝ) (heq : EqOn f (ofScalars ℝ c).sum (Ioo 0 (R : ℝ))) : ¬ AnalyticAt ℝ f (R : ℝ) := by intro ha obtain ⟨q,r,hq⟩ := ha obtain ⟨e,he0,he⟩ := ENNReal.lt_iff_exists_nnreal_btwn.mp (show (0 : ℝ≥0∞) < min (R : ℝ≥0∞) r from lt_min (by exact_mod_cast hR) hq.r_pos) have hepos : 0 < e := by exact_mod_cast he0 have heR : e < R := by exact_mod_cast (lt_min_iff.mp he).1 have her : (e : ℝ≥0∞) < r := (lt_min_iff.mp he).2 let d : ℝ≥0 := e/4 have hdpos : 0 < d := div_pos hepos (by norm_num) have hdR : d < R := by dsimp [d]; linarith have hde : 3*d < e := by dsimp [d]; linarith have hd_le_e : d ≤ e := by dsimp [d]; linarith let x : ℝ≥0 := R-d have hdx : x+d=R := tsub_add_cancel_of_le hdR.le have hxpos : 0 < x := tsub_pos_iff_lt.mpr hdR have hxR : x < R := by linarith have hxr : (x : ℝ≥0∞) < (ofScalars ℝ c).radius := by rw [hr]; exact_mod_cast hxR have hdr : (‖-(d : ℝ)‖₊ : ℝ≥0∞) < r := by simpa using (show (d : ℝ≥0∞) < r from (show (d : ℝ≥0∞) ≤ (e : ℝ≥0∞) by exact_mod_cast hd_le_e).trans_lt her) have hsright := hq.changeOrigin hdr have hcenter : (R : ℝ) + -(d : ℝ) = (x : ℝ) := by have hh : (x : ℝ)+(d : ℝ)=(R : ℝ) := by exact_mod_cast hdx linarith rw [hcenter] at hsright have hsleft := ((ofScalars ℝ c).hasFPowerSeriesOnBall hxr.pos).changeOrigin (show (‖(x : ℝ)‖₊ : ℝ≥0∞) < (ofScalars ℝ c).radius by simpa using hxr) rw [zero_add] at hsleft have hloc : (ofScalars ℝ c).sum =ᶠ[𝓝 (x : ℝ)] f := by filter_upwards [Ioo_mem_nhds (by exact_mod_cast hxpos) (by exact_mod_cast hxR)] with z hz exact (heq hz).symm have hseries := (hsleft.hasFPowerSeriesAt.congr hloc).eq_formalMultilinearSeries hsright.hasFPowerSeriesAt have hy : ((2*d : ℝ≥0) : ℝ≥0∞) < ((ofScalars ℝ c).changeOrigin (x : ℝ)).radius := by rw [hseries] apply lt_of_lt_of_le _ hsright.r_le simp only [nnnorm_neg, NNReal.nnnorm_eq] rw [lt_tsub_iff_right] calc ((2*d : ℝ≥0) : ℝ≥0∞) + (d : ℝ≥0∞) = ((3*d : ℝ≥0) : ℝ≥0∞) := by push_cast; ring _ < (e : ℝ≥0∞) := by exact_mod_cast hde _ < r := her have hh := radius_add_le c hc x (2*d) hxr hy rw [hr] at hh have hcast : x+2*d ≤ R := by exact_mod_cast hh linarith theorem radius_gt_of_analytic_interval (c : ℕ → ℝ) (hc : ∀ n, 0 ≤ c n) (B : ℝ≥0) (f : ℝ → ℝ) (hp : HasFPowerSeriesAt f (ofScalars ℝ c) 0) (hf : AnalyticOnNhd ℝ f (Icc 0 (B : ℝ))) : (B : ℝ≥0∞) < (ofScalars ℝ c).radius := by by_contra hb have hle : (ofScalars ℝ c).radius ≤ B := le_of_not_gt hb have hfin : (ofScalars ℝ c).radius ≠ ⊤ := ne_top_of_le_ne_top ENNReal.coe_ne_top hle let R := (ofScalars ℝ c).radius.toNNReal have hr : (ofScalars ℝ c).radius = (R : ℝ≥0∞) := (ENNReal.coe_toNNReal hfin).symm have hR : 0 < R := by have hh := hp.radius_pos rw [hr] at hh exact_mod_cast hh have hRB : R ≤ B := by rw [hr] at hle; exact_mod_cast hle have hloc : f =ᶠ[𝓝 0] (ofScalars ℝ c).sum := by filter_upwards [hp.eventually_hasSum] with z hz simpa only [zero_add, FormalMultilinearSeries.sum] using hz.tsum_eq.symm have hfs : AnalyticOnNhd ℝ f (Ico 0 (R : ℝ)) := hf.mono (fun z hz => ⟨hz.1, hz.2.le.trans (by exact_mod_cast hRB)⟩) have hps : AnalyticOnNhd ℝ (ofScalars ℝ c).sum (Ico 0 (R : ℝ)) := by apply (ofScalars ℝ c).analyticOnNhd.mono intro z hz rw [mem_eball_zero_iff, hr, enorm_eq_nnnorm, ENNReal.coe_lt_coe] exact_mod_cast (show ‖z‖ < (R : ℝ) by simpa [Real.norm_eq_abs, abs_of_nonneg hz.1] using hz.2) have heq := hfs.eqOn_of_preconnected_of_eventuallyEq hps isPreconnected_Ico (show (0 : ℝ) ∈ Ico 0 (R : ℝ) from ⟨le_rfl, by exact_mod_cast hR⟩) hloc exact not_analytic_at_radius c hc R hR hr f (heq.mono Ioo_subset_Ico_self) (hf R ⟨R.coe_nonneg, by exact_mod_cast hRB⟩) end BelowOne.PositiveSeries end end section noncomputable section open Finset Filter Set FormalMultilinearSeries open scoped Topology NNReal ENNReal Classical namespace BelowOne.PositiveAnalyticCube open MultiaffineDerivative variable {V : Type*} [Fintype V] def cube : Set (V → ℝ) := {x | ∀ i, x i ∈ Set.Icc 0 1} def diagonal : ℝ →L[ℝ] (V → ℝ) := ContinuousLinearMap.pi fun _ => ContinuousLinearMap.id ℝ ℝ def taylor (f : (V → ℝ) → ℝ) : FormalMultilinearSeries ℝ (V → ℝ) ℝ := fun n => (n.factorial : ℝ)⁻¹ • iteratedFDeriv ℝ n f 0 def diagonalCoefficient (f : (V → ℝ) → ℝ) (n : ℕ) : ℝ := taylor f n (fun _ _ => 1) lemma taylor_diagonal_eq {f : (V → ℝ) → ℝ} {p : FormalMultilinearSeries ℝ (V → ℝ) ℝ} {r : ℝ≥0∞} (hp : HasFPowerSeriesOnBall f p 0 r) (x : V → ℝ) (n : ℕ) : taylor f n (fun _ => x) = p n (fun _ => x) := by have h := hp.factorial_smul x n simp only [nsmul_eq_mul] at h rw [taylor,_root_.smul_apply,smul_eq_mul,←h] rw [←mul_assoc,inv_mul_cancel₀ (Nat.cast_ne_zero.mpr n.factorial_ne_zero),one_mul] lemma diagonal_hasFPowerSeriesAt {f : (V → ℝ) → ℝ} (hf : AnalyticAt ℝ f 0) : HasFPowerSeriesAt (f ∘ diagonal) (ofScalars ℝ (diagonalCoefficient f)) 0 := by obtain ⟨p,r,hp⟩ := hf have hs : HasFPowerSeriesAt (f ∘ diagonal) (p.compContinuousLinearMap diagonal) 0 := (show HasFPowerSeriesAt f p (diagonal (V := V) 0) by simpa using hp.hasFPowerSeriesAt).compContinuousLinearMap convert hs using 1 ext n rw [FormalMultilinearSeries.apply_eq_prod_smul_coeff,FormalMultilinearSeries.apply_eq_prod_smul_coeff, coeff_ofScalars] congr 1 rw [diagonalCoefficient,taylor_diagonal_eq hp] rfl lemma taylor_coordinate_nonneg (f : (V → ℝ) → ℝ) (hf0 : 0 ≤ f 0) (hf : ∀ n, 0 < n → ∀ τ : Fin n → V, 0 ≤ iteratedFDeriv ℝ n f 0 (coordinate ∘ τ)) (n : ℕ) (τ : Fin n → V) : 0 ≤ taylor f n (coordinate ∘ τ) := by rw [taylor,_root_.smul_apply,smul_eq_mul] apply mul_nonneg (by positivity) by_cases hn : n = 0 · subst n simpa only [iteratedFDeriv_zero_apply] using hf0 · exact hf n (Nat.pos_of_ne_zero hn) τ lemma diagonalCoefficient_nonneg (f : (V → ℝ) → ℝ) (hf0 : 0 ≤ f 0) (hf : ∀ n, 0 < n → ∀ τ : Fin n → V, 0 ≤ iteratedFDeriv ℝ n f 0 (coordinate ∘ τ)) (n : ℕ) : 0 ≤ diagonalCoefficient f n := PositiveMultilinear.nonneg _ (taylor_coordinate_nonneg f hf0 hf n) _ (fun _ _ => zero_le_one) lemma radius_le_of_norm_le {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [NormedAddCommGroup F] [NormedSpace ℝ F] (p : FormalMultilinearSeries ℝ E ℝ) (q : FormalMultilinearSeries ℝ F ℝ) (h : ∀ n, ‖q n‖ ≤ ‖p n‖) : p.radius ≤ q.radius := by unfold FormalMultilinearSeries.radius apply iSup_le intro r apply iSup_le intro C apply iSup_le intro hC apply q.le_radius_of_bound C intro n exact (mul_le_mul_of_nonneg_right (h n) (by positivity)).trans (hC n) lemma taylor_radius_gt_one (f : (V → ℝ) → ℝ) (hf0 : 0 ≤ f 0) (hf : ∀ n, 0 < n → ∀ τ : Fin n → V, 0 ≤ iteratedFDeriv ℝ n f 0 (coordinate ∘ τ)) (ha : AnalyticOnNhd ℝ f cube) : 1 < (taylor f).radius := by have ha0 : AnalyticAt ℝ f 0 := ha 0 (fun i => by simp) have hd : AnalyticOnNhd ℝ (f ∘ diagonal) (Set.Icc (0:ℝ) 1) := by intro x hx exact (ha (diagonal x) (fun _ => hx)).compContinuousLinearMap have hR := PositiveSeries.radius_gt_of_analytic_interval (diagonalCoefficient f) (diagonalCoefficient_nonneg f hf0 hf) 1 (f ∘ diagonal) (diagonal_hasFPowerSeriesAt ha0) hd apply hR.trans_le apply radius_le_of_norm_le intro n rw [ofScalars_norm,Real.norm_of_nonneg (diagonalCoefficient_nonneg f hf0 hf n)] exact PositiveMultilinear.norm_le_ones _ (taylor_coordinate_nonneg f hf0 hf n) lemma hasFPowerSeriesAt_taylor {f : (V → ℝ) → ℝ} (hf : AnalyticAt ℝ f 0) (hR : 0 < (taylor f).radius) : HasFPowerSeriesAt f (taylor f) 0 := by obtain ⟨p,r,hp⟩ := hf refine ⟨min r (taylor f).radius, ?_⟩ refine ⟨min_le_right _ _,lt_min hp.r_pos hR,?_⟩ intro x hx have hx' : x ∈ Metric.eball 0 r := by exact mem_eball_zero_iff.mpr ((mem_eball_zero_iff.mp hx).trans_le (min_le_left _ _)) simpa only [taylor,_root_.smul_apply] using hp.hasSum_iteratedFDeriv hx' omit [Fintype V] in lemma cube_convex : Convex ℝ (cube (V := V)) := by have hc : cube (V := V) = Set.pi Set.univ (fun _ : V => Set.Icc (0:ℝ) 1) := by ext x change (∀ i, x i ∈ Set.Icc 0 1) ↔ ∀ i ∈ Set.univ, x i ∈ Set.Icc 0 1 simp only [Set.mem_univ, forall_true_left] rw [hc] exact convex_pi (fun _ _ => convex_Icc 0 1) lemma cube_subset_eball {r : ℝ≥0∞} (hr : 1 < r) : cube (V := V) ⊆ Metric.eball 0 r := by intro x hx have hn : ‖x‖ ≤ 1 := by apply (pi_norm_le_iff_of_nonneg zero_le_one).mpr intro i exact (Real.norm_of_nonneg (hx i).1).trans_le (hx i).2 apply mem_eball_zero_iff.mpr exact (show ‖x‖ₑ ≤ (1:ℝ≥0∞) by rw [enorm_eq_nnnorm,← ENNReal.coe_one,ENNReal.coe_le_coe] exact_mod_cast hn).trans_lt hr lemma taylor_sum_eq_on_cube (f : (V → ℝ) → ℝ) (hf0 : 0 ≤ f 0) (hf : ∀ n, 0 < n → ∀ τ : Fin n → V, 0 ≤ iteratedFDeriv ℝ n f 0 (coordinate ∘ τ)) (ha : AnalyticOnNhd ℝ f cube) : Set.EqOn f (taylor f).sum cube := by have hR := taylor_radius_gt_one f hf0 hf ha have hp := hasFPowerSeriesAt_taylor (ha 0 (fun i => by simp)) (zero_lt_one.trans hR) have heq : f =ᶠ[𝓝 0] (taylor f).sum := by filter_upwards [hp.eventually_hasSum] with x hx simpa only [zero_add,FormalMultilinearSeries.sum] using hx.tsum_eq.symm exact ha.eqOn_of_preconnected_of_eventuallyEq ((taylor f).analyticOnNhd.mono (cube_subset_eball hR)) cube_convex.isPreconnected (fun i => by simp) heq end BelowOne.PositiveAnalyticCube end end section noncomputable section open Finset Filter Set FormalMultilinearSeries open scoped Topology NNReal ENNReal Classical namespace BelowOne.FKPressure variable {V I : Type*} [Fintype V] def pressure (ends : I → V × V) (E : Finset I) (u : ℝ) (v : I → ℝ) (x : V → ℝ) : ℝ := -Real.log (percolationSitePolynomial ends E (-u) v x) lemma analyticAt_percolationSitePolynomial (ends : I → V × V) (E : Finset I) (s : ℝ) (v : I → ℝ) (x : V → ℝ) : AnalyticAt ℝ (percolationSitePolynomial ends E s v) x := by rw [percolationSitePolynomial_eq] unfold MultiaffineDerivative.polynomial apply Finset.analyticAt_fun_sum intro T hT apply AnalyticAt.mul analyticAt_const apply Finset.analyticAt_fun_prod intro i hi exact (ContinuousLinearMap.proj i : (V → ℝ) →L[ℝ] ℝ).analyticAt x lemma pressure_zero (ends : I → V × V) (E : Finset I) (u : ℝ) (v : I → ℝ) (hv : ∀ e ∈ E, 0 ≤ v e) : pressure ends E u v 0 = 0 := by simp only [pressure,percolationSitePolynomial_zero ends E (-u) v hv,Real.log_one,neg_zero] lemma pressure_derivative_nonneg (ends : I → V × V) (E : Finset I) {u : ℝ} (hu : 0 < u) (hu1 : u < 1) (v : I → ℝ) (hv : ∀ e ∈ E, 0 ≤ v e) (n : ℕ) (hn : 0 < n) (τ : Fin n → V) : 0 ≤ iteratedFDeriv ℝ n (pressure ends E u v) 0 (MultiaffineDerivative.coordinate ∘ τ) := by change 0 ≤ iteratedFDeriv ℝ n (-(fun x => Real.log (percolationSitePolynomial ends E (-u) v x))) 0 (MultiaffineDerivative.coordinate ∘ τ) rw [iteratedFDeriv_neg_apply,_root_.neg_apply] exact neg_nonneg.mpr (percolationSitePolynomial_log_derivative_nonpos hn τ ends E hu hu1 v hv) lemma pressure_analyticOn_cube (ends : I → V × V) (E : Finset I) {u : ℝ} (hu : 0 ≤ u) (hu1 : u < 1) (v : I → ℝ) (hv : ∀ e ∈ E, 0 ≤ v e) : AnalyticOnNhd ℝ (pressure ends E u v) PositiveAnalyticCube.cube := by intro x hx exact ((analyticAt_log (percolationSitePolynomial_pos ends E hu hu1 v hv x hx)).comp (analyticAt_percolationSitePolynomial ends E (-u) v x)).neg theorem pressure_expansion (ends : I → V × V) (E : Finset I) {u : ℝ} (hu : 0 < u) (hu1 : u < 1) (v : I → ℝ) (hv : ∀ e ∈ E, 0 ≤ v e) : let p := PositiveAnalyticCube.taylor (pressure ends E u v) 1 < p.radius ∧ (∀ n (τ : Fin n → V), 0 ≤ p n (MultiaffineDerivative.coordinate ∘ τ)) ∧ (∀ x ∈ PositiveAnalyticCube.cube, HasSum (fun n => p n (fun _ => x)) (pressure ends E u v x)) := by dsimp only have hf0 : 0 ≤ pressure ends E u v 0 := (pressure_zero ends E u v hv).ge have hf := pressure_derivative_nonneg ends E hu hu1 v hv have ha := pressure_analyticOn_cube ends E hu.le hu1 v hv have hR := PositiveAnalyticCube.taylor_radius_gt_one _ hf0 hf ha refine ⟨hR,PositiveAnalyticCube.taylor_coordinate_nonneg _ hf0 hf,?_⟩ intro x hx rw [PositiveAnalyticCube.taylor_sum_eq_on_cube _ hf0 hf ha hx] exact (PositiveAnalyticCube.taylor (pressure ends E u v)).summable (PositiveAnalyticCube.cube_subset_eball hR hx) |>.hasSum end BelowOne.FKPressure end end end OAI