| import OAI.Probability.FreeIsing.Model |
|
|
| namespace OAI |
|
|
| namespace Problem367 |
|
|
| noncomputable section |
|
|
| open Relation |
|
|
| variable {d : ℕ} |
|
|
| theorem ConnectedFinset.image {D : Finset (TreeVertex d)} |
| (hD : ConnectedFinset D) (g : TreeAut d) : |
| ConnectedFinset (D.image g.toEquiv) := by |
| classical |
| refine ⟨hD.1.image _, ?_⟩ |
| intro u hu v hv |
| obtain ⟨u, huD, rfl⟩ := Finset.mem_image.mp hu |
| obtain ⟨v, hvD, rfl⟩ := Finset.mem_image.mp hv |
| exact ReflTransGen.lift g.toEquiv |
| (fun x y hxy => ⟨Finset.mem_image.mpr ⟨x, hxy.1, rfl⟩, |
| Finset.mem_image.mpr ⟨y, hxy.2.1, rfl⟩, |
| (g.map_adj x y).mpr hxy.2.2⟩) _ _ (hD.2 u huD v hvD) |
|
|
| namespace CylinderAut |
|
|
| private theorem adj_symm {u v : TreeVertex d} (h : treeAdj u v) : treeAdj v u := |
| h.symm |
|
|
| private theorem length_ne_of_adj {u v : TreeVertex d} (h : treeAdj u v) : |
| u.1.length ≠ v.1.length := by |
| rcases h with ⟨c, hc⟩ | ⟨c, hc⟩ |
| all_goals |
| have hlen := congrArg List.length hc |
| simp only [List.length_append, List.length_singleton] at hlen |
| omega |
|
|
| def orient (e : TreeVertex d × TreeVertex d) : TreeVertex d × TreeVertex d := |
| if e.1.1.length < e.2.1.length then e else e.swap |
|
|
| private theorem orient_swap (e : TreeVertex d × TreeVertex d) |
| (hne : e.1.1.length ≠ e.2.1.length) : |
| orient e.swap = orient e := by |
| unfold orient |
| simp only [Prod.fst_swap, Prod.snd_swap, Prod.swap_swap] |
| split_ifs <;> first | rfl | (exfalso; omega) |
| |
| private theorem mem_inducedEdges {D : Finset (TreeVertex d)} |
| {e : TreeVertex d × TreeVertex d} : |
| e ∈ inducedEdges D ↔ e.1 ∈ D ∧ e.2 ∈ D ∧ treeAdj e.1 e.2 ∧ |
| e.1.1.length < e.2.1.length := by |
| classical |
| simp [inducedEdges, and_assoc] |
|
|
| private theorem orient_mem {D : Finset (TreeVertex d)} |
| {e : TreeVertex d × TreeVertex d} (h₁ : e.1 ∈ D) (h₂ : e.2 ∈ D) |
| (ha : treeAdj e.1 e.2) : orient e ∈ inducedEdges D := by |
| classical |
| unfold orient |
| split_ifs with h |
| · exact mem_inducedEdges.mpr ⟨h₁, h₂, ha, h⟩ |
| · exact mem_inducedEdges.mpr ⟨h₂, h₁, adj_symm ha, |
| lt_of_le_of_ne (le_of_not_gt h) (length_ne_of_adj ha).symm⟩ |
|
|
| private theorem orient_eq_of_mem {D : Finset (TreeVertex d)} |
| {e : TreeVertex d × TreeVertex d} (he : e ∈ inducedEdges D) : |
| orient e = e := by |
| simp [orient, (mem_inducedEdges.mp he).2.2.2] |
|
|
| def push (g : TreeAut d) (e : TreeVertex d × TreeVertex d) : |
| TreeVertex d × TreeVertex d := |
| orient (g.toEquiv e.1, g.toEquiv e.2) |
|
|
| def pull (g : TreeAut d) (e : TreeVertex d × TreeVertex d) : |
| TreeVertex d × TreeVertex d := |
| orient (g.toEquiv.symm e.1, g.toEquiv.symm e.2) |
|
|
| private theorem push_mem (g : TreeAut d) {D : Finset (TreeVertex d)} |
| {e : TreeVertex d × TreeVertex d} (he : e ∈ inducedEdges D) : |
| push g e ∈ inducedEdges (D.image g.toEquiv) := by |
| classical |
| obtain ⟨h₁, h₂, ha, _⟩ := mem_inducedEdges.mp he |
| exact orient_mem (Finset.mem_image.mpr ⟨e.1, h₁, rfl⟩) |
| (Finset.mem_image.mpr ⟨e.2, h₂, rfl⟩) ((g.map_adj _ _).mpr ha) |
|
|
| private theorem pull_push (g : TreeAut d) {D : Finset (TreeVertex d)} |
| {e : TreeVertex d × TreeVertex d} (he : e ∈ inducedEdges D) : |
| pull g (push g e) = e := by |
| have hedir := (mem_inducedEdges.mp he).2.2.2 |
| unfold push pull orient |
| by_cases h : (g.toEquiv e.1).1.length < (g.toEquiv e.2).1.length |
| all_goals simp [h, hedir, not_lt_of_ge (le_of_lt hedir)] |
|
|
| private theorem pull_mem (g : TreeAut d) {D : Finset (TreeVertex d)} |
| {e : TreeVertex d × TreeVertex d} (he : e ∈ inducedEdges (D.image g.toEquiv)) : |
| pull g e ∈ inducedEdges D := by |
| classical |
| obtain ⟨h₁, h₂, ha, _⟩ := mem_inducedEdges.mp he |
| have hp₁ : g.toEquiv.symm e.1 ∈ D := by |
| obtain ⟨x, hx, hxe⟩ := Finset.mem_image.mp h₁ |
| simpa [← hxe] using hx |
| have hp₂ : g.toEquiv.symm e.2 ∈ D := by |
| obtain ⟨x, hx, hxe⟩ := Finset.mem_image.mp h₂ |
| simpa [← hxe] using hx |
| have hpa : treeAdj (g.toEquiv.symm e.1) (g.toEquiv.symm e.2) := by |
| apply (g.map_adj _ _).mp |
| simpa using ha |
| exact orient_mem hp₁ hp₂ hpa |
|
|
| private theorem push_pull (g : TreeAut d) {D : Finset (TreeVertex d)} |
| {e : TreeVertex d × TreeVertex d} (he : e ∈ inducedEdges (D.image g.toEquiv)) : |
| push g (pull g e) = e := by |
| have hedir := (mem_inducedEdges.mp he).2.2.2 |
| unfold push pull orient |
| by_cases h : (g.toEquiv.symm e.1).1.length < (g.toEquiv.symm e.2).1.length |
| all_goals simp [h, hedir, not_lt_of_ge (le_of_lt hedir)] |
|
|
| theorem prod_inducedEdges_image {M : Type*} [CommMonoid M] |
| (g : TreeAut d) (D : Finset (TreeVertex d)) |
| (f : TreeVertex d → TreeVertex d → M) |
| (hf : ∀ u v, f u v = f v u) : |
| (∏ e ∈ inducedEdges (D.image g.toEquiv), |
| f (g.toEquiv.symm e.1) (g.toEquiv.symm e.2)) = |
| ∏ e ∈ inducedEdges D, f e.1 e.2 := by |
| classical |
| symm |
| apply Finset.prod_bij (fun e _ => push g e) |
| · intro e he |
| exact push_mem g he |
| · intro e₁ he₁ e₂ he₂ heq |
| have h := congrArg (pull g) heq |
| simpa only [pull_push g he₁, pull_push g he₂] using h |
| · intro e he |
| exact ⟨pull g e, pull_mem g he, push_pull g he⟩ |
| · intro e he |
| unfold push orient |
| split_ifs |
| · simp |
| · simpa using hf e.1 e.2 |
|
|
| end CylinderAut |
|
|
| theorem freeCylinderWeight_image_relabel (g : TreeAut d) (theta : ℝ) |
| (D : Finset (TreeVertex d)) (eta : TreeVertex d → IsingSpin) : |
| freeCylinderWeight theta (D.image g.toEquiv) (relabel g eta) = |
| freeCylinderWeight theta D eta := by |
| classical |
| unfold freeCylinderWeight |
| apply congrArg ENNReal.ofReal |
| apply congrArg ((1 / 2 : ℝ) * ·) |
| exact CylinderAut.prod_inducedEdges_image g D |
| (fun u v => (1 + (if eta u = eta v then theta else -theta)) / 2) |
| (by intro u v; simp only [eq_comm]) |
| |
| private def cylinderInverseAut (g : TreeAut d) : TreeAut d where |
| toEquiv := g.toEquiv.symm |
| map_adj := by |
| intro u v |
| simpa using (g.map_adj (g.toEquiv.symm u) (g.toEquiv.symm v)).symm |
|
|
| private theorem measurable_spin_cylinder (D : Finset (TreeVertex d)) |
| (eta : TreeVertex d → IsingSpin) : |
| MeasurableSet {x : TreeVertex d → IsingSpin | ∀ v ∈ D, x v = eta v} := by |
| have hsingle (s : IsingSpin) : MeasurableSet ({s} : Set IsingSpin) := by |
| trivial |
| convert D.measurableSet_biInter |
| (fun v _ => (measurable_pi_apply v) (hsingle (eta v))) using 1 |
| ext x |
| simp |
|
|
| theorem HasFreeIsingLaw.map_relabel {theta : ℝ} |
| {mu : MeasureTheory.Measure (TreeVertex d → IsingSpin)} |
| (hmu : HasFreeIsingLaw theta mu) (g : TreeAut d) : |
| HasFreeIsingLaw theta (MeasureTheory.Measure.map (relabel g) mu) := by |
| classical |
| intro D hD eta |
| have hm : Measurable (relabel g : (TreeVertex d → IsingSpin) → _) := |
| measurable_pi_iff.mpr (fun v => measurable_pi_apply (g.toEquiv.symm v)) |
| rw [MeasureTheory.Measure.map_apply hm (measurable_spin_cylinder D eta)] |
| let gi := cylinderInverseAut g |
| have hpre : relabel g ⁻¹' {x : TreeVertex d → IsingSpin | ∀ v ∈ D, x v = eta v} = |
| {x : TreeVertex d → IsingSpin | ∀ v ∈ D.image gi.toEquiv, |
| x v = relabel gi eta v} := by |
| ext x |
| constructor |
| · intro hx v hv |
| obtain ⟨u, hu, rfl⟩ := Finset.mem_image.mp hv |
| simpa [relabel, gi, cylinderInverseAut] using hx u hu |
| · intro hx v hv |
| have hh := hx (gi.toEquiv v) (Finset.mem_image.mpr ⟨v, hv, rfl⟩) |
| simpa [relabel, gi, cylinderInverseAut] using hh |
| rw [hpre, hmu _ (hD.image gi), freeCylinderWeight_image_relabel] |
|
|
| end |
| end Problem367 |
|
|
| end OAI |
|
|
