| import OAI.Probability.FKMaps.NodeOrder |
| import OAI.Probability.FKMaps.RootedLaw |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open List Equiv Equiv.Perm |
| open scoped BigOperators |
| namespace FKCRT.Inventory.CoreTree |
| open MapCycles PermutationWedge |
| attribute [local instance] Classical.propDecidable |
|
|
| lemma nodeIndex_injective (t : CoreTree) : Function.Injective t.nodeIndex := by |
| induction t with |
| | leaf => intro v w _; exact @Subsingleton.elim PUnit _ v w |
| | branch c ts ih => |
| intro v w h |
| cases v with |
| | inl a => |
| cases w with |
| | inl b => exact congrArg Sum.inl (Subsingleton.elim _ _) |
| | inr w => simp only [nodeIndex] at h;omega |
| | inr v => |
| obtain ⟨i,v⟩ := v |
| cases w with |
| | inl a => simp only [nodeIndex] at h;omega |
| | inr w => |
| obtain ⟨j,w⟩ := w |
| have hij := le_antisymm (children_order c ts i j v w h.le) |
| (children_order c ts j i w v h.ge) |
| subst j |
| have hvw := ih i (show (ts i).nodeIndex v=(ts i).nodeIndex w by |
| simpa only [nodeIndex,Nat.add_left_cancel_iff] using h) |
| subst w |
| rfl |
|
|
| /-- The literal preorder indexing is an equivalence, including the root. -/ |
| def nodeEquiv (t : CoreTree) : t.Node ≃ Fin t.labels.length := |
| Equiv.ofBijective (fun v => ⟨t.nodeIndex v,t.nodeIndex_bound v⟩) |
| ⟨fun _ _ h => t.nodeIndex_injective (congrArg Fin.val h),fun i => by |
| obtain ⟨v,hv⟩ := t.nodeIndex_surjective i.isLt |
| exact ⟨v,Fin.ext hv⟩⟩ |
|
|
| def VertexConstant {A : Type*} (t : CoreTree) (f : t.Dart → A) : Prop := |
| ∀ a b,t.matching.distance a b=0 → f a=f b |
|
|
| lemma child_vertexConstant {A : Type*} (c : Core) (ts : Fin c.val.length → CoreTree) |
| (f : (branch c ts).Dart → A) (hf : (branch c ts).VertexConstant f) |
| (i : Fin c.val.length) : (ts i).VertexConstant (f ∘ childDart ts i) := by |
| intro a b hab |
| have hn : ts i≠leaf := by |
| intro h |
| have hh : Nonempty (ts i).Dart := ⟨a⟩ |
| rw [h] at hh |
| exact not_nonempty_empty hh |
| obtain ⟨r,L,_,hL⟩ := root_and_head (ts i) hn |
| apply hf |
| rw [child_internal_distance c ts i r a b L hL,hab] |
|
|
| lemma child_root_value {A : Type*} (c : Core) (ts : Fin c.val.length → CoreTree) |
| (f : (branch c ts).Dart → A) (hf : (branch c ts).VertexConstant f) |
| (i : Fin c.val.length) : |
| (((ts i).rootDart).map (f ∘ childDart ts i)).getD (f (coreDart ts (nextSlot c i)))= |
| f (coreDart ts (nextSlot c i)) := by |
| by_cases ht : ts i=leaf |
| · have hr : (ts i).rootDart=none := by rw [ht];rfl |
| rw [hr] |
| rfl |
| · obtain ⟨a,L,ha,hL⟩ := root_and_head (ts i) ht |
| rw [ha,Option.map_some,Option.getD_some] |
| apply hf |
| rw [(branch c ts).matching.distance_comm,child_distance_sum c ts i (nextSlot c i) a a L hL] |
| simp only [StackMatching.distance,SimpleGraph.edist_self,add_zero] |
|
|
| /-- Exact original degree incidence counting. The extra preorder root has |
| one additional root atom; no size-biased measure is postulated. -/ |
| theorem sum_poles {A : Type*} [AddCommMonoid A] (t : CoreTree) (f : t.Dart → A) |
| (hf : t.VertexConstant f) (r : A) : |
| (∑ v : t.Node,((t.pole v).map f).getD r)= |
| (t.rootDart.map f).getD r+∑ d : t.Dart,f d := by |
| induction t generalizing r with |
| | leaf => |
| change Empty → A at f |
| change (∑ _v : PUnit,r)=r+∑ d : Empty,f d |
| simp only [Fintype.sum_unique,Fintype.sum_empty,add_zero] |
| | branch c ts ih => |
| change (Fin c.val.length ⊕ (Σ i : Fin c.val.length,(ts i).Dart)) → A at f |
| change (∑ v : PUnit ⊕ (Σ i : Fin c.val.length,(ts i).Node),_)=_ |
| rw [Fintype.sum_sum_type,Fintype.sum_sigma] |
| simp only [Fintype.sum_unique,pole,rootDart] |
| have hx (i : Fin c.val.length) : |
| (∑ v : (ts i).Node,f (childPole c ts i v))= |
| f (coreDart ts (nextSlot c i))+∑ d : (ts i).Dart,f (childDart ts i d) := by |
| have hh := ih i (f ∘ childDart ts i) (child_vertexConstant c ts f hf i) |
| (f (coreDart ts (nextSlot c i))) |
| have hp (v : (ts i).Node) : f (childPole c ts i v)= |
| (((ts i).pole v).map (f ∘ childDart ts i)).getD (f (coreDart ts (nextSlot c i))) := by |
| unfold childPole |
| cases (ts i).pole v <;> rfl |
| simp_rw [hp] |
| exact hh.trans (congrArg (fun z => z+∑ d : (ts i).Dart,f (childDart ts i d)) |
| (child_root_value c ts f hf i)) |
| change f (coreDart ts c.entry)+(∑ i,∑ v,f (childPole c ts i v))= |
| f (coreDart ts c.entry)+∑ d : Fin c.val.length ⊕ (Σ i : Fin c.val.length,(ts i).Dart),f d |
| simp_rw [hx] |
| rw [Finset.sum_add_distrib,Fintype.sum_sum_type,Fintype.sum_sigma] |
| congr 1 |
| congr 1 |
| exact Equiv.sum_comp (List.finRange c.val.length).formPerm (f ∘ coreDart ts) |
|
|
| end FKCRT.Inventory.CoreTree |
| end |
|
|
|
|
| noncomputable section |
| open List Equiv Equiv.Perm |
| open scoped BigOperators ENNReal |
| namespace FKCRT.PermutationWedge |
| variable {α β : Type*} [Fintype α] [Fintype β] |
|
|
| /-- Exact quotient-graph relabelling for arbitrary finite dart carriers. -/ |
| def dartVertexEquiv (f : α ≃ β) {p : Perm α} {q : Perm β} |
| (hp : ∀ x,q (f x)=f (p x)) : Vertex p ≃ Vertex q := |
| Quotient.congr f (sameCycle_embedding f f.injective hp) |
|
|
| lemma dartVertexEquiv_apply (f : α ≃ β) {p : Perm α} {q : Perm β} |
| (hp : ∀ x,q (f x)=f (p x)) (x : α) : |
| dartVertexEquiv f hp (vertex p x)=vertex q (f x) := rfl |
|
|
| def dartGraphIso (f : α ≃ β) {p e : Perm α} {q a : Perm β} |
| (hp : ∀ x,q (f x)=f (p x)) (he : ∀ x,a (f x)=f (e x)) : |
| dartGraph e p ≃g dartGraph a q where |
| toEquiv := dartVertexEquiv f hp |
| map_rel_iff' := by |
| intro x y |
| constructor |
| · rintro ⟨hn,h⟩ |
| refine ⟨fun hh => hn (congrArg (dartVertexEquiv f hp) hh),?_⟩ |
| have go (x y : Vertex p) (d : β) |
| (hx : vertex q d=dartVertexEquiv f hp x) |
| (hy : vertex q (a d)=dartVertexEquiv f hp y) : |
| ∃ z,vertex p z=x ∧ vertex p (e z)=y := by |
| refine ⟨f.symm d,(dartVertexEquiv f hp).injective ?_,(dartVertexEquiv f hp).injective ?_⟩ |
| · simpa only [dartVertexEquiv_apply,Equiv.apply_symm_apply] using hx |
| · rw [dartVertexEquiv_apply,← he,Equiv.apply_symm_apply] |
| exact hy |
| rcases h with ⟨d,hx,hy⟩|⟨d,hy,hx⟩ |
| · exact Or.inl (go x y d hx hy) |
| · exact Or.inr (go y x d hy hx) |
| · rintro ⟨hn,h⟩ |
| refine ⟨fun hh => hn ((dartVertexEquiv f hp).injective hh),?_⟩ |
| have go (x y : Vertex p) (d : α) (hx : vertex p d=x) (hy : vertex p (e d)=y) : |
| ∃ z,vertex q z=dartVertexEquiv f hp x ∧ vertex q (a z)=dartVertexEquiv f hp y := by |
| refine ⟨f d,congrArg (dartVertexEquiv f hp) hx,?_⟩ |
| rw [he] |
| exact congrArg (dartVertexEquiv f hp) hy |
| rcases h with ⟨d,hx,hy⟩|⟨d,hy,hx⟩ |
| · exact Or.inl (go x y d hx hy) |
| · exact Or.inr (go y x d hy hx) |
|
|
| end FKCRT.PermutationWedge |
| namespace FKCRT |
| open Inventory MapCycles PermutationWedge |
| attribute [local instance] Classical.propDecidable |
|
|
| lemma dartGraph_eq_spanning {n : ℕ} (a s : Perm (Dart n)) : |
| dartGraph a s=spanningGraph a s Set.univ := by |
| ext x y |
| change (x≠y ∧ ((∃ d,orbit s d=x ∧ orbit s (a d)=y) ∨ |
| (∃ d,orbit s d=y ∧ orbit s (a d)=x))) ↔ _ |
| simp only [spanningGraph,SimpleGraph.fromRel_adj,Set.mem_univ,true_and] |
|
|
| /-- The canonical inverse word has the literal, uniquely determined stack |
| matching edge and vertex permutations. -/ |
| def matchingCanonical {n : ℕ} (w : SuccessfulWord n) |
| (D : StackMatching w.val (List.finRange (2*(n+1)))) : CanonicalTreeMap n where |
| a := turns (D.first++D.second) |
| s := (List.finRange (2*(n+1))).formPerm*turns D.first |
| A := matchingEdges D.first D.second |
| valid := matching_map_conditions D.first D.second D.first_arches D.second_arches D.covers |
| tour := by |
| have hn := D.covers.nodup_iff.mpr (List.nodup_finRange (2*(n+1))) |
| rw [partialReversal_matchingEdges D.first D.second hn,mul_assoc, |
| turns_self (by rw [endpoints_append] at hn;exact hn.of_append_left),mul_one] |
|
|
| lemma matchingCanonical_word {n : ℕ} (w : SuccessfulWord n) |
| (D : StackMatching w.val (List.finRange (2*(n+1)))) : |
| (matchingCanonical w D).word=w := by |
| apply Subtype.ext |
| exact matchingWord_of_matchings w.val D.first D.second D.first_arches D.second_arches |
| D.covers D.first_types D.second_types |
|
|
| lemma matchingCanonical_eq {n : ℕ} (w : SuccessfulWord n) |
| (D : StackMatching w.val (List.finRange (2*(n+1)))) : |
| matchingCanonical w D=(canonicalWordEquiv n).symm w := by |
| apply CanonicalTreeMap.word_injective |
| exact (matchingCanonical_word w D).trans ((canonicalWordEquiv n).apply_symm_apply w).symm |
|
|
| /-- The quotient representative used by the main statement is a genuine rooted |
| relabelling of the matching map, not merely a map with the same size or law. -/ |
| theorem matching_rooted_intertwine {n : ℕ} (w : SuccessfulWord n) |
| (D : StackMatching w.val (List.finRange (2*(n+1)))) : |
| let M := ((rootedWordEquiv n).symm w).1 |
| ∃ r : Perm (Dart n),r 0=0 ∧ (∀ d,reversal M (r d)=r (D.mate d)) ∧ |
| (∀ d,rotation M (r d)=r (((List.finRange (2*(n+1))).formPerm*turns D.first) d)) := by |
| dsimp only |
| let x := (rootedWordEquiv n).symm w |
| have hw : (rootedTreeNormal x).word=w := (rootedWordEquiv n).apply_symm_apply w |
| have hh : matchingCanonical w D=rootedTreeNormal x := |
| CanonicalTreeMap.word_injective ((matchingCanonical_word w D).trans hw.symm) |
| have hi := canonicalizeTree_iso x.1.out x.2.val x.2.property |
| change MapIso (rootedTreeNormal x).toMap x.1.out at hi |
| rw [← hh] at hi |
| exact hi |
|
|
| end FKCRT |
| end |
|
|
|
|
| noncomputable section |
| open List Equiv Equiv.Perm |
| namespace FKCRT.Inventory |
| open MapCycles PermutationWedge |
| attribute [local instance] Classical.propDecidable |
| variable {α : Type*} |
|
|
| def listDartEquiv (l : List α) (hn : l.Nodup) (hl : ∀ d,d∈l) {N : ℕ} |
| (hN : l.length=N) : Fin N ≃ α := |
| (finCongr hN.symm).trans (Equiv.ofBijective l.get |
| ⟨List.nodup_iff_injective_get.mp hn,fun d => by |
| obtain ⟨i,hi⟩ := List.mem_iff_get.mp (hl d) |
| exact ⟨i,hi⟩⟩) |
|
|
| lemma listDartEquiv_get (l : List α) (hn : l.Nodup) (hl : ∀ d,d∈l) {N : ℕ} |
| (hN : l.length=N) (i : Fin N) : |
| listDartEquiv l hn hl hN i=l[i.val]'(by omega) := rfl |
|
|
| lemma listDartEquiv_list (l : List α) (hn : l.Nodup) (hl : ∀ d,d∈l) {N : ℕ} |
| (hN : l.length=N) : (List.finRange N).map (listDartEquiv l hn hl hN)=l := by |
| apply List.ext_getElem |
| · simp [hN] |
| · intro i hi hi' |
| simp only [List.getElem_map,List.getElem_finRange,listDartEquiv_get,Fin.val_cast] |
|
|
| lemma listDartEquiv_labels (l : List α) (hn : l.Nodup) (hl : ∀ d,d∈l) {N : ℕ} |
| (hN : l.length=N) (v : α → TypedLetter) (w : Fin N → TypedLetter) |
| (hw : l.map v=List.ofFn w) (i : Fin N) : v (listDartEquiv l hn hl hN i)=w i := by |
| have hi : i.val<l.length := by omega |
| have hi' : i.val<(l.map v).length := by simpa using hi |
| have h := congrArg (fun a : List TypedLetter => a[i.val]?) hw |
| simpa only [List.getElem?_eq_getElem hi',List.getElem_map, |
| List.getElem?_eq_getElem (show i.val<(List.ofFn w).length by simp),List.getElem_ofFn, |
| Option.some.injEq,← listDartEquiv_get l hn hl hN i] using h |
|
|
| variable [DecidableEq α] |
|
|
| /-- Literal finite-word normalization simultaneously intertwines edge and |
| vertex permutations of the original multigraph. -/ |
| theorem StackMatching.word_intertwine {v : α → TypedLetter} {l : List α} |
| (M : StackMatching v l) (hn : l.Nodup) (hl : ∀ d,d∈l) {n : ℕ} |
| (w : FKCRT.SuccessfulWord n) (hw : l.map v=List.ofFn w.val) |
| (D : StackMatching w.val (List.finRange (2*(n+1)))) : |
| ∃ e : FKCRT.Dart n ≃ α, |
| (∀ i,M.mate (e i)=e (D.mate i)) ∧ |
| (∀ i,(l.formPerm*turns M.first) (e i)= |
| e (((List.finRange (2*(n+1))).formPerm*turns D.first) i)) := by |
| have hN : l.length=2*(n+1) := by |
| have h := congrArg List.length hw |
| simpa only [List.length_map,List.length_ofFn] using h |
| let e := listDartEquiv l hn hl hN |
| have he : (List.finRange (2*(n+1))).map e=l := listDartEquiv_list l hn hl hN |
| have hv (i : FKCRT.Dart n) (_hi : i∈List.finRange (2*(n+1))) : v (e i)=w.val i := |
| listDartEquiv_labels l hn hl hN v w.val hw i |
| let Q := D.map e v hv |
| let R : StackMatching v l := he ▸ Q |
| have hm : M.mate=Q.mate := (M.unique_mate R hn).trans (Q.cast_mate he) |
| have hf : turns M.first=turns Q.first := (M.unique_first R hn).trans |
| (congrArg turns (Q.cast_first he)) |
| refine ⟨e,?_,?_⟩ |
| · intro i |
| rw [hm] |
| exact D.map_mate (List.nodup_finRange _) e e.injective v hv i (List.mem_finRange i) |
| · intro i |
| change l.formPerm (turns M.first (e i))=e ((List.finRange _).formPerm (turns D.first i)) |
| rw [hf,D.map_first (List.nodup_finRange _) e e.injective v hv] |
| rw [← he] |
| exact formPerm_map_on _ (List.nodup_finRange _) e e.injective _ (List.mem_finRange _) |
|
|
| end FKCRT.Inventory |
| end |
|
|
|
|
| noncomputable section |
| open List Equiv Equiv.Perm |
| namespace FKCRT.Inventory.CoreTree |
| open MapCycles PermutationWedge |
| attribute [local instance] Classical.propDecidable |
|
|
| /-- The actual FK representative and the recursively glued literal map are |
| isomorphic on their original darts, simultaneously for edges and vertices. -/ |
| theorem realized_intertwine (t : CoreTree) {n : ℕ} (w : FKCRT.SuccessfulWord n) |
| (hw : t.word=List.ofFn w.val) : |
| let M := ((FKCRT.rootedWordEquiv n).symm w).1 |
| ∃ e : t.Dart ≃ FKCRT.Dart n, |
| (∀ d,FKCRT.reversal M (e d)=e (t.matching.mate d)) ∧ |
| (∀ d,FKCRT.rotation M (e d)=e ((t.darts.formPerm*turns t.matching.first) d)) := by |
| let D := StackMatching.ofEmpty (w := w.val) (l := List.finRange (2*(n+1))) |
| (by simpa only [← List.ofFn_eq_map] using w.property) |
| obtain ⟨e,he,hp⟩ := t.matching.word_intertwine t.darts_nodup t.darts_mem w |
| (t.darts_word.trans hw) D |
| obtain ⟨r,_hr,hrE,hrV⟩ := FKCRT.matching_rooted_intertwine w D |
| refine ⟨e.symm.trans r,?_,?_⟩ |
| · intro d |
| change FKCRT.reversal _ (r (e.symm d))=r (e.symm (t.matching.mate d)) |
| rw [hrE] |
| apply congrArg r |
| apply e.injective |
| simpa only [Equiv.apply_symm_apply] using (he (e.symm d)).symm |
| · intro d |
| change FKCRT.rotation _ (r (e.symm d))=r (e.symm ((t.darts.formPerm*turns t.matching.first) d)) |
| rw [hrV] |
| apply congrArg r |
| apply e.injective |
| simpa only [Equiv.apply_symm_apply] using (hp (e.symm d)).symm |
|
|
| /-- Original all-edge graph distances are preserved exactly by the finite |
| word/core realization; no block metric is substituted. -/ |
| theorem realized_distance (t : CoreTree) {n : ℕ} (w : FKCRT.SuccessfulWord n) |
| (hw : t.word=List.ofFn w.val) : |
| let M := ((FKCRT.rootedWordEquiv n).symm w).1 |
| ∃ e : t.Dart ≃ FKCRT.Dart n,∀ a b, |
| ((FKCRT.graph M Set.univ).dist (orbit (FKCRT.rotation M) (e a)) |
| (orbit (FKCRT.rotation M) (e b)):ℝ)=t.realDistance a b := by |
| obtain ⟨e,he,hp⟩ := t.realized_intertwine w hw |
| refine ⟨e,fun a b => ?_⟩ |
| have hh := dartGraph_embedding_edist e e.injective hp he a b |
| rw [FKCRT.dartGraph_eq_spanning] at hh |
| change (FKCRT.graph _ Set.univ).edist _ _=t.matching.distance a b at hh |
| change (FKCRT.graph ((FKCRT.rootedWordEquiv n).symm w).1 Set.univ).edist |
| (orbit (FKCRT.rotation _) (e a)) (orbit (FKCRT.rotation _) (e b))=t.matching.distance a b at hh |
| rw [t.distance_eq_nat a b] at hh |
| have hr : (FKCRT.graph ((FKCRT.rootedWordEquiv n).symm w).1 Set.univ).Reachable |
| (orbit (FKCRT.rotation _) (e a)) (orbit (FKCRT.rotation _) (e b)) := by |
| apply SimpleGraph.edist_ne_top_iff_reachable.mp |
| rw [hh] |
| exact ENat.natCast_ne_top _ |
| rw [← SimpleGraph.Reachable.coe_dist_eq_edist hr] at hh |
| dsimp only [realDistance] |
| exact_mod_cast hh |
|
|
| end FKCRT.Inventory.CoreTree |
| end |
|
|
|
|
| noncomputable section |
| open List Equiv Equiv.Perm |
| open scoped BigOperators |
| namespace FKCRT.Inventory.CoreTree |
| open MapCycles PermutationWedge |
| attribute [local instance] Classical.propDecidable |
|
|
| lemma pole_root (t : CoreTree) : t.pole t.root=t.rootDart := by cases t <;> rfl |
|
|
| /-- Preorder nodes indexed at the true total word length. -/ |
| def wordNodeEquiv (t : CoreTree) : t.Node ≃ Fin (t.word.length+1) := |
| t.nodeEquiv.trans (finCongr t.labels_length) |
|
|
| lemma wordNodeEquiv_root (t : CoreTree) : t.wordNodeEquiv t.root=0 := by |
| apply Fin.ext |
| exact t.nodeIndex_root |
|
|
| /-- Dropping precisely the preorder root leaves the exact multiset of all |
| original dart vertices. This is the degree measure's incidence identity. -/ |
| theorem sum_nonroot_poles {A : Type*} [AddCancelCommMonoid A] |
| (t : CoreTree) (f : t.Dart → A) (hf : t.VertexConstant f) (r : A) : |
| (∑ i : Fin t.word.length,((t.pole (t.wordNodeEquiv.symm i.succ)).map f).getD r)= |
| ∑ d : t.Dart,f d := by |
| have hh := t.sum_poles f hf r |
| have hs := t.wordNodeEquiv.symm.sum_comp (fun v => ((t.pole v).map f).getD r) |
| rw [Fin.sum_univ_succ] at hs |
| have hr : t.wordNodeEquiv.symm 0=t.root := |
| t.wordNodeEquiv.symm_apply_eq.mpr t.wordNodeEquiv_root.symm |
| rw [hr,t.pole_root] at hs |
| exact add_left_cancel (hs.trans hh) |
|
|
| lemma vertexConstant_of_intertwine {A : Type*} (t : CoreTree) {n : ℕ} |
| (M : FKCRT.RootedMap n) (e : t.Dart ≃ FKCRT.Dart n) |
| (hp : ∀ d,FKCRT.rotation M (e d)=e ((t.darts.formPerm*turns t.matching.first) d)) |
| (f : FKCRT.Vertex M → A) : |
| t.VertexConstant (fun d => f (orbit (FKCRT.rotation M) (e d))) := by |
| intro a b hab |
| change (dartGraph t.matching.mate (t.darts.formPerm*turns t.matching.first)).edist |
| (vertex _ a) (vertex _ b)=0 at hab |
| have hh := SimpleGraph.edist_eq_zero_iff.mp hab |
| exact congrArg (f ∘ dartVertexEquiv e hp) hh |
|
|
| end FKCRT.Inventory.CoreTree |
| end |
|
|
|
|
| noncomputable section |
| open List Equiv Equiv.Perm MeasureTheory |
| open scoped BigOperators ENNReal |
| namespace FKCRT.Inventory.CoreTree |
| open MapCycles PermutationWedge |
| attribute [local instance] Classical.propDecidable |
|
|
| def realizedPole (t : CoreTree) {n : ℕ} (M : FKCRT.RootedMap n) |
| (e : t.Dart ≃ FKCRT.Dart n) (v : t.Node) : FKCRT.Vertex M := |
| ((t.pole v).map (fun d => orbit (FKCRT.rotation M) (e d))).getD (orbit (FKCRT.rotation M) 0) |
|
|
| def nonrootVertex (t : CoreTree) {n : ℕ} (M : FKCRT.RootedMap n) |
| (e : t.Dart ≃ FKCRT.Dart n) (i : Fin t.word.length) : FKCRT.Vertex M := |
| t.realizedPole M e (t.wordNodeEquiv.symm i.succ) |
|
|
| lemma realizedPole_some (t : CoreTree) {n : ℕ} (M : FKCRT.RootedMap n) |
| (e : t.Dart ≃ FKCRT.Dart n) (v : t.Node) (a : t.Dart) (ha : t.pole v=some a) : |
| t.realizedPole M e v=orbit (FKCRT.rotation M) (e a) := by |
| simp only [realizedPole,ha,Option.map_some,Option.getD_some] |
|
|
| /-- Exact uniform nonroot-preorder mass equals original uniform dart mass. |
| The finite root atom is cancelled, not ignored asymptotically. -/ |
| theorem nonroot_dirac_eq (t : CoreTree) {n : ℕ} (M : FKCRT.RootedMap n) |
| (e : t.Dart ≃ FKCRT.Dart n) |
| (hp : ∀ d,FKCRT.rotation M (e d)=e ((t.darts.formPerm*turns t.matching.first) d)) : |
| let : MeasurableSpace (FKCRT.Vertex M) := ⊤ |
| (∑ i : Fin t.word.length,Measure.dirac (t.nonrootVertex M e i))= |
| ∑ d : FKCRT.Dart n,Measure.dirac (orbit (FKCRT.rotation M) d) := by |
| let : MeasurableSpace (FKCRT.Vertex M) := ⊤ |
| let r := orbit (FKCRT.rotation M) 0 |
| let f := fun d : t.Dart => Measure.dirac (orbit (FKCRT.rotation M) (e d)) |
| have hf : t.VertexConstant f := t.vertexConstant_of_intertwine M e hp Measure.dirac |
| have hh := t.sum_poles f hf (Measure.dirac r) |
| have hs := t.wordNodeEquiv.symm.sum_comp (fun v => ((t.pole v).map f).getD (Measure.dirac r)) |
| rw [Fin.sum_univ_succ] at hs |
| have hr : t.wordNodeEquiv.symm 0=t.root := |
| t.wordNodeEquiv.symm_apply_eq.mpr t.wordNodeEquiv_root.symm |
| rw [hr,t.pole_root] at hs |
| have hz := hs.trans hh |
| have hv (v : t.Node) : ((t.pole v).map f).getD (Measure.dirac r)= |
| Measure.dirac (t.realizedPole M e v) := by |
| dsimp [realizedPole] |
| cases t.pole v <;> rfl |
| have hroot : (t.rootDart.map f).getD (Measure.dirac r)=Measure.dirac (t.realizedPole M e t.root) := by |
| rw [← t.pole_root] |
| exact hv t.root |
| rw [hroot] at hz |
| simp_rw [hv] at hz |
| have hsum : (∑ d : t.Dart,f d)=∑ d : FKCRT.Dart n,Measure.dirac (orbit (FKCRT.rotation M) d) := |
| e.sum_comp (fun d => Measure.dirac (orbit (FKCRT.rotation M) d)) |
| rw [hsum] at hz |
| apply Measure.ext |
| intro s hs |
| have hh' := congrArg (fun μ : Measure (FKCRT.Vertex M) => μ s) hz |
| simp only [Measure.add_apply] at hh' |
| apply (ENNReal.add_left_inj (measure_ne_top (Measure.dirac (t.realizedPole M e t.root)) s)).mp |
| simpa only [add_comm,nonrootVertex] using hh' |
|
|
| /-- Every original vertex is reached by a nonroot pole, even in the presence |
| of loops and coincident poles. -/ |
| theorem nonrootVertex_surjective (t : CoreTree) {n : ℕ} (M : FKCRT.RootedMap n) |
| (e : t.Dart ≃ FKCRT.Dart n) |
| (hp : ∀ d,FKCRT.rotation M (e d)=e ((t.darts.formPerm*turns t.matching.first) d)) : |
| Function.Surjective (t.nonrootVertex M e) := by |
| intro v |
| classical |
| by_contra h |
| have hn : ∀ i,t.nonrootVertex M e i≠v := by simpa only [not_exists] using h |
| let : MeasurableSpace (FKCRT.Vertex M) := ⊤ |
| have hm := congrArg (fun μ : Measure (FKCRT.Vertex M) => μ {v}) (t.nonroot_dirac_eq M e hp) |
| have hz : (∑ i : Fin t.word.length,Measure.dirac (t.nonrootVertex M e i)) {v}=0 := by |
| simp only [Measure.finsetSum_apply,Measure.dirac_apply' _ (MeasurableSet.singleton v), |
| Set.indicator_apply,Set.mem_singleton_iff] |
| simp [hn] |
| rw [hz] at hm |
| obtain ⟨d,hd⟩ := Quotient.mk_surjective v |
| have hh : (1:ℝ≥0∞)≤(∑ a : FKCRT.Dart n,Measure.dirac (orbit (FKCRT.rotation M) a)) {v} := by |
| rw [Measure.finsetSum_apply] |
| calc |
| 1=Measure.dirac (orbit (FKCRT.rotation M) d) {v} := by |
| rw [show orbit (FKCRT.rotation M) d=v from hd] |
| simp |
| _≤∑ a : FKCRT.Dart n,Measure.dirac (orbit (FKCRT.rotation M) a) {v} := |
| Finset.single_le_sum (f := fun a : FKCRT.Dart n => |
| Measure.dirac (orbit (FKCRT.rotation M) a) {v}) |
| (fun _ _ => by positivity) (Finset.mem_univ d) |
| rw [← hm] at hh |
| exact not_le_of_gt zero_lt_one hh |
|
|
| end FKCRT.Inventory.CoreTree |
| end |
|
|
| end OAI |
|
|
