| import OAI.Combinatorics.PlanarL1.Growth |
|
|
| namespace OAI |
|
|
| section |
|
|
|
|
|
|
| namespace PlanarL1.HeightTree |
| open Set PlanarL1.Topology |
| attribute [local instance] Classical.propDecidable |
| variable {V : Type} [Fintype V] [LinearOrder V] (T : HeightTree V) |
| {G : SimpleGraph V} (P : PLDrawing G) |
|
|
| lemma growth_exists (hG : T.graph ≤ G) (S : Finset V) |
| (hroot : T.root∈S) (hS : T.ParentClosed S) : Nonempty (T.Growth P S) := by |
| classical |
| induction S using Finset.strongInductionOn with |
| | _ S ih => |
| by_cases hs : S={T.root} |
| · subst S; exact T.initial_growth P hG |
| have hne : (S.erase T.root).Nonempty := by |
| by_contra hh |
| have hempty := Finset.not_nonempty_iff_eq_empty.mp hh |
| apply hs |
| exact (Finset.insert_erase hroot).symm.trans (by rw [hempty]; rfl) |
| obtain ⟨v,hv,hmax⟩ := Finset.exists_max_image (S.erase T.root) T.depth hne |
| have hvr : v≠T.root := (Finset.mem_erase.mp hv).1 |
| have hvS : v∈S := (Finset.mem_erase.mp hv).2 |
| have hroot' : T.root∈S.erase v := Finset.mem_erase.mpr ⟨hvr.symm,hroot⟩ |
| have hS' : T.ParentClosed (S.erase v) := by |
| intro w hw |
| have hwv := (Finset.mem_erase.mp hw).1 |
| have hwS := (Finset.mem_erase.mp hw).2 |
| refine Finset.mem_erase.mpr ⟨?_,hS w hwS⟩ |
| intro he |
| by_cases hwr : w=T.root |
| · subst w; exact hvr (he.symm.trans T.at_root) |
| · have hd := T.step_depth (show T.Step v w from ⟨hwr,he.symm⟩) |
| exact (not_lt_of_ge (hmax w (Finset.mem_erase.mpr ⟨hwr,hwS⟩))) hd |
| have hfront : T.Frontier (S.erase v) v := by |
| refine ⟨(by simp),Finset.mem_erase.mpr ⟨T.parent_ne hvr,hS v hvS⟩⟩ |
| obtain ⟨H⟩ := ih (S.erase v) (Finset.erase_ssubset hvS) hroot' hS' |
| simpa only [Finset.insert_erase hvS] using H.advance hS' hG hfront |
|
|
| noncomputable def internal : Finset V := Finset.univ.filter (fun v => ¬T.IsLeaf v) |
|
|
| omit [LinearOrder V] in |
| lemma mem_internal (v : V) : v∈T.internal ↔ ¬T.IsLeaf v := by simp [internal] |
|
|
| lemma internal_closed : T.ParentClosed T.internal := by |
| intro v hv |
| by_cases he : v=T.root |
| · subst v; rwa [T.at_root] |
| · apply (T.mem_internal _).mpr |
| exact fun h => h v ⟨he,rfl⟩ |
| |
| omit [LinearOrder V] in |
| lemma internal_scope (hroot : ¬T.IsLeaf T.root) (v : V) : T.Scope T.internal v := by |
| by_cases h : T.IsLeaf v |
| · refine Or.inr ⟨fun hv => (T.mem_internal v).mp hv h,(T.mem_internal _).mpr ?_⟩ |
| have hvr : v≠T.root := fun he => hroot (he ▸ h) |
| exact fun hh => hh v ⟨hvr,rfl⟩ |
| · exact Or.inl ((T.mem_internal _).mpr h) |
|
|
| omit [LinearOrder V] in |
| lemma internal_frontier (hroot : ¬T.IsLeaf T.root) (v : V) : |
| T.Frontier T.internal v ↔ T.IsLeaf v := by |
| constructor |
| · intro h |
| by_contra hh |
| exact h.1 ((T.mem_internal _).mpr hh) |
| · intro h |
| rcases T.internal_scope hroot v with hv|hv |
| · exact False.elim ((T.mem_internal _).mp hv h) |
| · exact hv |
|
|
| /-- Every actual polygonally drawn finite tree can be enclosed in a convex disk, |
| with the leaf stubs left as disjoint exterior polygonal arcs. All untouched raw |
| leaf-to-leaf drawing pieces remain outside the closed disk. -/ |
| lemma tree_core (hG : T.graph ≤ G) (hroot : ¬T.IsLeaf T.root) : |
| ∃ C : DiskCore T.graph {v | T.IsLeaf v}, |
| ∃ E : ExteriorPorts C.drawing.point P.point {v | T.IsLeaf v} C.disk, |
| Disjoint (closure C.disk) (P.carrier {v | T.IsLeaf v}) ∧ |
| ∀ v, T.IsLeaf v → ∀ z∈E.region v, z∈P.carrier {v | T.IsLeaf v} → z=P.point v := by |
| classical |
| obtain ⟨H⟩ := T.growth_exists P hG T.internal ((T.mem_internal _).mpr hroot) T.internal_closed |
| let i : V → {v // T.Scope T.internal v} := fun v => ⟨v,T.internal_scope hroot v⟩ |
| have hi : Function.Injective i := fun _ _ h => congrArg Subtype.val h |
| have hgraph : ∀ u v, T.graph.Adj u v → |
| (SimpleGraph.comap Subtype.val T.graph).Adj (i u) (i v) := fun _ _ h => h |
| have hports : ∀ v, T.IsLeaf v → T.Frontier T.internal (i v).val := |
| fun v h => (T.internal_frontier hroot v).mpr h |
| obtain ⟨C,E,hD,hp,hE⟩ := H.core.pullback H.stems i hi hgraph hports |
| have hout : outside P T.internal=P.carrier {v | T.IsLeaf v} := by |
| unfold outside |
| congr 1 |
| ext v |
| simp only [mem_ofPred_eq,T.mem_internal,not_not] |
| refine ⟨C,E,?_,?_⟩ |
| · rw [hD,← hout]; exact H.avoid |
| · intro v hv z hz hzK |
| apply H.contact (i v) (hports v hv) z |
| · exact (hE v) ▸ hz |
| · rwa [hout] |
| |
| end PlanarL1.HeightTree |
| |
| |
| |
| |
| namespace PlanarL1.Topology |
| open Set |
| |
| lemma PolygonallyJoined.exists_path {S : Set ℂ} {x y : ℂ} |
| (h : PolygonallyJoined S x y) (hx : x∈S) : |
| ∃ p : Path x y, range p ⊆ S := by |
| induction h with |
| | refl => exact ⟨Path.refl x,by rintro z ⟨t,rfl⟩; exact hx⟩ |
| | @tail y z h hz ih => |
| obtain ⟨p,hp⟩ := ih |
| exact ⟨p.trans (Path.segment y z),by rw [Path.trans_range,Path.range_segment]; exact union_subset hp hz⟩ |
| |
| namespace DiskCore |
| variable {V : Type} [LinearOrder V] {G : SimpleGraph V} {B : Set V} (C : DiskCore G B) |
|
|
| lemma carrier_subset (S : Set V) : C.drawing.carrier S ⊆ closure C.disk := by |
| intro z hz |
| rcases hz with hz|hz |
| · obtain ⟨v,hv⟩ := mem_iUnion.mp hz |
| exact mem_singleton_iff.mp hv ▸ C.point_mem v.val |
| · obtain ⟨u,hu⟩ := mem_iUnion.mp hz |
| obtain ⟨v,hv⟩ := mem_iUnion.mp hu |
| exact C.region_mem _ _ (C.drawing.region_adj hv) hv |
|
|
| end DiskCore |
| end PlanarL1.Topology |
|
|
| namespace PlanarL1.HeightTree |
| open Set PlanarL1.Topology Real |
| attribute [local instance] Classical.propDecidable |
| variable {V : Type} [LinearOrder V] (T : HeightTree V) |
|
|
| lemma ancestor_plpath (P : PLDrawing T.graph) {u v : V} (h : T.Ancestor u v) |
| {S : Set V} (hS : ∀ w, T.Ancestor u w → T.Ancestor w v → w∈S) : |
| ∃ p : Path (P.point u) (P.point v), range p ⊆ P.carrier S := by |
| induction h with |
| | refl => exact ⟨Path.refl _,by rintro z ⟨t,rfl⟩; exact P.point_mem_carrier (hS _ .refl .refl)⟩ |
| | @tail v w huv hvw ih => |
| obtain ⟨p,hp⟩ := ih (fun a ha hb => hS a ha (hb.tail hvw)) |
| obtain ⟨q,hq⟩ := (P.region_joined v w (Or.inl hvw)).exists_path (P.region_start v w (Or.inl hvw)) |
| refine ⟨p.trans q,?_⟩ |
| rw [Path.trans_range] |
| exact union_subset hp (hq.trans (P.region_mem_carrier (hS v huv (.single hvw)) |
| (hS w (huv.tail hvw) .refl))) |
|
|
| lemma descendants_pljoined (P : PLDrawing T.graph) (a : V) {u v : V} |
| (hu : T.Ancestor a u) (hv : T.Ancestor a v) : |
| ∃ p : Path (P.point u) (P.point v), range p ⊆ P.carrier {w | T.Ancestor a w} := by |
| obtain ⟨p,hp⟩ := T.ancestor_plpath P hu (fun _ h _ => h) |
| obtain ⟨q,hq⟩ := T.ancestor_plpath P hv (fun _ h _ => h) |
| exact ⟨p.symm.trans q,by rw [Path.trans_range,Path.symm_range]; exact union_subset hp hq⟩ |
| |
| lemma nondescendants_pljoined (P : PLDrawing T.graph) (a : V) {u v : V} |
| (hu : ¬T.Ancestor a u) (hv : ¬T.Ancestor a v) : |
| ∃ p : Path (P.point u) (P.point v), range p ⊆ P.carrier {w | ¬T.Ancestor a w} := by |
| obtain ⟨p,hp⟩ := T.ancestor_plpath P (T.root_ancestor u) |
| (S := {w | ¬T.Ancestor a w}) (fun _ _ h ha => hu (ha.trans h)) |
| obtain ⟨q,hq⟩ := T.ancestor_plpath P (T.root_ancestor v) |
| (S := {w | ¬T.Ancestor a w}) (fun _ _ h ha => hv (ha.trans h)) |
| exact ⟨p.symm.trans q,by rw [Path.trans_range,Path.symm_range]; exact union_subset hp hq⟩ |
| |
| lemma core_prefix_connected {B : Set V} {n : ℕ} (C : DiskCore T.graph B) |
| (h : ℂ ≃ₜ ℂ) (hbound : ∀ z∈closure C.disk, ‖h z‖≤1) |
| (leaf : Fin n → V) (angle : Fin n → ℝ) |
| (hend : ∀ i, h (C.drawing.point (leaf i))=(Circle.exp (angle i) : ℂ)) |
| (horder : StrictMono angle) (hspan : ∀ i j, angle j-angle i<2*π) |
| (a : V) {i j : Fin n} (hi : T.Ancestor a (leaf i)) (hj : T.Ancestor a (leaf j)) : |
| (T.prefixGraph leaf a).Reachable i j := by |
| apply Columns.consecutive_connected (T.prefixGraph leaf a) {k | T.Ancestor a (leaf k)} |
| (fun _ _ hne hc ha hb => ⟨hne,hc,ha,hb⟩) _ hi hj |
| intro w x y z hwx hxy hyz hbad |
| suffices impossible : ∀ (S U : Set V), Disjoint S U → |
| (∃ p : Path (C.drawing.point (leaf w)) (C.drawing.point (leaf y)), range p⊆C.drawing.carrier S) → |
| (∃ q : Path (C.drawing.point (leaf x)) (C.drawing.point (leaf z)), range q⊆C.drawing.carrier U) → False by |
| rcases hbad with ⟨hw,hx,hy,hz⟩ | ⟨hw,hx,hy,hz⟩ |
| · exact impossible {v | T.Ancestor a v} {v | ¬T.Ancestor a v} |
| disjoint_compl_right (T.descendants_pljoined C.drawing a hw hy) |
| (T.nondescendants_pljoined C.drawing a hx hz) |
| · exact impossible {v | ¬T.Ancestor a v} {v | T.Ancestor a v} |
| disjoint_compl_left (T.nondescendants_pljoined C.drawing a hw hy) |
| (T.descendants_pljoined C.drawing a hx hz) |
| intro S U hdis ⟨p,hp⟩ ⟨q,hq⟩ |
| let p' := (p.map h.continuous).cast (hend w).symm (hend y).symm |
| let q' := (q.map h.continuous).cast (hend x).symm (hend z).symm |
| obtain ⟨s,t,hst⟩ := Topology.disk_cyclic_arcs_meet (angle w) (angle x) (angle y) (angle z) |
| (horder hwx) (horder hxy) (horder hyz) (by linarith [hspan w z]) p' q' |
| (fun t => hbound _ (C.carrier_subset S (hp (mem_range_self t)))) |
| (fun t => hbound _ (C.carrier_subset U (hq (mem_range_self t)))) |
| have he : p s=q t := h.injective hst |
| exact disjoint_left.mp (C.drawing.carrier_disjoint hdis) (hp (mem_range_self s)) |
| (he ▸ hq (mem_range_self t)) |
|
|
| lemma layout_of_core [Fintype V] (C : DiskCore T.graph {v | T.IsLeaf v}) |
| (P : SimpleGraph {v : V // T.IsLeaf v}) |
| (hheight : ∀ i j, P.Adj i j → T.height i.val=T.height j.val) |
| (hmatch : ∀ i j k, P.Adj i j → P.Adj i k → j=k) |
| (arc : ∀ i j, P.Adj i j → Path (C.drawing.point i.val) (C.drawing.point j.val)) |
| (hout : ∀ i j h t, arc i j h t∉C.disk) |
| (hdis : ∀ i j h k l h', i≠k → i≠l → j≠k → j≠l → |
| Disjoint (range (arc i j h)) (range (arc k l h'))) : |
| ∃ (L : T.Layout (Fintype.card {v : V // T.IsLeaf v})), |
| ∀ i j, L.pair.Adj i j ↔ P.Adj ⟨L.leaf i,L.isLeaf i⟩ ⟨L.leaf j,L.isLeaf j⟩ := by |
| classical |
| obtain ⟨h,hi,hcl,hfr⟩ := exists_homeomorph_image_interior_closure_frontier_eq_unitBall C.convex |
| (show (interior C.disk).Nonempty by rw [C.isOpen.interior_eq]; exact ⟨C.center,C.center_mem⟩) C.bounded |
| have hnorm (v : {v : V // T.IsLeaf v}) : ‖h (C.drawing.point v.val)‖=1 := by |
| have hm := mem_image_of_mem h (C.port v.val v.property) |
| rw [hfr] at hm |
| simpa only [Metric.mem_sphere,dist_zero_right] using hm |
| have hbound (z : ℂ) (hz : z∈closure C.disk) : ‖h z‖≤1 := by |
| have hm := mem_image_of_mem h hz |
| rw [hcl] at hm |
| simpa only [Metric.mem_closedBall,dist_zero_right] using hm |
| have hexterior (z : ℂ) (hz : z∉C.disk) : 1≤‖h z‖ := by |
| by_contra! hn |
| have hm : h z∈Metric.ball (0:ℂ) 1 := by simpa only [Metric.mem_ball,dist_zero_right] using hn |
| rw [← hi] at hm |
| obtain ⟨w,hw,he⟩ := hm |
| exact hz (h.injective he ▸ interior_subset hw) |
| obtain ⟨e,he,hspan⟩ := Topology.finite_port_order (fun v : {v : V // T.IsLeaf v} => h (C.drawing.point v.val)) |
| hnorm (h.injective.comp (C.drawing.point_injective.comp Subtype.val_injective)) |
| let angle (i : Fin (Fintype.card {v : V // T.IsLeaf v})) := Complex.arg (h (C.drawing.point (e i).val)) |
| have hend i : h (C.drawing.point (e i).val)=(Circle.exp (angle i) : ℂ) := |
| (Topology.circle_exp_arg (hnorm (e i))).symm |
| let A : ∀ i j, (SimpleGraph.comap e P).Adj i j → |
| Path (Circle.exp (angle i) : ℂ) (Circle.exp (angle j) : ℂ) := |
| fun i j hij => ((arc (e i) (e j) hij).map h.continuous).cast (hend i).symm (hend j).symm |
| have hnc : ColumnOrder.Noncrossing (SimpleGraph.comap e P) := by |
| apply Topology.noncrossing_of_exterior_arcs _ angle he hspan A |
| · intro i j hij t; exact hexterior _ (hout (e i) (e j) hij t) |
| · intro i j hij k l hkl hik hil hjk hjl |
| rw [disjoint_left] |
| rintro z ⟨s,hs⟩ ⟨t,ht⟩ |
| have hh : h (arc (e i) (e j) hij s)=h (arc (e k) (e l) hkl t) := hs.trans ht.symm |
| exact disjoint_left.mp (hdis (e i) (e j) hij (e k) (e l) hkl |
| (e.injective.ne hik) (e.injective.ne hil) (e.injective.ne hjk) (e.injective.ne hjl)) |
| (mem_range_self s) (h.injective hh ▸ mem_range_self t) |
| let L : T.Layout (Fintype.card {v : V // T.IsLeaf v}) := { |
| leaf := fun i => (e i).val |
| isLeaf := fun i => (e i).property |
| injective := Subtype.val_injective.comp e.injective |
| covers := fun v hv => ⟨e.symm ⟨v,hv⟩,by simp⟩ |
| prefix_connected := fun a i j hi hj => |
| T.core_prefix_connected C h hbound _ angle hend he hspan a hi hj |
| pair := SimpleGraph.comap e P |
| noncrossing := hnc |
| paired_height := fun i j hij => hheight (e i) (e j) hij |
| matching := fun i j k hij hik => e.injective (hmatch (e i) (e j) (e k) hij hik) } |
| exact ⟨L,fun _ _ => Iff.rfl⟩ |
|
|
| end PlanarL1.HeightTree |
|
|
|
|
|
|
|
|
| namespace PlanarL1.Topology |
| open Set |
| variable {V : Type} [LinearOrder V] {G : SimpleGraph V} (P : PLDrawing G) |
| {p : V → ℂ} {B : Set V} {D : Set ℂ} (E : ExteriorPorts p P.point B D) |
|
|
| /-- The untouched raw carrier together with the actual exterior stubs. -/ |
| def stemCarrier (S : Set V) : Set ℂ := P.carrier S ∪ ⋃ v : S, E.region v.val |
|
|
| lemma stemCarrier_disjoint |
| (hcontact : ∀ v∈B, ∀ z∈E.region v, z∈P.carrier B → z=P.point v) |
| {S U : Set V} (hS : S⊆B) (hU : U⊆B) (hSU : Disjoint S U) : |
| Disjoint (stemCarrier P E S) (stemCarrier P E U) := by |
| have cross {S U : Set V} (hS : S⊆B) (hU : U⊆B) (hSU : Disjoint S U) : |
| Disjoint (P.carrier S) (⋃ v : U, E.region v.val) := by |
| rw [disjoint_left] |
| intro z hz hz' |
| obtain ⟨v,hv⟩ := mem_iUnion.mp hz' |
| have he := hcontact v.val (hU v.property) z hv (P.carrier_mono hS hz) |
| exact disjoint_left.mp hSU (P.point_carrier_iff.mp (he ▸ hz)) v.property |
| apply Disjoint.union_left |
| · exact Disjoint.union_right (P.carrier_disjoint hSU) (cross hS hU hSU) |
| · apply Disjoint.union_right (cross hU hS hSU.symm).symm |
| rw [disjoint_left] |
| intro z hz hz' |
| obtain ⟨v,hv⟩ := mem_iUnion.mp hz |
| obtain ⟨w,hw⟩ := mem_iUnion.mp hz' |
| exact disjoint_left.mp (E.disjoint v.val (hS v.property) w.val (hU w.property) |
| (fun he => disjoint_left.mp hSU v.property (he ▸ w.property))) hv hw |
|
|
| end PlanarL1.Topology |
|
|
| namespace PlanarL1.HeightTree |
| open Set PlanarL1.Topology |
| attribute [local instance] Classical.propDecidable |
| variable {V : Type} [Fintype V] [LinearOrder V] (T : HeightTree V) |
| {G : SimpleGraph V} (P : PLDrawing G) |
|
|
| /-- The literal planar leaf layout is constructed from a real raw drawing of |
| its tree and terminal matching. Neither a contour order nor a disk is assumed. -/ |
| lemma layout_of_drawing (P : PLDrawing G) (hG : T.graph ≤ G) (hroot : ¬T.IsLeaf T.root) |
| (M : SimpleGraph {v : V // T.IsLeaf v}) |
| (hMG : ∀ i j, M.Adj i j → G.Adj i.val j.val) |
| (hheight : ∀ i j, M.Adj i j → T.height i.val=T.height j.val) |
| (hmatch : ∀ i j k, M.Adj i j → M.Adj i k → j=k) : |
| ∃ (L : T.Layout (Fintype.card {v : V // T.IsLeaf v})), |
| ∀ i j, L.pair.Adj i j ↔ M.Adj ⟨L.leaf i,L.isLeaf i⟩ ⟨L.leaf j,L.isLeaf j⟩ := by |
| classical |
| obtain ⟨C,E,havoid,hcontact⟩ := T.tree_core P hG hroot |
| choose s hs using fun v : {v // T.IsLeaf v} => |
| (E.joined v.val v.property).exists_path (E.start v.val v.property) |
| choose r hr using fun i j (h : M.Adj i j) => |
| (P.region_joined i.val j.val (hMG i j h)).exists_path (P.region_start i.val j.val (hMG i j h)) |
| let A : ∀ i j, M.Adj i j → Path (C.drawing.point i.val) (C.drawing.point j.val) := |
| fun i j h => ((s i).trans (r i j h)).trans (s j).symm |
| have hS (i j : {v // T.IsLeaf v}) : ({i.val,j.val} : Set V) ⊆ {v | T.IsLeaf v} := by |
| intro v hv |
| rcases hv with rfl|hv |
| · exact i.property |
| · rw [mem_singleton_iff] at hv; exact hv ▸ j.property |
| have hArange (i j : {v // T.IsLeaf v}) (h : M.Adj i j) : |
| range (A i j h) ⊆ stemCarrier P E {i.val,j.val} := by |
| change range (((s i).trans (r i j h)).trans (s j).symm) ⊆ _ |
| rw [Path.trans_range,Path.trans_range,Path.symm_range] |
| refine union_subset (union_subset ?_ ?_) ?_ |
| · intro z hz; exact Or.inr (mem_iUnion.mpr ⟨⟨i.val,by simp⟩,hs i hz⟩) |
| · intro z hz; exact Or.inl (P.region_mem_carrier (by simp) (by simp) (hr i j h hz)) |
| · intro z hz; exact Or.inr (mem_iUnion.mpr ⟨⟨j.val,by simp⟩,hs j hz⟩) |
| have houtside (S : Set V) (hS : S⊆{v | T.IsLeaf v}) (z : ℂ) |
| (hz : z∈stemCarrier P E S) : z∉C.disk := by |
| intro hzD |
| rcases hz with hz|hz |
| · exact disjoint_left.mp havoid (subset_closure hzD) (P.carrier_mono hS hz) |
| · obtain ⟨v,hv⟩ := mem_iUnion.mp hz |
| have he := E.inside v.val (hS v.property) z hv (subset_closure hzD) |
| have hf := C.port v.val (hS v.property) |
| have hn : C.drawing.point v.val∉interior C.disk := hf.2 |
| exact hn (by rw [C.isOpen.interior_eq]; exact he ▸ hzD) |
| apply T.layout_of_core C M hheight hmatch A |
| · intro i j h t; exact houtside _ (hS i j) _ (hArange i j h (mem_range_self t)) |
| · intro i j h k l h' hik hil hjk hjl |
| have hSU : Disjoint ({i.val,j.val} : Set V) {k.val,l.val} := by |
| simp only [disjoint_left,mem_insert_iff,mem_singleton_iff] |
| intro v hv hv' |
| rcases hv with rfl|rfl <;> rcases hv' with he|he |
| · exact hik (Subtype.ext he) |
| · exact hil (Subtype.ext he) |
| · exact hjk (Subtype.ext he) |
| · exact hjl (Subtype.ext he) |
| exact (stemCarrier_disjoint P E hcontact (hS i j) (hS k l) hSU).mono |
| (hArange i j h) (hArange k l h') |
| |
| end PlanarL1.HeightTree |
| |
| |
| |
| |
| namespace PlanarL1.Topology.Drawing |
| open Set |
| variable {V : Type} [LinearOrder V] {G : SimpleGraph V} (D : Drawing G) |
|
|
| lemma forward_interior_meet (d e : ForwardDart G) {s t : unitInterval} |
| (hs : 0<(s:ℝ)) (hs' : (s:ℝ)<1) (ht : 0<(t:ℝ)) (ht' : (t:ℝ)<1) |
| (he : D.edge d.val.fst d.val.snd d.val.adj s=D.edge e.val.fst e.val.snd e.val.adj t) : |
| d=e ∧ s=t := by |
| have hd := ForwardDart.eq_of_endpoints d e (D.interior_disjoint _ _ _ _ _ _ s t hs hs' ht ht' he) |
| subst e |
| exact ⟨rfl,D.edge_injective _ _ _ he⟩ |
|
|
| namespace Split |
| attribute [local instance] Classical.propDecidable |
| variable (S : Set (ForwardDart G)) |
|
|
| abbrev Tip := S × Fin 2 |
| abbrev Node := V ⊕ Tip S |
| abbrev Piece := {d : ForwardDart G // d∉S} ⊕ (S × Fin 3) |
|
|
| noncomputable def tipTime (k : Fin 2) : unitInterval := ⟨((k.val:ℝ)+1)/3,by |
| constructor |
| · positivity |
| · have hk : (k.val:ℝ)<2 := by exact_mod_cast k.isLt |
| linarith⟩ |
|
|
| lemma tipTime_pos (k : Fin 2) : 0<(tipTime k:ℝ) := by dsimp [tipTime]; positivity |
| lemma tipTime_lt_one (k : Fin 2) : (tipTime k:ℝ)<1 := by |
| have hk : (k.val:ℝ)<2 := by exact_mod_cast k.isLt |
| dsimp [tipTime]; linarith |
| |
| noncomputable def point : Node S → ℂ |
| | .inl v => D.point v |
| | .inr (d,k) => D.edge d.val.val.fst d.val.val.snd d.val.val.adj (tipTime k) |
|
|
| lemma point_injective : Function.Injective (point D S) := by |
| intro a b he |
| cases a with |
| | inl a => cases b with |
| | inl b => exact congrArg Sum.inl (D.point_injective he) |
| | inr b => exact False.elim (D.interior_avoid _ _ _ _ a (tipTime_pos b.2) (tipTime_lt_one b.2) he.symm) |
| | inr a => cases b with |
| | inl b => exact False.elim (D.interior_avoid _ _ _ _ b (tipTime_pos a.2) (tipTime_lt_one a.2) he) |
| | inr b => |
| obtain ⟨hd,ht⟩ := D.forward_interior_meet a.1.val b.1.val |
| (tipTime_pos a.2) (tipTime_lt_one a.2) (tipTime_pos b.2) (tipTime_lt_one b.2) he |
| have hk : a.2=b.2 := by |
| apply Fin.ext |
| have hh := congrArg Subtype.val ht |
| change ((a.2.val:ℝ)+1)/3=((b.2.val:ℝ)+1)/3 at hh |
| exact_mod_cast (show (a.2.val:ℝ)=(b.2.val:ℝ) by linarith) |
| exact congrArg Sum.inr (Prod.ext (Subtype.ext hd) hk) |
|
|
| def meshNode (d : S) (r : Fin 4) : Node S := |
| if h0 : r.val=0 then .inl d.val.val.fst |
| else if h3 : r.val=3 then .inl d.val.val.snd |
| else .inr (d,⟨r.val-1,by omega⟩) |
|
|
| noncomputable def meshTime (r : Fin 4) : unitInterval := ⟨(r.val:ℝ)/3,by |
| constructor |
| · positivity |
| · have hr : (r.val:ℝ)<4 := by exact_mod_cast r.isLt |
| have hr' : r.val≤3 := by omega |
| have hr'' : (r.val:ℝ)≤3 := by exact_mod_cast hr' |
| linarith⟩ |
|
|
| lemma mesh_point (d : S) (r : Fin 4) : |
| point D S (meshNode S d r)=D.edge d.val.val.fst d.val.val.snd d.val.val.adj (meshTime r) := by |
| fin_cases r <;> norm_num [meshNode,point,meshTime,tipTime] |
| |
| noncomputable def label : Piece S → ForwardDart G |
| | .inl d => d.val |
| | .inr (d,_) => d.val |
|
|
| def src : Piece S → Node S |
| | .inl d => .inl d.val.val.fst |
| | .inr (d,k) => meshNode S d k.castSucc |
|
|
| def dst : Piece S → Node S |
| | .inl d => .inl d.val.val.snd |
| | .inr (d,k) => meshNode S d k.succ |
|
|
| noncomputable def first : Piece S → unitInterval |
| | .inl _ => 0 |
| | .inr (_,k) => meshTime k.castSucc |
|
|
| noncomputable def last : Piece S → unitInterval |
| | .inl _ => 1 |
| | .inr (_,k) => meshTime k.succ |
|
|
| lemma first_lt_last (p : Piece S) : (first S p:ℝ)<(last S p:ℝ) := by |
| cases p with |
| | inl p => exact zero_lt_one |
| | inr p => dsimp [first,last,meshTime]; push_cast; linarith |
| |
| lemma src_point (p : Piece S) : |
| point D S (src S p)=D.edge (label S p).val.fst (label S p).val.snd (label S p).val.adj (first S p) := by |
| cases p with |
| | inl p => exact (Path.source _).symm |
| | inr p => exact mesh_point D S p.1 p.2.castSucc |
|
|
| lemma dst_point (p : Piece S) : |
| point D S (dst S p)=D.edge (label S p).val.fst (label S p).val.snd (label S p).val.adj (last S p) := by |
| cases p with |
| | inl p => exact (Path.target _).symm |
| | inr p => exact mesh_point D S p.1 p.2.succ |
|
|
| lemma src_ne_dst (D : Drawing G) (p : Piece S) : src S p≠dst S p := by |
| intro he |
| have hp := congrArg (point D S) he |
| rw [src_point,dst_point] at hp |
| have ht := congrArg Subtype.val (D.edge_injective _ _ _ hp) |
| exact (ne_of_lt (first_lt_last S p)) ht |
|
|
| lemma interior_point_avoid (p : Piece S) {t : unitInterval} |
| (ht₀ : (first S p:ℝ)<(t:ℝ)) (ht₁ : (t:ℝ)<(last S p:ℝ)) (v : Node S) : |
| D.edge (label S p).val.fst (label S p).val.snd (label S p).val.adj t≠point D S v := by |
| have ht : 0<(t:ℝ) := lt_of_le_of_lt (first S p).property.1 ht₀ |
| have ht' : (t:ℝ)<1 := lt_of_lt_of_le ht₁ (last S p).property.2 |
| intro he |
| cases v with |
| | inl v => exact D.interior_avoid _ _ _ t v ht ht' he |
| | inr v => |
| obtain ⟨hd,htt⟩ := D.forward_interior_meet (label S p) v.1.val ht ht' |
| (tipTime_pos v.2) (tipTime_lt_one v.2) he |
| cases p with |
| | inl p => |
| change p.val=v.1.val at hd |
| exact p.property (hd.symm ▸ v.1.property) |
| | inr p => |
| rw [htt] at ht₀ ht₁ |
| change (p.2.val:ℝ)/3 < ((v.2.val:ℝ)+1)/3 at ht₀ |
| change ((v.2.val:ℝ)+1)/3 < ((p.2.val+1:ℕ):ℝ)/3 at ht₁ |
| have hlo : p.2.val<v.2.val+1 := by exact_mod_cast (show (p.2.val:ℝ)<(v.2.val:ℝ)+1 by linarith) |
| have hhi : v.2.val+1<p.2.val+1 := by |
| exact_mod_cast (show (v.2.val:ℝ)+1<(p.2.val:ℝ)+1 by push_cast at ht₁; linarith) |
| omega |
| |
| lemma interior_piece_unique (p q : Piece S) {s t : unitInterval} |
| (hs₀ : (first S p:ℝ)<(s:ℝ)) (hs₁ : (s:ℝ)<(last S p:ℝ)) |
| (ht₀ : (first S q:ℝ)<(t:ℝ)) (ht₁ : (t:ℝ)<(last S q:ℝ)) |
| (he : D.edge (label S p).val.fst (label S p).val.snd (label S p).val.adj s= |
| D.edge (label S q).val.fst (label S q).val.snd (label S q).val.adj t) : p=q := by |
| obtain ⟨hd,hst⟩ := D.forward_interior_meet (label S p) (label S q) |
| (lt_of_le_of_lt (first S p).property.1 hs₀) (lt_of_lt_of_le hs₁ (last S p).property.2) |
| (lt_of_le_of_lt (first S q).property.1 ht₀) (lt_of_lt_of_le ht₁ (last S q).property.2) he |
| subst t |
| cases p with |
| | inl p => cases q with |
| | inl q => exact congrArg Sum.inl (Subtype.ext hd) |
| | inr q => |
| change p.val=q.1.val at hd |
| exact False.elim (p.property (hd.symm ▸ q.1.property)) |
| | inr p => cases q with |
| | inl q => |
| change p.1.val=q.val at hd |
| exact False.elim (q.property (hd ▸ p.1.property)) |
| | inr q => |
| have hk : p.2=q.2 := by |
| apply Fin.ext |
| change (p.2.val:ℝ)/3 < (s:ℝ) at hs₀ |
| change (s:ℝ)<((p.2.val+1:ℕ):ℝ)/3 at hs₁ |
| change (q.2.val:ℝ)/3 < (s:ℝ) at ht₀ |
| change (s:ℝ)<((q.2.val+1:ℕ):ℝ)/3 at ht₁ |
| push_cast at hs₁ ht₁ |
| have hpq : p.2.val<q.2.val+1 := by exact_mod_cast (show (p.2.val:ℝ)<(q.2.val:ℝ)+1 by linarith) |
| have hqp : q.2.val<p.2.val+1 := by exact_mod_cast (show (q.2.val:ℝ)<(p.2.val:ℝ)+1 by linarith) |
| omega |
| exact congrArg Sum.inr (Prod.ext (Subtype.ext hd) hk) |
|
|
| end Split |
| end PlanarL1.Topology.Drawing |
|
|
|
|
|
|
| end |
|
|
| end OAI |
|
|
