| import Mathlib |
| import OAI.Probability.LatticeSurface.Geometry.TriangularCover |
|
|
| namespace OAI |
|
|
| open MeasureTheory |
|
|
| open scoped ENNReal |
|
|
| noncomputable section |
|
|
| namespace TriangularLipschitz |
|
|
| def latticeDist (x y : Vertex) : ℝ := |
| max (max |(x.1 : ℝ) - y.1| |(x.2 : ℝ) - y.2|) |
| |((x.1 : ℝ) - y.1) + ((x.2 : ℝ) - y.2)| |
|
|
| def box (L : ℕ) : Finset Vertex := |
| (Finset.Icc 0 (L : ℤ)) ×ˢ (Finset.Icc 0 (L : ℤ)) |
|
|
| def interior (L : ℕ) : Finset Vertex := |
| (Finset.Icc 1 ((L : ℤ) - 1)) ×ˢ (Finset.Icc 1 ((L : ℤ) - 1)) |
|
|
| abbrev Filling (L : ℕ) := {x : Vertex // x ∈ interior L} → ℝ |
|
|
| noncomputable def filledHeight (L : ℕ) (s : Vertex → ℝ) (a : Filling L) |
| (x : Vertex) : ℝ := |
| if hx : x ∈ interior L then a ⟨x, hx⟩ else s x |
|
|
| def fillingPolytope (L : ℕ) (s : Vertex → ℝ) : Set (Filling L) := |
| {a | ∀ x ∈ box L, ∀ y ∈ box L, Adj x y → |
| |filledHeight L s a x - filledHeight L s a y| ≤ 1} |
|
|
| noncomputable def fillingVolume (L : ℕ) (s : Vertex → ℝ) : ℝ≥0∞ := |
| volume (fillingPolytope L s) |
|
|
| noncomputable def logFillingVolume (L : ℕ) (s : Vertex → ℝ) : WithBot ℝ := |
| if fillingVolume L s = 0 then ⊥ else |
| (Real.log (fillingVolume L s).toReal : ℝ) |
|
|
| noncomputable def positiveLogVolume (L : ℕ) (s : Vertex → ℝ) : ℝ := |
| Real.log (fillingVolume L s).toReal |
|
|
| def faceCenter (L : ℕ) (side : Fin 4) : Vertex := |
| match side.val with |
| | 0 => (0, (L / 2 : ℕ)) |
| | 1 => ((L : ℤ), (L / 2 : ℕ)) |
| | 2 => ((L / 2 : ℕ), 0) |
| | _ => ((L / 2 : ℕ), (L : ℤ)) |
|
|
| def compressedNeighbor (L : ℕ) (side : Fin 4) : Vertex := |
| match side.val with |
| | 0 => (0, (L / 2 : ℕ) + 1) |
| | 1 => ((L : ℤ), (L / 2 : ℕ) - 1) |
| | 2 => ((L / 2 : ℕ) + 1, 0) |
| | _ => ((L / 2 : ℕ) - 1, (L : ℤ)) |
|
|
| def ConvexGood (L k₀ : ℕ) (δ δ₀ s₀ : ℝ) (h : Vertex → ℝ) : Prop := |
| (∀ x ∈ box L, ∀ y ∈ box L, Adj x y → |h x - h y| ≤ 1 - δ) ∧ |
| (∀ x ∈ box L, ∀ y ∈ box L, (k₀ : ℝ) ≤ latticeDist x y → |
| |h x - h y| ≤ (1 - δ₀) * latticeDist x y) ∧ |
| (∀ side, s₀ ≤ |h (compressedNeighbor L side) - h (faceCenter L side)|) |
|
|
| lemma adj_symm {x y : Vertex} (h : Adj x y) : Adj y x := by |
| rcases x with ⟨a,b⟩; rcases y with ⟨c,d⟩ |
| simp only [Adj, Prod.mk.injEq] at h ⊢ |
| omega |
|
|
| lemma adj_ne {x y : Vertex} (h : Adj x y) : x ≠ y := by |
| intro hxy |
| subst y |
| rcases x with ⟨a,b⟩ |
| simp only [Adj, Prod.mk.injEq] at h |
| omega |
|
|
| def latticeGraph : SimpleGraph Vertex where |
| Adj := Adj |
| symm := ⟨fun _ _ => adj_symm⟩ |
| loopless := ⟨fun _ h => adj_ne h rfl⟩ |
|
|
| abbrev BoxVertex (L : ℕ) := {x : Vertex // x ∈ box L} |
|
|
| def boxGraph (L : ℕ) : SimpleGraph (BoxVertex L) := latticeGraph.induce (↑(box L)) |
|
|
| @[simp] lemma boxGraph_adj {L : ℕ} (x y : BoxVertex L) : |
| (boxGraph L).Adj x y ↔ Adj x.val y.val := Iff.rfl |
|
|
| @[simp] lemma mem_box {L : ℕ} {x : Vertex} : |
| x ∈ box L ↔ (0 ≤ x.1 ∧ x.1 ≤ (L : ℤ)) ∧ (0 ≤ x.2 ∧ x.2 ≤ (L : ℤ)) := by |
| simp [box] |
|
|
| instance box_nonempty (L : ℕ) : Nonempty (BoxVertex L) := |
| ⟨⟨(0,0), by simp⟩⟩ |
|
|
| def intDist (x y : Vertex) : ℤ := |
| max (max |x.1-y.1| |x.2-y.2|) |(x.1-y.1)+(x.2-y.2)| |
|
|
| lemma intDist_nonneg (x y : Vertex) : 0 ≤ intDist x y := |
| (abs_nonneg _).trans ((le_max_left _ _).trans (le_max_left _ _)) |
|
|
| lemma intDist_eq_zero_iff (x y : Vertex) : intDist x y = 0 ↔ x = y := by |
| rcases x with ⟨a,b⟩; rcases y with ⟨c,d⟩ |
| simp only [intDist, Prod.mk.injEq, abs_eq_max_neg] |
| omega |
|
|
| lemma intDist_cast (x y : Vertex) : (intDist x y : ℝ) = latticeDist x y := by |
| simp [intDist, latticeDist, max_assoc] |
|
|
| lemma geodesic_step {x y : Vertex} (hne : x ≠ y) : |
| ∃ z : Vertex, Adj x z ∧ |
| (min x.1 y.1 ≤ z.1 ∧ z.1 ≤ max x.1 y.1) ∧ |
| (min x.2 y.2 ≤ z.2 ∧ z.2 ≤ max x.2 y.2) ∧ |
| intDist z y + 1 = intDist x y := by |
| rcases x with ⟨a,b⟩; rcases y with ⟨c,d⟩ |
| change (a,b) ≠ (c,d) at hne |
| rcases lt_trichotomy a c with hac | hac | hac |
| · by_cases hdb : d < b |
| · refine ⟨(a+1,b-1), ?_, ?_, ?_, ?_⟩ |
| · simp [Adj] |
| · dsimp; omega |
| · dsimp; omega |
| · simp only [intDist, abs_eq_max_neg]; omega |
| · refine ⟨(a+1,b), ?_, ?_, ?_, ?_⟩ |
| · simp [Adj] |
| · dsimp; omega |
| · dsimp; omega |
| · simp only [intDist, abs_eq_max_neg]; omega |
| · subst c |
| rcases lt_trichotomy b d with hbd | hbd | hbd |
| · refine ⟨(a,b+1), ?_, ?_, ?_, ?_⟩ |
| · simp [Adj] |
| · dsimp; omega |
| · dsimp; omega |
| · simp only [intDist, abs_eq_max_neg]; omega |
| · exact False.elim (hne (by simp [hbd])) |
| · refine ⟨(a,b-1), ?_, ?_, ?_, ?_⟩ |
| · simp [Adj] |
| · dsimp; omega |
| · dsimp; omega |
| · simp only [intDist, abs_eq_max_neg]; omega |
| · by_cases hbd : b < d |
| · refine ⟨(a-1,b+1), ?_, ?_, ?_, ?_⟩ |
| · simp [Adj] |
| · dsimp; omega |
| · dsimp; omega |
| · simp only [intDist, abs_eq_max_neg]; omega |
| · refine ⟨(a-1,b), ?_, ?_, ?_, ?_⟩ |
| · simp [Adj] |
| · dsimp; omega |
| · dsimp; omega |
| · simp only [intDist, abs_eq_max_neg]; omega |
|
|
| lemma box_geodesic (L : ℕ) (x y : BoxVertex L) : |
| ∃ p : (boxGraph L).Walk x y, (p.length : ℤ) = intDist x.val y.val := by |
| suffices ∀ n (x y : BoxVertex L), (intDist x.val y.val).toNat = n → |
| ∃ p : (boxGraph L).Walk x y, (p.length : ℤ) = intDist x.val y.val from |
| this _ x y rfl |
| intro n |
| induction n using Nat.strong_induction_on with |
| | h n ih => |
| intro x y hn |
| by_cases hxy : x = y |
| · subst y |
| refine ⟨SimpleGraph.Walk.nil, ?_⟩ |
| simp [intDist] |
| · have hne : x.val ≠ y.val := fun h => hxy (Subtype.ext h) |
| obtain ⟨z,hxz,hz1,hz2,hd⟩ := geodesic_step hne |
| have hz : z ∈ box L := by |
| have hxb := mem_box.mp x.property |
| have hyb := mem_box.mp y.property |
| apply mem_box.mpr |
| constructor <;> constructor <;> omega |
| let z' : BoxVertex L := ⟨z,hz⟩ |
| have hlt : (intDist z y.val).toNat < n := by |
| have := intDist_nonneg z y.val |
| have := intDist_nonneg x.val y.val |
| omega |
| obtain ⟨p,hp⟩ := ih _ hlt z' y rfl |
| refine ⟨SimpleGraph.Walk.cons (show (boxGraph L).Adj x z' from hxz) p, ?_⟩ |
| simp only [SimpleGraph.Walk.length_cons, Nat.cast_add, Nat.cast_one] |
| change (p.length : ℤ) + 1 = _ |
| rw [hp] |
| exact hd |
|
|
| lemma box_connected (L : ℕ) : (boxGraph L).Connected := by |
| constructor |
| intro x y |
| obtain ⟨p,_⟩ := box_geodesic L x y |
| exact ⟨p⟩ |
|
|
| lemma latticeDist_triangle (x y z : Vertex) : |
| latticeDist x z ≤ latticeDist x y + latticeDist y z := by |
| apply max_le |
| · apply max_le |
| · exact (abs_sub_le (x.1 : ℝ) y.1 z.1).trans |
| (add_le_add ((le_max_left _ _).trans (le_max_left _ _)) |
| ((le_max_left _ _).trans (le_max_left _ _))) |
| · exact (abs_sub_le (x.2 : ℝ) y.2 z.2).trans |
| (add_le_add ((le_max_right _ _).trans (le_max_left _ _)) |
| ((le_max_right _ _).trans (le_max_left _ _))) |
| · calc |
| |((x.1 : ℝ) - z.1) + ((x.2 : ℝ) - z.2)| = |
| |(((x.1 : ℝ)-y.1)+((x.2 : ℝ)-y.2)) + |
| (((y.1 : ℝ)-z.1)+((y.2 : ℝ)-z.2))| := by congr 1; ring |
| _ ≤ |((x.1 : ℝ)-y.1)+((x.2 : ℝ)-y.2)| + |
| |((y.1 : ℝ)-z.1)+((y.2 : ℝ)-z.2)| := abs_add_le _ _ |
| _ ≤ _ := add_le_add (le_max_right _ _) (le_max_right _ _) |
|
|
| lemma intDist_adj {x y : Vertex} (hxy : Adj x y) : intDist x y = 1 := by |
| rcases x with ⟨a,b⟩; rcases y with ⟨c,d⟩ |
| simp only [Adj, Prod.mk.injEq] at hxy |
| simp only [intDist, abs_eq_max_neg] |
| omega |
|
|
| lemma latticeDist_adj {x y : Vertex} (hxy : Adj x y) : latticeDist x y = 1 := by |
| rw [←intDist_cast, intDist_adj hxy] |
| norm_num |
|
|
| lemma latticeDist_walk_le {L : ℕ} {x y : BoxVertex L} (p : (boxGraph L).Walk x y) : |
| latticeDist x.val y.val ≤ (p.length : ℝ) := by |
| induction p with |
| | nil => simp [latticeDist] |
| | @cons x y z hxy p ih => |
| calc |
| latticeDist x.val z.val ≤ latticeDist x.val y.val + latticeDist y.val z.val := |
| latticeDist_triangle _ _ _ |
| _ ≤ 1 + (p.length : ℝ) := add_le_add (le_of_eq (latticeDist_adj hxy)) ih |
| _ = ((SimpleGraph.Walk.cons hxy p).length : ℝ) := by simp; ring |
|
|
| lemma box_dist (L : ℕ) (x y : BoxVertex L) : |
| ((boxGraph L).dist x y : ℝ) = latticeDist x.val y.val := by |
| apply le_antisymm |
| · obtain ⟨p,hp⟩ := box_geodesic L x y |
| have hpr : (p.length : ℝ) = latticeDist x.val y.val := by |
| rw [←intDist_cast] |
| exact_mod_cast hp |
| rw [←hpr] |
| exact_mod_cast (boxGraph L).dist_le p |
| · obtain ⟨p,hp⟩ := (box_connected L).exists_walk_length_eq_dist x y |
| simpa only [hp] using latticeDist_walk_le p |
|
|
| lemma scaled_edge_bound_walk {L : ℕ} {h : Vertex → ℝ} {c : ℝ} |
| (hh : ∀ x ∈ box L, ∀ y ∈ box L, Adj x y → |h x-h y| ≤ c) |
| {x y : BoxVertex L} (p : (boxGraph L).Walk x y) : |
| |h x.val-h y.val| ≤ c * (p.length : ℝ) := by |
| induction p with |
| | nil => simp |
| | @cons x y z hxy p ih => |
| calc |
| |h x.val-h z.val| ≤ |h x.val-h y.val|+|h y.val-h z.val| := abs_sub_le _ _ _ |
| _ ≤ c + c * (p.length : ℝ) := |
| add_le_add (hh _ x.property _ y.property hxy) ih |
| _ = c*((SimpleGraph.Walk.cons hxy p).length : ℝ) := by simp; ring |
|
|
| lemma near_global_bound {L : ℕ} {h : Vertex → ℝ} {c : ℝ} |
| (hh : ∀ x ∈ box L, ∀ y ∈ box L, Adj x y → |h x-h y| ≤ c) |
| {x y : Vertex} (hx : x ∈ box L) (hy : y ∈ box L) : |
| |h x-h y| ≤ c*latticeDist x y := by |
| obtain ⟨p,hp⟩ := box_geodesic L ⟨x,hx⟩ ⟨y,hy⟩ |
| have hpr : (p.length : ℝ) = latticeDist x y := by |
| rw [←intDist_cast] |
| exact_mod_cast hp |
| simpa only [hpr] using scaled_edge_bound_walk hh p |
|
|
| end TriangularLipschitz |
|
|
| end |
|
|
| end OAI |
|
|
