| import OAI.Combinatorics.PlanarL1.Columns |
|
|
| namespace OAI |
|
|
| section |
|
|
| namespace PlanarL1 |
| namespace Columns |
| namespace Model |
|
|
| variable {n : ℕ} (M : Model n) |
| namespace Point |
|
|
| variable {M} {J : Set ℝ} {root : Fin n} |
|
|
| lemma paths_nonempty (x y : M.Point J root) : Nonempty (M.Path J x.column y.column) := by |
| obtain ⟨p⟩ := x.reachable.symm.trans y.reachable |
| obtain ⟨q, _⟩ := Path.exists_word p |
| exact ⟨q⟩ |
|
|
| noncomputable def distance (x y : M.Point J root) : ℝ := |
| ⨅ p : M.Path J x.column y.column, p.length x.height y.height |
|
|
| lemma lengths_bddBelow (x y : M.Point J root) : |
| BddBelow (Set.range fun p : M.Path J x.column y.column => p.length x.height y.height) := |
| ⟨0, by rintro _ ⟨p, rfl⟩; exact p.length_nonneg _ _⟩ |
| |
| lemma distance_le (x y : M.Point J root) (p : M.Path J x.column y.column) : |
| x.distance y ≤ p.length x.height y.height := |
| ciInf_le (x.lengths_bddBelow y) p |
|
|
| lemma distance_nonneg (x y : M.Point J root) : 0 ≤ x.distance y := by |
| have := x.paths_nonempty y |
| exact le_ciInf (fun p => p.length_nonneg _ _) |
|
|
| lemma height_change_le (x y : M.Point J root) : |x.height - y.height| ≤ x.distance y := by |
| have := x.paths_nonempty y |
| exact le_ciInf (fun p => p.height_change_le _ _) |
|
|
| lemma distance_self (x : M.Point J root) : x.distance x = 0 := by |
| apply le_antisymm _ (x.distance_nonneg x) |
| simpa only [Path.length, sub_self, abs_zero] using x.distance_le x (.nil _) |
|
|
| lemma distance_triangle (x y z : M.Point J root) : |
| x.distance z ≤ x.distance y + y.distance z := by |
| have := x.paths_nonempty y |
| have := y.paths_nonempty z |
| apply le_ciInf_add |
| intro p |
| apply le_add_ciInf |
| intro q |
| exact (x.distance_le z (p.append q)).trans (p.length_append_le q _ _ _) |
|
|
| lemma distance_comm (x y : M.Point J root) : x.distance y = y.distance x := by |
| have := x.paths_nonempty y |
| have := y.paths_nonempty x |
| suffices ∀ x y : M.Point J root, x.distance y ≤ y.distance x by |
| exact le_antisymm (this x y) (this y x) |
| intro x y |
| have := y.paths_nonempty x |
| apply le_ciInf |
| intro p |
| simpa only [Path.length_reverse] using x.distance_le y p.reverse |
|
|
| noncomputable instance : PseudoMetricSpace (M.Point J root) where |
| dist := distance |
| dist_self := distance_self |
| dist_comm := distance_comm |
| dist_triangle := distance_triangle |
|
|
| /-- The full vertical interval is isometric, before or after the quotient. |
| No path's vertical variation can improve upon direct travel. -/ |
| lemma dist_same_column (x y : M.Point J root) (h : x.column = y.column) : |
| dist x y = |x.height - y.height| := by |
| rcases x with ⟨i, a, ha, hx⟩ |
| rcases y with ⟨j, b, hb, hy⟩ |
| change i = j at h |
| subst j |
| let x : M.Point J root := ⟨i, a, ha, hx⟩ |
| let y : M.Point J root := ⟨i, b, hb, hy⟩ |
| exact le_antisymm (x.distance_le y (.nil i)) (x.height_change_le y) |
|
|
| /-- Vertical motion on a chosen column representative. -/ |
| def withHeight (x : M.Point J root) (H : ℝ) (hH : H ∈ J) : M.Point J root := |
| ⟨x.column, H, hH, x.reachable⟩ |
|
|
| @[simp] lemma withHeight_self (x : M.Point J root) : |
| x.withHeight x.height x.inBand = x := rfl |
|
|
| lemma dist_withHeight (x : M.Point J root) (H : ℝ) (hH : H ∈ J) : |
| dist x (x.withHeight H hH) = |x.height - H| := x.dist_same_column _ rfl |
|
|
| lemma dist_le_switch (x y : M.Point J root) {H : ℝ} (hH : H ∈ J) |
| (hs : H ∈ M.heights x.column y.column) : |
| dist x y ≤ |x.height - H| + |H - y.height| := |
| x.distance_le y (.cons H hH hs (.nil _)) |
|
|
| /-- The source's adjacent-midpoint estimate: one available switch costs at |
| most the width of the band. -/ |
| lemma dist_midpoints_le (x y : M.Point J root) {H a : ℝ} |
| (hx : x.height = H) (hy : y.height = H) |
| (hhalf : ∀ T ∈ J, |H - T| ≤ a / 2) |
| (h : (M.activeGraph J).Adj x.column y.column) : dist x y ≤ a := by |
| obtain ⟨T, hT, hs⟩ := h |
| have hd := x.dist_le_switch y hT hs |
| rw [hx, hy, abs_sub_comm T H] at hd |
| linarith [hhalf T hT] |
|
|
| /-- Lengths realized by words with no repeated column. -/ |
| def simpleLengths (x y : M.Point J root) : Set ℝ := |
| ⋃ w : (M.activeGraph J).Path x.column y.column, |
| Set.range (fun s : M.Schedule J w.val => s.toPath.length x.height y.height) |
|
|
| lemma mem_simpleLengths (x y : M.Point J root) (p : M.Path J x.column y.column) |
| (hp : p.word.IsPath) : p.length x.height y.height ∈ x.simpleLengths y := by |
| apply Set.mem_iUnion.mpr |
| refine ⟨⟨p.word, hp⟩, ?_⟩ |
| exact ⟨Schedule.ofPath p, by simp only [Schedule.toPath_ofPath]⟩ |
|
|
| lemma simpleLengths_nonempty (x y : M.Point J root) : (x.simpleLengths y).Nonempty := by |
| obtain ⟨p⟩ := x.paths_nonempty y |
| obtain ⟨q, hq, _⟩ := p.simple_replacement x.height y.height |
| exact ⟨q.length x.height y.height, x.mem_simpleLengths y q hq⟩ |
|
|
| lemma isCompact_simpleLengths (hJ : IsClosed J) (x y : M.Point J root) : |
| IsCompact (x.simpleLengths y) := by |
| classical |
| apply isCompact_iUnion |
| intro w |
| let := Schedule.compactSpace hJ w.val |
| exact isCompact_range (Schedule.continuous_length w.val _ _ id |
| continuous_const continuous_const continuous_id) |
|
|
| /-- Geometry, `geo:geodesics`: finite intrinsic distances are attained by a |
| switching path with no repeated column. Compactness is required of the actual |
| switch-height sets, rather than of an artificial discretization. -/ |
| lemma exists_shortest (hJ : IsClosed J) (x y : M.Point J root) : |
| ∃ p : M.Path J x.column y.column, |
| p.word.IsPath ∧ p.length x.height y.height = dist x y := by |
| have hc := x.isCompact_simpleLengths hJ y |
| have hm := hc.isLeast_sInf (x.simpleLengths_nonempty y) |
| obtain ⟨w, s, hs⟩ := Set.mem_iUnion.mp hm.1 |
| change s.toPath.length x.height y.height = sInf (x.simpleLengths y) at hs |
| refine ⟨s.toPath, ?_, ?_⟩ |
| · rw [Schedule.word_toPath] |
| exact w.property |
| · apply le_antisymm _ (x.distance_le y s.toPath) |
| have := x.paths_nonempty y |
| apply le_ciInf |
| intro p |
| obtain ⟨q, hq, hlen⟩ := p.simple_replacement x.height y.height |
| rw [hs] |
| exact (hm.2 (x.mem_simpleLengths y q hq)).trans hlen |
|
|
| /-- Two short paths whose projected words meet on a column give a short |
| connection, with only one band-width paid for the vertical transfer. -/ |
| lemma dist_le_of_shared_column (x y : M.Point J root) {i j v : Fin n} |
| (p : M.Path J x.column i) (q : M.Path J y.column j) |
| {H T a : ℝ} (hH : H ∈ J) (hT : T ∈ J) |
| (hwidth : ∀ r ∈ J, ∀ s ∈ J, |r - s| ≤ a) |
| (hpv : v ∈ p.word.support) (hqv : v ∈ q.word.support) : |
| dist x y ≤ p.length x.height H + q.length y.height T + a := by |
| obtain ⟨A, hA, p₁, p₂, hp⟩ := p.split_at_column x.inBand hH hpv |
| obtain ⟨B, hB, q₁, q₂, hq⟩ := q.split_at_column y.inBand hT hqv |
| have hd := x.distance_le y (p₁.append q₁.reverse) |
| have ha := p₁.length_append_le q₁.reverse x.height B y.height |
| have he := p₁.length_end_le x.height A B |
| rw [q₁.length_reverse] at ha |
| have hw := hwidth A hA B hB |
| have hn₁ := p₂.length_nonneg A H |
| have hn₂ := q₂.length_nonneg B T |
| change x.distance y ≤ _ |
| linarith |
|
|
| /-- The source's quotient identifies precisely finite chains of switches at a |
| single height. This verifies that metric separation has not introduced any |
| extra quotient relations. -/ |
| lemma zero_distance_iff (hJ : IsClosed J) (x y : M.Point J root) : |
| dist x y = 0 ↔ x.height = y.height ∧ |
| (M.activeGraph {x.height}).Reachable x.column y.column := by |
| constructor |
| · intro h |
| obtain ⟨p, _, hp⟩ := x.exists_shortest hJ y |
| exact p.zero_length_identifies _ _ (hp.trans h) |
| · rintro ⟨hxy, ⟨w⟩⟩ |
| obtain ⟨p, hp⟩ := Path.exists_zero_path x.height x.inBand w |
| apply le_antisymm _ dist_nonneg |
| have h := x.distance_le y p |
| rwa [← hxy, hp] at h |
|
|
| /-- Exact shortest paths to a fixed-height column stay in its distance |
| sublevel after projection to column indices. This is the metric assertion |
| underlying `geo:sublevel`, not merely a graph-connectivity assumption. -/ |
| lemma shortest_sublevel (hJ : IsClosed J) (o y : M.Point J root) : |
| ∃ p : M.Path J o.column y.column, |
| p.length o.height y.height = dist o y ∧ |
| ∀ v ∈ p.word.support, ∃ hv : (M.activeGraph J).Reachable root v, |
| dist o (⟨v, y.height, y.inBand, hv⟩ : M.Point J root) ≤ dist o y := by |
| obtain ⟨p, _, hp⟩ := o.exists_shortest hJ y |
| refine ⟨p, hp, ?_⟩ |
| intro v hv |
| obtain ⟨H, _, q, r, hqr⟩ := p.split_at_column o.inBand y.inBand hv |
| refine ⟨o.reachable.trans q.word.reachable, ?_⟩ |
| let z : M.Point J root := ⟨v, y.height, y.inBand, o.reachable.trans q.word.reachable⟩ |
| have h1 := o.distance_le z q |
| have h2 := q.length_end_le o.height H y.height |
| have h3 := r.height_change_le H y.height |
| change o.distance z ≤ dist o y |
| linarith |
|
|
| /-- The fixed-height radial sublevel in the active column graph. Columns |
| outside the chosen component are absent, as for the source's value `+∞`. -/ |
| def sublevel (o : M.Point J root) (H : ℝ) (hH : H ∈ J) (t : ℝ) : Set (Fin n) := |
| {i | ∃ hi : (M.activeGraph J).Reachable root i, |
| dist o (⟨i, H, hH, hi⟩ : M.Point J root) ≤ t} |
|
|
| lemma mem_sublevel_iff (o x : M.Point J root) (H : ℝ) (hH : H ∈ J) (t : ℝ) : |
| x.column ∈ o.sublevel H hH t ↔ dist o (x.withHeight H hH) ≤ t := by |
| constructor |
| · rintro ⟨_, hd⟩ |
| exact hd |
| · intro hd |
| exact ⟨x.reachable, hd⟩ |
|
|
| lemma sublevel_preconnected (hJ : IsClosed J) (o : M.Point J root) |
| (H : ℝ) (hH : H ∈ J) (t : ℝ) : |
| ((M.activeGraph J).induce (o.sublevel H hH t)).Preconnected := by |
| intro x y |
| obtain ⟨hx, hdx⟩ := x.property |
| obtain ⟨hy, hdy⟩ := y.property |
| obtain ⟨p, _, hp⟩ := o.shortest_sublevel hJ ⟨x.val, H, hH, hx⟩ |
| obtain ⟨q, _, hq⟩ := o.shortest_sublevel hJ ⟨y.val, H, hH, hy⟩ |
| have hmem : ∀ v ∈ (p.word.reverse.append q.word).support, |
| v ∈ o.sublevel H hH t := by |
| intro v hv |
| rcases (p.word.reverse.mem_support_append_iff q.word).mp hv with hv | hv |
| · have hv' : v ∈ p.word.support := by simpa using hv |
| obtain ⟨hvr, hdv⟩ := hp v hv' |
| exact ⟨hvr, hdv.trans hdx⟩ |
| · obtain ⟨hvr, hdv⟩ := hq v hv |
| exact ⟨hvr, hdv.trans hdy⟩ |
| exact ⟨(p.word.reverse.append q.word).induce _ hmem⟩ |
|
|
| /-- Geometry, Lemma `geo:sublevel`, including the actual nonemptiness |
| hypothesis and connectivity in the induced graph, not merely in the ambient |
| component. -/ |
| lemma sublevel_connected (hJ : IsClosed J) (o : M.Point J root) |
| (H : ℝ) (hH : H ∈ J) (t : ℝ) (hne : (o.sublevel H hH t).Nonempty) : |
| ((M.activeGraph J).induce (o.sublevel H hH t)).Connected := by |
| have : Nonempty (o.sublevel H hH t) := hne.to_subtype |
| exact ⟨o.sublevel_preconnected hJ H hH t⟩ |
|
|
| /-- The short connector in the portal argument. We use the connected |
| fixed-height sublevel at `t - 12a`; this changes the source's intermediate |
| 13a estimate to 14a, still strictly below the required 100a separation. -/ |
| lemma short_connector (hJ : IsClosed J) (o x : M.Point J root) |
| {H a t : ℝ} (hH : H ∈ J) (ha : 0 < a) (ht : 30 * a ≤ t) |
| (hhalf : ∀ T ∈ J, |H - T| ≤ a / 2) |
| (hx : t ≤ dist o (x.withHeight H hH)) (hnear : dist o x < t + a) : |
| ∃ v ∈ o.sublevel H hH (t - 12 * a), ∃ T ∈ J, |
| ∃ p : M.Path J x.column v, p.length x.height T ≤ 14 * a := by |
| let S := o.sublevel H hH (t - 12 * a) |
| have hxo : x.column ∉ S := by |
| intro h |
| have hd := (o.mem_sublevel_iff x H hH (t - 12 * a)).mp h |
| linarith |
| have hoo : o.column ∈ S := by |
| apply (o.mem_sublevel_iff o H hH (t - 12 * a)).mpr |
| rw [o.dist_withHeight, abs_sub_comm] |
| linarith [hhalf o.height o.inBand] |
| obtain ⟨p, _, hp⟩ := x.exists_shortest hJ o |
| obtain ⟨u, v, T, hT, hs, hu, hv, q, r, hqr⟩ := |
| p.crosses_set S hxo hoo x.height o.height |
| let z : M.Point J root := ⟨u, T, hT, x.reachable.trans q.word.reachable⟩ |
| have hout : t - 12 * a < dist o (z.withHeight H hH) := by |
| apply lt_of_not_ge |
| intro h |
| exact hu ((o.mem_sublevel_iff z H hH _).mpr h) |
| have hz : dist o z ≤ r.length T o.height := by |
| have hh := z.distance_le o (.cons T hT hs r) |
| rw [dist_comm o z] |
| change z.distance o ≤ r.length T o.height |
| simpa only [Path.length, z, sub_self, abs_zero, zero_add] using hh |
| have hvshift : dist z (z.withHeight H hH) ≤ a / 2 := by |
| rw [z.dist_withHeight] |
| change |T - H| ≤ a / 2 |
| rw [abs_sub_comm] |
| exact hhalf T hT |
| have htri := dist_triangle o z (z.withHeight H hH) |
| have hlen : q.length x.height T ≤ 14 * a := by |
| rw [hp, dist_comm x o] at hqr |
| linarith |
| refine ⟨v, hv, T, hT, q.snoc T hT hs, ?_⟩ |
| simpa only [Path.length_snoc, sub_self, abs_zero, add_zero] using hlen |
|
|
| /-- Quantitative exclusion behind the two-portals lemma: three entrance-range |
| midpoints in a connected high set cannot be mutually more than 100 widths |
| apart. No minor-exclusion or short-connector hypothesis is assumed. -/ |
| lemma no_three_far_entrances (hJ : IsClosed J) (o : M.Point J root) |
| {H a t : ℝ} (hH : H ∈ J) (ha : 0 < a) |
| (hhalf : ∀ T ∈ J, |H - T| ≤ a / 2) |
| {C : Set (Fin n)} (hC : ((M.activeGraph J).induce C).Preconnected) |
| (hhigh : ∀ z : M.Point J root, z.column ∈ C → t ≤ dist o (z.withHeight H hH)) |
| (x : Fin 3 → M.Point J root) (hxc : ∀ i, (x i).column ∈ C) |
| (hnear : ∀ i, dist o (x i) < t + a) |
| (hfar : Pairwise (fun i j => 100 * a < dist (x i) (x j))) : False := by |
| by_cases ht : 30 * a ≤ t |
| · let L := o.sublevel H hH (t - 12 * a) |
| have hCL : Disjoint C L := by |
| apply Set.disjoint_left.mpr |
| rintro v hv ⟨hr, hd⟩ |
| let z : M.Point J root := ⟨v, H, hH, hr⟩ |
| have hz := hhigh z hv |
| change t ≤ dist o z at hz |
| linarith |
| have hno : ∀ u ∈ C, ∀ v ∈ L, ¬ (M.activeGraph J).Adj u v := by |
| rintro u hu v ⟨hr, hd⟩ huv |
| let y : M.Point J root := ⟨v, H, hH, hr⟩ |
| let z : M.Point J root := ⟨u, H, hH, |
| hr.trans (SimpleGraph.Adj.reachable huv.symm)⟩ |
| have hz := hhigh z hu |
| change t ≤ dist o z at hz |
| have hzy := z.dist_midpoints_le y rfl rfl hhalf huv |
| have hh := dist_triangle o y z |
| rw [dist_comm y z] at hh |
| change dist o y ≤ t - 12 * a at hd |
| linarith |
| have hcon := fun i => o.short_connector hJ (x i) hH ha ht hhalf |
| (hhigh (x i) (hxc i)) (hnear i) |
| choose v hv T hT p hp using hcon |
| have hwidth : ∀ r ∈ J, ∀ s ∈ J, |r - s| ≤ a := by |
| intro r hr s hs |
| have hb := abs_sub_le r H s |
| rw [abs_sub_comm r H] at hb |
| linarith [hhalf r hr, hhalf s hs] |
| have hdis : Pairwise (fun i j => Disjoint |
| {w | w ∈ (p i).word.support} {w | w ∈ (p j).word.support}) := by |
| intro i j hij |
| apply Set.disjoint_left.mpr |
| intro w hwi hwj |
| have hd := (x i).dist_le_of_shared_column (x j) (p i) (p j) |
| (hT i) (hT j) hwidth hwi hwj |
| have hf := hfar hij |
| linarith [hp i, hp j] |
| exact ColumnOrder.no_three_connectors (M.active_noncrossing J) hC |
| (o.sublevel_preconnected hJ H hH (t - 12 * a)) hCL hno |
| (fun i => (x i).column) v hxc hv (fun i => (p i).word) hdis |
| · have hf := hfar (show (0 : Fin 3) ≠ 1 by decide) |
| have hd := dist_triangle (x 0) o (x 1) |
| rw [dist_comm (x 0) o] at hd |
| linarith [hnear 0, hnear 1] |
|
|
| /-- Two entrances cover all entrance midpoints. The two chosen values may |
| coincide, representing the one-portal case; both are actual entrances. -/ |
| lemma two_portal_midpoints (hJ : IsClosed J) (o : M.Point J root) |
| {H a t : ℝ} (hH : H ∈ J) (ha : 0 < a) |
| (hhalf : ∀ T ∈ J, |H - T| ≤ a / 2) |
| {C : Set (Fin n)} (hC : ((M.activeGraph J).induce C).Preconnected) |
| (hhigh : ∀ z : M.Point J root, z.column ∈ C → t ≤ dist o (z.withHeight H hH)) |
| {E : Set (M.Point J root)} (hne : E.Nonempty) |
| (heC : ∀ x ∈ E, x.column ∈ C) (hnear : ∀ x ∈ E, dist o x < t + a) : |
| ∃ p ∈ E, ∃ q ∈ E, ∀ x ∈ E, dist x p ≤ 100 * a ∨ dist x q ≤ 100 * a := by |
| classical |
| obtain ⟨p, hp⟩ := hne |
| by_cases hex : ∃ q ∈ E, 100 * a < dist p q |
| · obtain ⟨q, hq, hpq⟩ := hex |
| refine ⟨p, hp, q, hq, ?_⟩ |
| intro z hz |
| by_contra h |
| push Not at h |
| apply o.no_three_far_entrances hJ hH ha hhalf hC hhigh ![p, q, z] |
| · intro i |
| fin_cases i |
| · exact heC p hp |
| · exact heC q hq |
| · exact heC z hz |
| · intro i |
| fin_cases i |
| · exact hnear p hp |
| · exact hnear q hq |
| · exact hnear z hz |
| · intro i j hij |
| fin_cases i <;> fin_cases j <;> simp_all [dist_comm] |
| · refine ⟨p, hp, p, hp, ?_⟩ |
| intro x hx |
| left |
| rw [dist_comm] |
| exact le_of_not_gt (fun h => hex ⟨x, hx, h⟩) |
| |
| /-- Geometry `geo:portals`, the full-column covering conclusion with the |
| stated 200a constant. The entrance-range hypothesis is derived from adjacency |
| by `dist_midpoints_le`; the two portal centers are selected from `E` itself. -/ |
| lemma two_portals (hJ : IsClosed J) (o : M.Point J root) |
| {H a t : ℝ} (hH : H ∈ J) (ha : 0 < a) |
| (hhalf : ∀ T ∈ J, |H - T| ≤ a / 2) |
| {C : Set (Fin n)} (hC : ((M.activeGraph J).induce C).Preconnected) |
| (hhigh : ∀ z : M.Point J root, z.column ∈ C → t ≤ dist o (z.withHeight H hH)) |
| {E : Set (M.Point J root)} (hne : E.Nonempty) |
| (heC : ∀ x ∈ E, x.column ∈ C) (hnear : ∀ x ∈ E, dist o x < t + a) : |
| ∃ p ∈ E, ∃ q ∈ E, ∀ x : M.Point J root, x.withHeight H hH ∈ E → |
| dist x p ≤ 200 * a ∨ dist x q ≤ 200 * a := by |
| obtain ⟨p, hp, q, hq, hcover⟩ := o.two_portal_midpoints hJ hH ha hhalf hC hhigh |
| hne heC hnear |
| refine ⟨p, hp, q, hq, ?_⟩ |
| intro x hx |
| have hv : dist x (x.withHeight H hH) ≤ a / 2 := by |
| rw [x.dist_withHeight, abs_sub_comm] |
| exact hhalf x.height x.inBand |
| rcases hcover _ hx with h | h |
| · left |
| linarith [dist_triangle x (x.withHeight H hH) p] |
| · right |
| linarith [dist_triangle x (x.withHeight H hH) q] |
|
|
| /-- Radial superlevels contain exactly the reachable columns whose midpoints |
| have radial value at least the threshold. -/ |
| def superlevel (o : M.Point J root) (H : ℝ) (hH : H ∈ J) (t : ℝ) : Set (Fin n) := |
| {i | ∃ hi : (M.activeGraph J).Reachable root i, |
| t ≤ dist o (⟨i, H, hH, hi⟩ : M.Point J root)} |
|
|
| lemma mem_superlevel_iff (o x : M.Point J root) (H : ℝ) (hH : H ∈ J) (t : ℝ) : |
| x.column ∈ o.superlevel H hH t ↔ t ≤ dist o (x.withHeight H hH) := by |
| constructor |
| · rintro ⟨_, hd⟩ |
| exact hd |
| · intro hd |
| exact ⟨x.reachable, hd⟩ |
|
|
| /-- The actual entrance midpoints of a radial high component. The adjacent |
| low column, rather than a separate entrance-range hypothesis, is part of the |
| definition. -/ |
| def entrances (o : M.Point J root) (H : ℝ) (hH : H ∈ J) (t : ℝ) |
| (C : ((M.activeGraph J).induce (o.superlevel H hH t)).ConnectedComponent) : |
| Set (M.Point J root) := |
| {x | x.height = H ∧ x.column ∈ ColumnOrder.componentColumns C ∧ |
| ∃ y : M.Point J root, y.height = H ∧ |
| (M.activeGraph J).Adj x.column y.column ∧ dist o y < t} |
|
|
| lemma entrance_radial (o : M.Point J root) {H a t : ℝ} (hH : H ∈ J) |
| (hhalf : ∀ T ∈ J, |H - T| ≤ a / 2) |
| (C : ((M.activeGraph J).induce (o.superlevel H hH t)).ConnectedComponent) |
| {x : M.Point J root} (hx : x ∈ o.entrances H hH t C) : |
| t ≤ dist o x ∧ dist o x < t + a := by |
| obtain ⟨hxH, hxC, y, hyH, hxy, hy⟩ := hx |
| have hhigh := (o.mem_superlevel_iff x H hH t).mp |
| (ColumnOrder.componentColumns_subset C hxC) |
| have heq : x.withHeight H hH = x := by |
| simpa only [← hxH] using x.withHeight_self |
| rw [heq] at hhigh |
| have hd := x.dist_midpoints_le y hxH hyH hhalf hxy |
| have htri := dist_triangle o y x |
| rw [dist_comm y x] at htri |
| exact ⟨hhigh, by linarith⟩ |
|
|
| /-- Exit a high component along an attained shortest path. The final high |
| column is an actual entrance. The estimate retains the distance to the radial |
| threshold, and is the geometric input for both cell diameters and portal levels. -/ |
| lemma exit_superlevel (hJ : IsClosed J) (o x : M.Point J root) |
| {H a t : ℝ} (hH : H ∈ J) (ht : a / 2 < t) |
| (hhalf : ∀ T ∈ J, |H - T| ≤ a / 2) |
| (C : ((M.activeGraph J).induce (o.superlevel H hH t)).ConnectedComponent) |
| (hx : x.column ∈ ColumnOrder.componentColumns C) : |
| ∃ z : M.Point J root, z.withHeight H hH ∈ o.entrances H hH t C ∧ |
| dist x z ≤ dist o x - t + a / 2 := by |
| let S := ColumnOrder.componentColumns C |
| have hoo : o.column ∉ S := by |
| intro ho |
| have hh := (o.mem_superlevel_iff o H hH t).mp |
| (ColumnOrder.componentColumns_subset C ho) |
| rw [o.dist_withHeight, abs_sub_comm] at hh |
| linarith [hhalf o.height o.inBand] |
| obtain ⟨p, _, hp⟩ := x.exists_shortest hJ o |
| obtain ⟨u, v, T, hT, hs, hu, hv, q, r, hqr⟩ := |
| p.crosses_set Sᶜ (by simpa only [Set.mem_compl_iff, not_not] using hx) |
| hoo x.height o.height |
| have huC : u ∈ S := by simpa only [Set.mem_compl_iff, not_not] using hu |
| have huv : (M.activeGraph J).Adj u v := ⟨T, hT, hs⟩ |
| let z : M.Point J root := ⟨u, T, hT, x.reachable.trans q.word.reachable⟩ |
| let y : M.Point J root := ⟨v, H, hH, z.reachable.trans huv.reachable⟩ |
| have hy : dist o y < t := by |
| apply lt_of_not_ge |
| intro h |
| exact hv (ColumnOrder.componentColumns_adj C huC huv ⟨y.reachable, h⟩) |
| have hentrance : z.withHeight H hH ∈ o.entrances H hH t C := |
| ⟨rfl, huC, y, rfl, huv, hy⟩ |
| refine ⟨z, hentrance, ?_⟩ |
| have hhigh := (o.mem_superlevel_iff z H hH t).mp |
| (ColumnOrder.componentColumns_subset C huC) |
| have hvshift : dist z (z.withHeight H hH) ≤ a / 2 := by |
| rw [z.dist_withHeight, abs_sub_comm] |
| exact hhalf T hT |
| have hz : dist o z ≤ r.length T o.height := by |
| have hh := z.distance_le o (.cons T hT hs r) |
| rw [dist_comm o z] |
| change z.distance o ≤ r.length T o.height |
| simpa only [Path.length, z, sub_self, abs_zero, zero_add] using hh |
| have htri := dist_triangle o z (z.withHeight H hH) |
| have hdx := x.distance_le z q |
| change dist x z ≤ q.length x.height T at hdx |
| rw [hp, dist_comm x o] at hqr |
| linarith |
|
|
| /-- Nonempty radial high components have entrances above the initial |
| half-width. This discharges the existence clause of `geo:portals`. -/ |
| lemma entrances_nonempty (hJ : IsClosed J) (o : M.Point J root) |
| {H a t : ℝ} (hH : H ∈ J) (ht : a / 2 < t) |
| (hhalf : ∀ T ∈ J, |H - T| ≤ a / 2) |
| (C : ((M.activeGraph J).induce (o.superlevel H hH t)).ConnectedComponent) : |
| (o.entrances H hH t C).Nonempty := by |
| obtain ⟨i, hi⟩ := C.nonempty_supp |
| obtain ⟨hr, _⟩ := i.property |
| let x : M.Point J root := ⟨i.val, H, hH, hr⟩ |
| obtain ⟨z, hz, _⟩ := o.exit_superlevel hJ x hH ht hhalf C ⟨i, hi, rfl⟩ |
| exact ⟨z.withHeight H hH, hz⟩ |
|
|
| /-- Geometry `geo:portals` with the actual radial component and actual |
| entrances. In particular no covering or radial-range conclusion is assumed. -/ |
| lemma component_two_portals (hJ : IsClosed J) (o : M.Point J root) |
| {H a t : ℝ} (hH : H ∈ J) (ha : 0 < a) |
| (hhalf : ∀ T ∈ J, |H - T| ≤ a / 2) |
| (C : ((M.activeGraph J).induce (o.superlevel H hH t)).ConnectedComponent) |
| (hne : (o.entrances H hH t C).Nonempty) : |
| ∃ p ∈ o.entrances H hH t C, ∃ q ∈ o.entrances H hH t C, |
| (t ≤ dist o p ∧ dist o p < t + a) ∧ |
| (t ≤ dist o q ∧ dist o q < t + a) ∧ |
| ∀ x : M.Point J root, x.withHeight H hH ∈ o.entrances H hH t C → |
| dist x p ≤ 200 * a ∨ dist x q ≤ 200 * a := by |
| obtain ⟨p, hp, q, hq, hcover⟩ := o.two_portals hJ hH ha hhalf |
| (ColumnOrder.componentColumns_connected C).preconnected |
| (fun z hz => (o.mem_superlevel_iff z H hH t).mp |
| (ColumnOrder.componentColumns_subset C hz)) hne |
| (fun _ hx => hx.2.1) (fun _ hx => (o.entrance_radial hH hhalf C hx).2) |
| exact ⟨p, hp, q, hq, o.entrance_radial hH hhalf C hp, |
| o.entrance_radial hH hhalf C hq, hcover⟩ |
|
|
| /-- The geodesic-to-root estimate behind radial cells: every point of a |
| high component whose radial distance is bounded is close to a chosen portal. -/ |
| lemma component_portal_cover (hJ : IsClosed J) (o : M.Point J root) |
| {H a t : ℝ} (hH : H ∈ J) (ha : 0 < a) (ht : a / 2 < t) |
| (hhalf : ∀ T ∈ J, |H - T| ≤ a / 2) |
| (C : ((M.activeGraph J).induce (o.superlevel H hH t)).ConnectedComponent) : |
| ∃ p ∈ o.entrances H hH t C, ∃ q ∈ o.entrances H hH t C, |
| ∀ x : M.Point J root, x.column ∈ ColumnOrder.componentColumns C → |
| dist x p ≤ dist o x - t + 201 * a ∨ |
| dist x q ≤ dist o x - t + 201 * a := by |
| obtain ⟨p, hp, q, hq, _, _, hc⟩ := o.component_two_portals hJ hH ha hhalf C |
| (o.entrances_nonempty hJ hH ht hhalf C) |
| refine ⟨p, hp, q, hq, ?_⟩ |
| intro x hx |
| obtain ⟨z, hz, hd⟩ := o.exit_superlevel hJ x hH ht hhalf C hx |
| rcases hc z hz with hz | hz |
| · left |
| linarith [dist_triangle x z p] |
| · right |
| linarith [dist_triangle x z q] |
|
|
| /-- The half-open radial layer of the source. Its connected components, |
| not components of the ambient graph, are the cell column sets. -/ |
| def layer (o : M.Point J root) (H : ℝ) (hH : H ∈ J) (q D : ℝ) : Set (Fin n) := |
| {i | ∃ hi : (M.activeGraph J).Reachable root i, |
| q ≤ dist o (⟨i, H, hH, hi⟩ : M.Point J root) ∧ |
| dist o (⟨i, H, hH, hi⟩ : M.Point J root) < q + D} |
|
|
| lemma layer_subset_superlevel (o : M.Point J root) (H : ℝ) (hH : H ∈ J) (q D : ℝ) : |
| o.layer H hH q D ⊆ o.superlevel H hH q := by |
| rintro i ⟨hr, hlow, _⟩ |
| exact ⟨hr, hlow⟩ |
|
|
| lemma mem_layer_iff (o x : M.Point J root) (H : ℝ) (hH : H ∈ J) (q D : ℝ) : |
| x.column ∈ o.layer H hH q D ↔ |
| q ≤ dist o (x.withHeight H hH) ∧ dist o (x.withHeight H hH) < q + D := by |
| constructor |
| · rintro ⟨_, hd⟩ |
| exact hd |
| · intro hd |
| exact ⟨x.reachable, hd⟩ |
|
|
| /-- The weak-diameter assertion of `geo:cells` for the literal full-column |
| cell. Paths measuring distance may leave the cell, exactly as in the source. -/ |
| lemma radial_cell_diameter (hJ : IsClosed J) (o : M.Point J root) |
| {H a q D : ℝ} (hH : H ∈ J) (ha : 0 < a) (hthin : a ≤ D / 1000) |
| (hhalf : ∀ T ∈ J, |H - T| ≤ a / 2) |
| (C : ((M.activeGraph J).induce (o.layer H hH q D)).ConnectedComponent) |
| (x y : M.Point J root) (hx : x.column ∈ ColumnOrder.componentColumns C) |
| (hy : y.column ∈ ColumnOrder.componentColumns C) : dist x y ≤ 10 * D := by |
| classical |
| have hD : 0 < D := by linarith |
| have hup : ∀ z : M.Point J root, z.column ∈ ColumnOrder.componentColumns C → |
| dist o z < q + D + a / 2 := by |
| intro z hz |
| have hr := (o.mem_layer_iff z H hH q D).mp |
| (ColumnOrder.componentColumns_subset C hz) |
| have hv := hhalf z.height z.inBand |
| have hd := dist_triangle o (z.withHeight H hH) z |
| rw [dist_comm (z.withHeight H hH) z, z.dist_withHeight, abs_sub_comm] at hd |
| linarith [hr.2] |
| by_cases hq : q ≤ 30 * a |
| · have hd := dist_triangle x o y |
| rw [dist_comm x o] at hd |
| linarith [hup x hx, hup y hy] |
| · let Cplus := ColumnOrder.componentAbove (o.layer_subset_superlevel H hH q D) C |
| have hsub := ColumnOrder.componentColumns_above (o.layer_subset_superlevel H hH q D) C |
| have ht : a / 2 < q := by linarith |
| obtain ⟨p, _, r, _, hc⟩ := o.component_portal_cover hJ hH ha ht hhalf Cplus |
| let f : ColumnOrder.componentColumns C → M.Point J root := fun i => |
| ⟨i.val, H, hH, (ColumnOrder.componentColumns_subset C i.property).choose⟩ |
| have hedge : ∀ i j, ((M.activeGraph J).induce (ColumnOrder.componentColumns C)).Adj i j → |
| dist (f i) (f j) ≤ a := by |
| intro i j hij |
| exact (f i).dist_midpoints_le (f j) rfl rfl hhalf hij |
| have hcover : ∀ i, dist (f i) p ≤ D + 210 * a ∨ dist (f i) r ≤ D + 210 * a := by |
| intro i |
| have hfi : (f i).column ∈ ColumnOrder.componentColumns C := i.property |
| have hu := hup (f i) hfi |
| rcases hc (f i) (hsub hfi) with h | h |
| · exact Or.inl (by linarith) |
| · exact Or.inr (by linarith) |
| have hd := ColumnOrder.connected_two_balls |
| (ColumnOrder.componentColumns_connected C).preconnected f p r |
| (show 0 ≤ D + 210 * a by positivity) ha.le hedge hcover ⟨x.column, hx⟩ ⟨y.column, hy⟩ |
| have hvx : dist x (f ⟨x.column, hx⟩) ≤ a / 2 := by |
| change dist x (x.withHeight H hH) ≤ a / 2 |
| rw [x.dist_withHeight, abs_sub_comm] |
| exact hhalf x.height x.inBand |
| have hvy : dist (f ⟨y.column, hy⟩) y ≤ a / 2 := by |
| change dist (y.withHeight H hH) y ≤ a / 2 |
| rw [dist_comm, y.dist_withHeight, abs_sub_comm] |
| exact hhalf y.height y.inBand |
| have ht₁ := dist_triangle x (f ⟨x.column, hx⟩) y |
| have ht₂ := dist_triangle (f ⟨x.column, hx⟩) (f ⟨y.column, hy⟩) y |
| linarith |
|
|
| /-- Changing to the fixed midheight costs at most one band width in any |
| radial comparison. This also controls all zero-distance representatives. -/ |
| lemma radial_difference_le (o x y : M.Point J root) {H a : ℝ} (hH : H ∈ J) |
| (hhalf : ∀ T ∈ J, |H - T| ≤ a / 2) : |
| |dist o (x.withHeight H hH) - dist o (y.withHeight H hH)| ≤ dist x y + a := by |
| have hx : dist x (x.withHeight H hH) ≤ a / 2 := by |
| rw [x.dist_withHeight, abs_sub_comm] |
| exact hhalf x.height x.inBand |
| have hy : dist y (y.withHeight H hH) ≤ a / 2 := by |
| rw [y.dist_withHeight, abs_sub_comm] |
| exact hhalf y.height y.inBand |
| have h₁ := abs_dist_sub_le (x.withHeight H hH) (y.withHeight H hH) o |
| rw [dist_comm (x.withHeight H hH) o, dist_comm (y.withHeight H hH) o] at h₁ |
| have h₂ := dist_triangle (x.withHeight H hH) x (y.withHeight H hH) |
| have h₃ := dist_triangle x y (y.withHeight H hH) |
| rw [dist_comm (x.withHeight H hH) x] at h₂ |
| linarith |
|
|
| /-- A column visited by a short switching path has a nearby radial midpoint. |
| The conclusion uses the actual path prefix, rather than a shortest path |
| constrained to a radial cell. -/ |
| lemma path_radial_bound (o x y : M.Point J root) {H a : ℝ} (hH : H ∈ J) |
| (hhalf : ∀ T ∈ J, |H - T| ≤ a / 2) (p : M.Path J x.column y.column) |
| {i : Fin n} (hi : i ∈ p.word.support) : |
| ∃ hr : (M.activeGraph J).Reachable root i, |
| |dist o (⟨i, H, hH, hr⟩ : M.Point J root) - dist o (x.withHeight H hH)| ≤ |
| p.length x.height y.height + a := by |
| obtain ⟨T, hT, q, r, hqr⟩ := p.split_at_column x.inBand y.inBand hi |
| let z : M.Point J root := ⟨i, T, hT, x.reachable.trans q.word.reachable⟩ |
| have hd : dist x z ≤ p.length x.height y.height := by |
| have hq := x.distance_le z q |
| have hr := r.length_nonneg T y.height |
| change dist x z ≤ q.length x.height T at hq |
| linarith |
| refine ⟨z.reachable, ?_⟩ |
| have hb := o.radial_difference_le z x hH hhalf |
| rw [dist_comm z x] at hb |
| change |dist o (z.withHeight H hH) - dist o (x.withHeight H hH)| ≤ _ |
| linarith |
|
|
| /-- Deterministic padding in one actual radial layer. All representatives of |
| all endpoints are covered because the lemma is stated on the pseudometric |
| space of representatives. -/ |
| lemma radial_cell_padding (o x y : M.Point J root) {H a q D ρ : ℝ} |
| (hH : H ∈ J) (ha : 0 ≤ a) (hhalf : ∀ T ∈ J, |H - T| ≤ a / 2) |
| (C : ((M.activeGraph J).induce (o.layer H hH q D)).ConnectedComponent) |
| (hx : x.column ∈ ColumnOrder.componentColumns C) |
| (hlow : q + ρ + 2 * a < dist o (x.withHeight H hH)) |
| (hupp : dist o (x.withHeight H hH) < q + D - ρ - 2 * a) |
| (p : M.Path J x.column y.column) (hp : p.length x.height y.height ≤ ρ) : |
| y.column ∈ ColumnOrder.componentColumns C := by |
| apply ColumnOrder.componentColumns_of_walk C p.word hx |
| intro i hi |
| obtain ⟨hr, hb⟩ := o.path_radial_bound x y hH hhalf p hi |
| obtain ⟨h₁, h₂⟩ := abs_le.mp hb |
| refine ⟨hr, ?_, ?_⟩ <;> linarith |
| |
| lemma radial_ball_padding (hJ : IsClosed J) (o x y : M.Point J root) |
| {H a q D ρ : ℝ} (hH : H ∈ J) (ha : 0 ≤ a) |
| (hhalf : ∀ T ∈ J, |H - T| ≤ a / 2) |
| (C : ((M.activeGraph J).induce (o.layer H hH q D)).ConnectedComponent) |
| (hx : x.column ∈ ColumnOrder.componentColumns C) |
| (hlow : q + ρ + 2 * a < dist o (x.withHeight H hH)) |
| (hupp : dist o (x.withHeight H hH) < q + D - ρ - 2 * a) |
| (hxy : dist x y ≤ ρ) : y.column ∈ ColumnOrder.componentColumns C := by |
| obtain ⟨p, _, hp⟩ := x.exists_shortest hJ y |
| exact o.radial_cell_padding x y hH ha hhalf C hx hlow hupp p (hp ▸ hxy) |
|
|
| /-- The literal full-column frontier of a column cell in the active graph. -/ |
| def frontier (C : Set (Fin n)) : Set (Fin n) := |
| {i | i ∈ C ∧ ∃ j, (M.activeGraph J).Adj i j ∧ j ∉ C} |
|
|
| /-- A frontier midpoint is within one width of a layer threshold. The |
| neighbor cannot be in the same layer, since the cell is a component there. -/ |
| lemma frontier_radial (o z : M.Point J root) {H a q D : ℝ} (hH : H ∈ J) |
| (hhalf : ∀ T ∈ J, |H - T| ≤ a / 2) |
| (C : ((M.activeGraph J).induce (o.layer H hH q D)).ConnectedComponent) |
| (hz : z.column ∈ frontier (M := M) (J := J) (ColumnOrder.componentColumns C)) : |
| dist o (z.withHeight H hH) < q + a ∨ |
| q + D - a ≤ dist o (z.withHeight H hH) := by |
| obtain ⟨hzc, j, hzj, hj⟩ := hz |
| let w : M.Point J root := ⟨j, H, hH, z.reachable.trans hzj.reachable⟩ |
| have hnot : j ∉ o.layer H hH q D := by |
| intro h |
| exact hj (ColumnOrder.componentColumns_adj C hzc hzj h) |
| have hd : dist (z.withHeight H hH) w ≤ a := |
| (z.withHeight H hH).dist_midpoints_le w rfl rfl hhalf hzj |
| have hw : ¬ (q ≤ dist o w ∧ dist o w < q + D) := by |
| intro h |
| exact hnot ⟨w.reachable, h⟩ |
| have ht₁ := dist_triangle o (z.withHeight H hH) w |
| have ht₂ := dist_triangle o w (z.withHeight H hH) |
| rw [dist_comm w (z.withHeight H hH)] at ht₂ |
| by_cases hq : dist o w < q |
| · exact Or.inl (by linarith) |
| · exact Or.inr (by have h := not_lt.mp hq; have h' : q + D ≤ dist o w := |
| le_of_not_gt (fun hu => hw ⟨h, hu⟩); linarith) |
| |
| /-- Exact strict avoidance of the frontier, the second assertion of |
| `geo:padding`. The empty-frontier case is automatic, not assigned distance 0. -/ |
| lemma radial_frontier_distance (o x z : M.Point J root) {H a q D ρ : ℝ} |
| (hH : H ∈ J) (hhalf : ∀ T ∈ J, |H - T| ≤ a / 2) |
| (C : ((M.activeGraph J).induce (o.layer H hH q D)).ConnectedComponent) |
| (hlow : q + ρ + 2 * a < dist o (x.withHeight H hH)) |
| (hupp : dist o (x.withHeight H hH) < q + D - ρ - 2 * a) |
| (hz : z.column ∈ frontier (M := M) (J := J) (ColumnOrder.componentColumns C)) : |
| ρ < dist x z := by |
| obtain h | h := o.frontier_radial z hH hhalf C hz |
| · have hb := (abs_le.mp (o.radial_difference_le x z hH hhalf)).2 |
| linarith |
| · have hb := (abs_le.mp (o.radial_difference_le x z hH hhalf)).1 |
| linarith |
|
|
|
|
| /-- Every fixed column is an isometric copy of its allowed height interval. -/ |
| def columnMap (i : Fin n) (hi : (M.activeGraph J).Reachable root i) : J → M.Point J root := |
| fun H => ⟨i, H.val, H.property, hi⟩ |
|
|
| lemma columnMap_isometry (i : Fin n) (hi : (M.activeGraph J).Reachable root i) : |
| Isometry (columnMap i hi) := by |
| apply Isometry.of_dist_eq |
| intro H T |
| exact (columnMap i hi H).dist_same_column (columnMap i hi T) rfl |
|
|
| /-- Compactness of any full-column subset in a compact band, including the |
| literal radial cells and their frontiers. This argument works before taking |
| the separation quotient and does not require a false Hausdorff assumption. -/ |
| lemma fullColumns_compact (hJ : IsCompact J) (C : Set (Fin n)) : |
| IsCompact {x : M.Point J root | x.column ∈ C} := by |
| classical |
| let : CompactSpace J := isCompact_iff_compactSpace.mp hJ |
| let I := {i : Fin n // i ∈ C ∧ (M.activeGraph J).Reachable root i} |
| have heq : {x : M.Point J root | x.column ∈ C} = |
| ⋃ i : I, Set.range (columnMap i.val i.property.2) := by |
| ext x |
| constructor |
| · intro hx |
| refine Set.mem_iUnion.mpr ⟨⟨x.column, hx, x.reachable⟩, ?_⟩ |
| exact ⟨⟨x.height, x.inBand⟩, rfl⟩ |
| · intro hx |
| obtain ⟨i, H, rfl⟩ := Set.mem_iUnion.mp hx |
| exact i.property.1 |
| rw [heq] |
| exact isCompact_iUnion (fun i => isCompact_range (columnMap_isometry i.val i.property.2).continuous) |
|
|
| /-- A continuous scalar frontier constraint attains its infimum whenever |
| there is a frontier point. Used by the main raise-or-descend test. -/ |
| lemma frontier_minimizer (hJ : IsCompact J) (C : Set (Fin n)) |
| (s : M.Point J root → ℝ) (hs : Continuous s) (x : M.Point J root) (c : ℝ) |
| (hne : ∃ z : M.Point J root, z.column ∈ frontier (M := M) (J := J) C) : |
| ∃ z : M.Point J root, z.column ∈ frontier (M := M) (J := J) C ∧ |
| ∀ w : M.Point J root, w.column ∈ frontier (M := M) (J := J) C → |
| s z + c * dist x z ≤ s w + c * dist x w := by |
| have hc := fullColumns_compact (M := M) (root := root) hJ |
| (frontier (M := M) (J := J) C) |
| have hf : Continuous (fun z : M.Point J root => s z + c * dist x z) := |
| hs.add (continuous_const.mul (continuous_const.dist continuous_id)) |
| obtain ⟨z, hz, hmin⟩ := hc.exists_isMinOn hne hf.continuousOn |
| exact ⟨z, hz, hmin⟩ |
|
|
|
|
| /-- The metric interpolation property of an actual attained shortest path. |
| This is the geodesic fact used by the small-ball and descending-path arguments. -/ |
| lemma exists_between (hJ : IsClosed J) (hconv : Set.OrdConnected J) |
| (x y : M.Point J root) {ℓ : ℝ} (hℓ : 0 ≤ ℓ) (hlen : ℓ ≤ dist x y) : |
| ∃ z : M.Point J root, dist x z = ℓ ∧ dist z y = dist x y - ℓ := by |
| obtain ⟨p, _, hp⟩ := x.exists_shortest hJ y |
| obtain ⟨k, T, hT, q, r, hq, hr⟩ := p.split_at_length hconv x.inBand y.inBand hℓ |
| (hp ▸ hlen) |
| let z : M.Point J root := ⟨k, T, hT, x.reachable.trans q.word.reachable⟩ |
| have h₁ : dist x z ≤ ℓ := by |
| have h := x.distance_le z q |
| exact h.trans_eq hq |
| have h₂ : dist z y ≤ dist x y - ℓ := by |
| have h := z.distance_le y r |
| exact h.trans_eq (hr.trans (by rw [hp])) |
| have ht := dist_triangle x z y |
| exact ⟨z, by linarith, by linarith⟩ |
|
|
| /-- Every point on a shortest descending path retains the endpoint's deficit |
| bound. This is `main:ray-prefix`, expressed by exact arclength distances. -/ |
| lemma descent_along_shortest {s : M.Point J root → ℝ} {ε : ℝ} |
| (hs : ∀ u v, s u - s v ≤ dist u v) (x z v : M.Point J root) |
| (hshort : dist x v + dist v z = dist x z) |
| (hdrop : s z ≤ s x - dist x z + ε) : |
| s v ≤ s x - dist x v + ε := by |
| linarith [hs v z] |
|
|
|
|
| /-- All representatives of the intrinsic closed ball, projected to columns. |
| Using representatives includes columns identified by zero-length paths. -/ |
| def ballColumns (x : M.Point J root) (ρ : ℝ) : Set (Fin n) := |
| {i | ∃ y : M.Point J root, y.column = i ∧ dist x y ≤ ρ} |
|
|
| lemma mem_ballColumns (x y : M.Point J root) {ρ : ℝ} (hy : dist x y ≤ ρ) : |
| y.column ∈ x.ballColumns ρ := ⟨y, rfl, hy⟩ |
|
|
| lemma path_ballColumns (x y : M.Point J root) (p : M.Path J x.column y.column) |
| {ρ : ℝ} (hp : p.length x.height y.height ≤ ρ) : |
| ∀ v ∈ p.word.support, v ∈ x.ballColumns ρ := by |
| intro v hv |
| obtain ⟨T, hT, q, r, hqr⟩ := p.split_at_column x.inBand y.inBand hv |
| let z : M.Point J root := ⟨v, T, hT, x.reachable.trans q.word.reachable⟩ |
| refine ⟨z, rfl, ?_⟩ |
| have h := x.distance_le z q |
| have hr := r.length_nonneg T y.height |
| change dist x z ≤ q.length x.height T at h |
| linarith |
|
|
| /-- The projection of an actual closed ball is induced-connected. This is |
| not an assumed graph property in the local interpolation argument. -/ |
| lemma ballColumns_preconnected (hJ : IsClosed J) (x : M.Point J root) (ρ : ℝ) : |
| ((M.activeGraph J).induce (x.ballColumns ρ)).Preconnected := by |
| intro i j |
| obtain ⟨y, hy, hxy⟩ := i.property |
| obtain ⟨z, hz, hxz⟩ := j.property |
| obtain ⟨p, _, hp⟩ := x.exists_shortest hJ y |
| obtain ⟨q, _, hq⟩ := x.exists_shortest hJ z |
| have hm : ∀ v ∈ (p.word.reverse.append q.word).support, |
| v ∈ x.ballColumns ρ := by |
| intro v hv |
| rcases (p.word.reverse.mem_support_append_iff q.word).mp hv with h | h |
| · exact x.path_ballColumns y p (hp ▸ hxy) v (by simpa using h) |
| · exact x.path_ballColumns z q (hq ▸ hxz) v h |
| have hreach := (p.word.reverse.append q.word).induce _ hm |
| exact ⟨hreach.copy (Subtype.ext hy) (Subtype.ext hz)⟩ |
|
|
| lemma ballColumns_nonempty (x : M.Point J root) {ρ : ℝ} (hρ : 0 ≤ ρ) : |
| (x.ballColumns ρ).Nonempty := |
| ⟨x.column, x.mem_ballColumns x (by simpa using hρ)⟩ |
|
|
| /-- The sharper `2ρ+a` version of the source's `2ρ+2a` radial spread. -/ |
| lemma ball_radial_spread (o x y z : M.Point J root) {H a ρ : ℝ} (hH : H ∈ J) |
| (hhalf : ∀ T ∈ J, |H - T| ≤ a / 2) |
| (hy : dist x y ≤ ρ) (hz : dist x z ≤ ρ) : |
| |dist o (y.withHeight H hH) - dist o (z.withHeight H hH)| ≤ 2 * ρ + a := by |
| have h := o.radial_difference_le y z hH hhalf |
| have ht := dist_triangle y x z |
| rw [dist_comm y x] at ht |
| linarith |
|
|
| /-- A shortest path to any point outside a high component reaches an actual |
| entrance within its total length. Unlike `exit_superlevel`, no radial decrease |
| to the root is needed. -/ |
| lemma exit_superlevel_to (hJ : IsClosed J) (o x y : M.Point J root) |
| {H t : ℝ} (hH : H ∈ J) |
| (C : ((M.activeGraph J).induce (o.superlevel H hH t)).ConnectedComponent) |
| (hx : x.column ∈ ColumnOrder.componentColumns C) |
| (hy : y.column ∉ ColumnOrder.componentColumns C) : |
| ∃ z : M.Point J root, z.withHeight H hH ∈ o.entrances H hH t C ∧ |
| dist x z ≤ dist x y := by |
| let S := ColumnOrder.componentColumns C |
| obtain ⟨p, _, hp⟩ := x.exists_shortest hJ y |
| obtain ⟨u, v, T, hT, hs, hu, hv, q, r, hqr⟩ := |
| p.crosses_set Sᶜ (by simpa only [Set.mem_compl_iff, not_not] using hx) |
| hy x.height y.height |
| have huC : u ∈ S := by simpa only [Set.mem_compl_iff, not_not] using hu |
| have huv : (M.activeGraph J).Adj u v := ⟨T, hT, hs⟩ |
| let z : M.Point J root := ⟨u, T, hT, x.reachable.trans q.word.reachable⟩ |
| let w : M.Point J root := ⟨v, H, hH, z.reachable.trans huv.reachable⟩ |
| have hw : dist o w < t := by |
| apply lt_of_not_ge |
| intro h |
| exact hv (ColumnOrder.componentColumns_adj C huC huv ⟨w.reachable, h⟩) |
| refine ⟨z, ⟨rfl, huC, w, rfl, huv, hw⟩, ?_⟩ |
| have hdx := x.distance_le z q |
| change dist x z ≤ q.length x.height T at hdx |
| have hr := r.length_nonneg T y.height |
| linarith |
|
|
| /-- Any point in a high component and within `L` of a point outside it is |
| within `L+200a` of one of its two fixed entrance portals. -/ |
| lemma near_component_portal (hJ : IsClosed J) (o : M.Point J root) |
| {H a t : ℝ} (hH : H ∈ J) (ha : 0 < a) |
| (hhalf : ∀ T ∈ J, |H - T| ≤ a / 2) |
| (C : ((M.activeGraph J).induce (o.superlevel H hH t)).ConnectedComponent) |
| (hne : (o.entrances H hH t C).Nonempty) : |
| ∃ p ∈ o.entrances H hH t C, ∃ q ∈ o.entrances H hH t C, |
| ∀ x y : M.Point J root, x.column ∈ ColumnOrder.componentColumns C → |
| y.column ∉ ColumnOrder.componentColumns C → |
| dist x p ≤ dist x y + 200 * a ∨ dist x q ≤ dist x y + 200 * a := by |
| obtain ⟨p, hp, q, hq, _, _, hc⟩ := o.component_two_portals hJ hH ha hhalf C hne |
| refine ⟨p, hp, q, hq, ?_⟩ |
| intro x y hx hy |
| obtain ⟨z, hz, hdist⟩ := o.exit_superlevel_to hJ x y hH C hx hy |
| rcases hc z hz with h | h |
| · exact Or.inl (by linarith [dist_triangle x z p]) |
| · exact Or.inr (by linarith [dist_triangle x z q]) |
|
|
|
|
| /-- The fixed-height radial profile attains its minimum among the finite |
| set of columns represented in a nonempty closed ball. -/ |
| lemma ball_radial_minimum (o x : M.Point J root) {H ρ : ℝ} (hH : H ∈ J) |
| (hρ : 0 ≤ ρ) : |
| ∃ y : M.Point J root, dist x y ≤ ρ ∧ |
| ∀ z : M.Point J root, dist x z ≤ ρ → |
| dist o (y.withHeight H hH) ≤ dist o (z.withHeight H hH) := by |
| let R := {i : Fin n // (M.activeGraph J).Reachable root i} |
| let S : Set R := {i | i.val ∈ x.ballColumns ρ} |
| let f : R → ℝ := fun i => dist o ⟨i.val, H, hH, i.property⟩ |
| have hne : S.Nonempty := |
| ⟨⟨x.column, x.reachable⟩, x.mem_ballColumns x (by simpa using hρ)⟩ |
| obtain ⟨i, hi, hmin⟩ := Set.exists_min_image S f (Set.toFinite _) hne |
| obtain ⟨y, hy, hxy⟩ := hi |
| refine ⟨y, hxy, ?_⟩ |
| intro z hz |
| have heq : (⟨i.val, H, hH, i.property⟩ : M.Point J root) = y.withHeight H hH := by |
| cases y |
| simp_all only [withHeight] |
| have h := hmin ⟨z.column, z.reachable⟩ (x.mem_ballColumns z hz) |
| change dist o _ ≤ dist o (z.withHeight H hH) at h |
| rwa [heq] at h |
|
|
| /-- The exact geometric content of the one-chain small-ball argument: |
| there are only two consecutive radial layer depths in a sufficiently small |
| ball, and all its representatives lie in one node at the lower depth. -/ |
| lemma ball_two_layers (hJ : IsClosed J) (o x : M.Point J root) |
| {H a ρ δ : ℝ} (hH : H ∈ J) (hρ : 0 ≤ ρ) (hδ : 0 < δ) |
| (hhalf : ∀ T ∈ J, |H - T| ≤ a / 2) (hsmall : 2 * ρ + a < δ) : |
| ∃ k : ℕ, ∃ y : M.Point J root, |
| ∃ C : ((M.activeGraph J).induce (o.superlevel H hH (k * δ))).ConnectedComponent, |
| dist x y ≤ ρ ∧ dist o (y.withHeight H hH) < (k + 1) * δ ∧ |
| (∀ z : M.Point J root, dist x z ≤ ρ → |
| z.column ∈ ColumnOrder.componentColumns C ∧ |
| (k : ℝ) * δ ≤ dist o (z.withHeight H hH) ∧ |
| dist o (z.withHeight H hH) < (k + 2) * δ) := by |
| obtain ⟨y, hy, hmin⟩ := o.ball_radial_minimum x hH hρ |
| let b := dist o (y.withHeight H hH) |
| let k := ⌊b / δ⌋₊ |
| have hb : 0 ≤ b / δ := div_nonneg dist_nonneg hδ.le |
| have hlo : (k : ℝ) * δ ≤ b := (le_div_iff₀ hδ).mp (Nat.floor_le hb) |
| have hhi : b < (k + 1) * δ := (div_lt_iff₀ hδ).mp (Nat.lt_floor_add_one (b / δ)) |
| have hbound : ∀ z : M.Point J root, dist x z ≤ ρ → |
| (k : ℝ) * δ ≤ dist o (z.withHeight H hH) ∧ |
| dist o (z.withHeight H hH) < (k + 2) * δ := by |
| intro z hz |
| have hminz := hmin z hz |
| have hspread := o.ball_radial_spread x z y hH hhalf hz hy |
| have hu := (abs_le.mp hspread).2 |
| constructor |
| · exact hlo.trans hminz |
| · dsimp [b] at hhi |
| linarith |
| have hsub : x.ballColumns ρ ⊆ o.superlevel H hH (k * δ) := by |
| rintro _ ⟨z, rfl, hz⟩ |
| exact (o.mem_superlevel_iff z H hH (k * δ)).mpr (hbound z hz).1 |
| obtain ⟨C, hC⟩ := ColumnOrder.exists_component_containing |
| (x.ballColumns_nonempty hρ) (x.ballColumns_preconnected hJ ρ) hsub |
| exact ⟨k, y, C, hy, hhi, fun z hz => ⟨hC (x.mem_ballColumns z hz), hbound z hz⟩⟩ |
|
|
|
|
| /-- At depth zero the single radial node contains every reachable column, |
| including the chosen basepoint column. -/ |
| lemma mem_zero_component (o x : M.Point J root) {H : ℝ} (hH : H ∈ J) |
| (C : ((M.activeGraph J).induce (o.superlevel H hH 0)).ConnectedComponent) : |
| x.column ∈ ColumnOrder.componentColumns C := by |
| classical |
| obtain ⟨i, hi⟩ := C.nonempty_supp |
| obtain ⟨hr, _⟩ := i.property |
| obtain ⟨p⟩ := hr.symm.trans x.reachable |
| apply ColumnOrder.componentColumns_of_walk C p ⟨i, hi, rfl⟩ |
| intro v hv |
| exact ⟨hr.trans (p.takeUntil v hv).reachable, dist_nonneg⟩ |
|
|
| /-- Two fixed geometric portals, with all bounds required by the actual |
| interpolation hierarchy. Repeated portals encode the one-portal case. -/ |
| structure PortalData (o : M.Point J root) (H : ℝ) (hH : H ∈ J) (a t : ℝ) |
| (C : ((M.activeGraph J).induce (o.superlevel H hH t)).ConnectedComponent) where |
| left : M.Point J root |
| right : M.Point J root |
| left_height : left.height = H |
| right_height : right.height = H |
| left_mem : left.column ∈ ColumnOrder.componentColumns C |
| right_mem : right.column ∈ ColumnOrder.componentColumns C |
| left_radial : t ≤ dist o left ∧ dist o left < t + a |
| right_radial : t ≤ dist o right ∧ dist o right < t + a |
| cover : ∀ x : M.Point J root, x.column ∈ ColumnOrder.componentColumns C → |
| min (dist x left) (dist x right) ≤ dist o x - t + 201 * a |
| entrance_cover : ∀ x : M.Point J root, |
| x.withHeight H hH ∈ o.entrances H hH t C → |
| min (dist x left) (dist x right) ≤ 200 * a |
|
|
| /-- The portal data are constructed from the proved geometry, including the |
| root convention; they are not assumptions on the interpolation input. -/ |
| lemma portalData_nonempty (hJ : IsClosed J) (o : M.Point J root) |
| {H a t : ℝ} (hH : H ∈ J) (ho : o.height = H) (ha : 0 < a) |
| (hhalf : ∀ T ∈ J, |H - T| ≤ a / 2) (ht : t = 0 ∨ a / 2 < t) |
| (C : ((M.activeGraph J).induce (o.superlevel H hH t)).ConnectedComponent) : |
| Nonempty (o.PortalData H hH a t C) := by |
| rcases ht with rfl | ht |
| · refine ⟨⟨o, o, ho, ho, o.mem_zero_component o hH C, |
| o.mem_zero_component o hH C, ?_, ?_, ?_, ?_⟩⟩ |
| · simpa only [dist_self, zero_add] using And.intro (le_refl (0 : ℝ)) ha |
| · simpa only [dist_self, zero_add] using And.intro (le_refl (0 : ℝ)) ha |
| · intro x _ |
| simp only [min_self, sub_zero, dist_comm x o] |
| linarith |
| · rintro x ⟨_, _, y, _, _, hy⟩ |
| exact (not_lt_of_ge dist_nonneg hy).elim |
| · obtain ⟨p, hp, q, hq, hpr, hqr, hc⟩ := o.component_two_portals hJ hH ha hhalf C |
| (o.entrances_nonempty hJ hH ht hhalf C) |
| refine ⟨⟨p, q, hp.1, hq.1, hp.2.1, hq.2.1, hpr, hqr, ?_, ?_⟩⟩ |
| · intro x hx |
| obtain ⟨z, hz, hd⟩ := o.exit_superlevel hJ x hH ht hhalf C hx |
| rcases hc z hz with hz | hz |
| · exact (min_le_left _ _).trans (by linarith [dist_triangle x z p]) |
| · exact (min_le_right _ _).trans (by linarith [dist_triangle x z q]) |
| · intro x hx |
| exact min_le_iff.mpr (hc x hx) |
|
|
| namespace PortalData |
|
|
| variable {o : M.Point J root} {H a t : ℝ} {hH : H ∈ J} |
| {C : ((M.activeGraph J).induce (o.superlevel H hH t)).ConnectedComponent} |
|
|
| /-- Layer points and points only slightly beyond its top are close to a |
| fixed portal. The radial allowance is kept explicit for child portals. -/ |
| lemma near_of_radial (K : o.PortalData H hH a t C) |
| {δ e : ℝ} (x : M.Point J root) (hx : x.column ∈ ColumnOrder.componentColumns C) |
| (hr : dist o x ≤ t + δ + e) : |
| min (dist x K.left) (dist x K.right) ≤ δ + e + 201 * a := by |
| linarith [K.cover x hx] |
|
|
| lemma near_layer (K : o.PortalData H hH a t C) |
| (hhalf : ∀ T ∈ J, |H - T| ≤ a / 2) (ha : 0 ≤ a) |
| {δ : ℝ} (x : M.Point J root) (hx : x.column ∈ ColumnOrder.componentColumns C) |
| (hr : dist o (x.withHeight H hH) < t + δ) : |
| min (dist x K.left) (dist x K.right) ≤ δ + 220 * a := by |
| have hv : dist (x.withHeight H hH) x ≤ a / 2 := by |
| rw [dist_comm, x.dist_withHeight, abs_sub_comm] |
| exact hhalf x.height x.inBand |
| have htri := dist_triangle o (x.withHeight H hH) x |
| linarith [K.cover x hx] |
|
|
| /-- A near-exit point is in the equality collar of these same portals; |
| there is no resampling or reselecting a different portal pair. -/ |
| lemma near_exit (K : o.PortalData H hH a t C) (hJ : IsClosed J) |
| (x y : M.Point J root) (hx : x.column ∈ ColumnOrder.componentColumns C) |
| (hy : y.column ∉ ColumnOrder.componentColumns C) : |
| min (dist x K.left) (dist x K.right) ≤ dist x y + 200 * a := by |
| obtain ⟨z, hz, hd⟩ := o.exit_superlevel_to hJ x y hH C hx hy |
| rcases min_le_iff.mp (K.entrance_cover z hz) with h | h |
| · exact (min_le_left _ _).trans (by linarith [dist_triangle x z K.left]) |
| · exact (min_le_right _ _).trans (by linarith [dist_triangle x z K.right]) |
|
|
| end PortalData |
|
|
| end Point |
|
|
| end Model |
| end Columns |
| end PlanarL1 |
|
|
| end |
|
|
| end OAI |
|
|
