| import OAI.Probability.FKMaps.InventoryDrift |
| import OAI.Probability.FKMaps.Matching |
| import OAI.Probability.FKMaps.TourActivity |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open List Equiv Equiv.Perm |
| attribute [local instance] Classical.propDecidable |
| namespace FKCRT |
| open MapCycles Chords |
| variable {n : ℕ} |
|
|
| lemma sameCycle_edge_out (a p : Perm (Dart n)) (ha : Function.Involutive a) (y : Dart n) : |
| p.SameCycle (orbit a y).out (a (orbit a y).out) ↔ p.SameCycle y (a y) := by |
| rcases (MapFinite.mk_eq_iff_involution a ha y (orbit a y)).mp rfl with hh|hh |
| · conv_rhs => rw [hh] |
| · conv_rhs => rw [hh,ha] |
| exact ⟨SameCycle.symm,SameCycle.symm⟩ |
|
|
| lemma orbit_opener_injective (a : Perm (Dart n)) (ha : Function.Involutive a) : |
| Function.Injective (fun x : Opener a => orbit a x.val) := by |
| intro x y hh |
| rcases (MapFinite.sameCycle_involution a ha x.val y.val).mp (Quotient.exact hh) with hh|hh |
| · exact Subtype.ext hh.symm |
| · have hx := x.property |
| have hy := y.property |
| rw [hh,ha] at hy |
| exact False.elim ((not_lt_of_ge hx.le) hy) |
|
|
| /-- Exact fundamental-cut incidence for a selected tree edge in canonical |
| rooted tour order. All representative choices have been removed. -/ |
| theorem fundamentalCross_tree_chord (a s : Perm (Dart n)) (ha : Function.Involutive a) |
| (T : Finset (Orbit a)) (hT : Multiforest a s T) |
| (ht : s*partialReversal a ha T=(List.finRange (2*(n+1))).formPerm) |
| (x y : Opener a) (hx : orbit a x.val∈T) (hne : x≠y) : |
| FundamentalCross a s T (orbit a x.val) (orbit a y.val) ↔ Cross a x y := by |
| have hneq : orbit a x.val≠orbit a y.val := fun h => hne (orbit_opener_injective a ha h) |
| rw [fundamentalCross_tour_cut a s ha T hT hx hneq,ht,edgeSwap_eq a ha x.val, |
| sameCycle_edge_out a _ ha y.val] |
| obtain ⟨h1,h2,h3,h4⟩ := opener_endpoints_ne a ha y x hne.symm |
| rw [ordered_tour_cut _ (List.pairwise_lt_finRange _) List.mem_finRange x.val (a x.val) |
| x.property y.val (a y.val) h1 h2 h3 h4] |
| have hx' := x.property |
| have hy' := y.property |
| have hv1 := Fin.val_ne_of_ne h1 |
| have hv2 := Fin.val_ne_of_ne h2 |
| have hv3 := Fin.val_ne_of_ne h3 |
| have hv4 := Fin.val_ne_of_ne h4 |
| unfold Cross |
| simp only [Fin.lt_def] at hx' hy' ⊢ |
| omega |
|
|
| /-- In a genuine planar two-colour canonical tour, fundamental incidence is |
| exactly alternating chords. The dual maximal-orbit condition excludes |
| crossings between two non-tree edges. -/ |
| theorem fundamentalCross_iff_chord (a s : Perm (Dart n)) (ha : Function.Involutive a) |
| (T : Finset (Orbit a)) (hT : Multiforest a s T) |
| (ht : s*partialReversal a ha T=(List.finRange (2*(n+1))).formPerm) |
| (hdual : Nat.card (Orbit (partialReversal a ha Tᶜ*(List.finRange (2*(n+1))).formPerm))= |
| Nat.card (Orbit (List.finRange (2*(n+1))).formPerm)+Tᶜ.card) |
| (x y : Opener a) (hne : x≠y) : |
| FundamentalCross a s T (orbit a x.val) (orbit a y.val) ↔ Cross a x y := by |
| by_cases hx : orbit a x.val∈T |
| · exact fundamentalCross_tree_chord a s ha T hT ht x y hx hne |
| by_cases hy : orbit a y.val∈T |
| · rw [fundamentalCross_symm] |
| exact (fundamentalCross_tree_chord a s ha T hT ht y x hy hne.symm).trans or_comm |
| have hnc : ¬Cross a x y := by |
| rintro (hh|hh) |
| · exact ordered_no_crossing a ha _ (List.pairwise_lt_finRange _) List.mem_finRange Tᶜ hdual |
| x.val y.val (Finset.mem_compl.mpr hx) (Finset.mem_compl.mpr hy) hh.1 hh.2.1 hh.2.2 |
| · exact ordered_no_crossing a ha _ (List.pairwise_lt_finRange _) List.mem_finRange Tᶜ hdual |
| y.val x.val (Finset.mem_compl.mpr hy) (Finset.mem_compl.mpr hx) hh.1 hh.2.1 hh.2.2 |
| simp only [FundamentalCross,hx,hy,false_and,or_self,hnc] |
|
|
| end FKCRT |
| end |
|
|
|
|
| noncomputable section |
| open Equiv Equiv.Perm |
| attribute [local instance] Classical.propDecidable |
| namespace FKCRT |
| variable {n : ℕ} |
|
|
| def relabelPerm (r p : Perm (Dart n)) : Perm (Dart n) := r⁻¹*p*r |
|
|
| lemma relabelPerm_apply (r p : Perm (Dart n)) (d : Dart n) : |
| relabelPerm r p d=r.symm (p (r d)) := rfl |
|
|
| lemma relabelPerm_mul (r p q : Perm (Dart n)) : |
| relabelPerm r (p*q)=relabelPerm r p*relabelPerm r q := by unfold relabelPerm; group |
| |
| lemma relabelPerm_involutive (r a : Perm (Dart n)) (ha : Function.Involutive a) : |
| Function.Involutive (relabelPerm r a) := by |
| intro d |
| simp only [relabelPerm_apply,Equiv.apply_symm_apply] |
| rw [ha,Equiv.symm_apply_apply] |
|
|
| lemma relabelPerm_no_fixed (r a : Perm (Dart n)) (hf : ∀ d,a d≠d) : |
| ∀ d,relabelPerm r a d≠d := by |
| intro d h |
| have hh := congrArg r h |
| exact hf (r d) (by simpa only [relabelPerm_apply,Equiv.apply_symm_apply] using hh) |
|
|
| def relabelOrbit (r p : Perm (Dart n)) : Orbit (relabelPerm r p) ≃ Orbit p := |
| Quotient.congr r (by |
| intro d e |
| change (r⁻¹*p*r).SameCycle d e ↔ p.SameCycle (r d) (r e) |
| simpa only [inv_inv] using (sameCycle_conj (g := r⁻¹) (f := p) (x := d) (y := e))) |
|
|
| @[simp] lemma relabelOrbit_apply (r p : Perm (Dart n)) (d : Dart n) : |
| relabelOrbit r p (orbit (relabelPerm r p) d)=orbit p (r d) := rfl |
|
|
| lemma card_orbit_relabel (r p : Perm (Dart n)) : |
| Nat.card (Orbit (relabelPerm r p))=Nat.card (Orbit p) := Nat.card_congr (relabelOrbit r p) |
|
|
| def relabelEdges (r a : Perm (Dart n)) (A : Finset (Orbit a)) : Finset (Orbit (relabelPerm r a)) := |
| A.map (relabelOrbit r a).symm.toEmbedding |
|
|
| @[simp] lemma mem_relabelEdges (r a : Perm (Dart n)) (A : Finset (Orbit a)) |
| (e : Orbit (relabelPerm r a)) : e∈relabelEdges r a A ↔ relabelOrbit r a e∈A := by |
| simp [relabelEdges] |
|
|
| @[simp] lemma card_relabelEdges (r a : Perm (Dart n)) (A : Finset (Orbit a)) : |
| (relabelEdges r a A).card=A.card := Finset.card_map _ |
|
|
| lemma relabelEdges_compl (r a : Perm (Dart n)) (A : Finset (Orbit a)) : |
| relabelEdges r a Aᶜ=(relabelEdges r a A)ᶜ := by ext e; simp |
| |
| lemma partialReversal_relabel (r a : Perm (Dart n)) (ha : Function.Involutive a) |
| (A : Finset (Orbit a)) : |
| partialReversal (relabelPerm r a) (relabelPerm_involutive r a ha) (relabelEdges r a A)= |
| relabelPerm r (partialReversal a ha A) := by |
| apply Equiv.ext |
| intro d |
| simp only [partialReversal_apply,mem_relabelEdges,relabelOrbit_apply,relabelPerm_apply] |
| split_ifs <;> simp |
| |
| lemma tourNumbering_relabel (p : Perm (Dart n)) (hp : ∀ d e,p.SameCycle d e) : |
| relabelPerm (tourNumbering p hp) p=finRotate (2*(n+1)) := by |
| apply Equiv.ext |
| intro i |
| apply (tourNumbering p hp).injective |
| simpa only [relabelPerm_apply,Equiv.apply_symm_apply] using (tourNumbering_successor p hp i).symm |
|
|
| end FKCRT |
| end |
|
|
|
|
| noncomputable section |
| open List Equiv Equiv.Perm |
| attribute [local instance] Classical.propDecidable |
| namespace FKCRT |
| open MapCycles Inventory |
| variable {n : ℕ} |
|
|
| lemma formPerm_finRange_eq_rotate : |
| (List.finRange (2*(n+1))).formPerm=finRotate (2*(n+1)) := by |
| apply Equiv.ext |
| intro i |
| have hh := List.formPerm_apply_getElem (List.finRange (2*(n+1))) (List.nodup_finRange _) i.val |
| (by simp) |
| simpa [finRotate_apply,Fin.ext_iff,Fin.val_add] using hh |
|
|
| /-- Every genuine rooted planar map/tree tour has a successful identified |
| inventory word. Its stack inverse is root-isomorphic to the initial map, |
| with both permutation identities (and hence the cyclic seam) literal. -/ |
| theorem map_tour_identified_word (M : LabelledMap n) (A : Finset (Orbit M.val.1)) |
| (ht : ∀ d e,(M.val.2*partialReversal M.val.1 M.property.1 A).SameCycle d e) : |
| ∃ (r : Perm (Dart n)) (w : Dart n→TypedLetter) (E F : List (Dart n×Dart n)), |
| r 0=0 ∧ stackTypedRun ((List.finRange (2*(n+1))).map w) []=some [] ∧ |
| Arches (List.finRange (2*(n+1))) E ∧ Arches (List.finRange (2*(n+1))) F ∧ |
| (endpoints (E++F)).Perm (List.finRange (2*(n+1))) ∧ |
| (∀ e∈E,w e.1=.burger true ∧ w e.2=.order true) ∧ |
| (∀ e∈F,w e.1=.burger false ∧ w e.2=.order false) ∧ |
| (∀ d,M.val.1 (r d)=r (turns (E++F) d)) ∧ |
| (∀ d,M.val.2 (r d)=r (((List.finRange (2*(n+1))).formPerm*turns E) d)) := by |
| let a := M.val.1 |
| let s := M.val.2 |
| let t := s*partialReversal a M.property.1 A |
| let r := tourNumbering t ht |
| let a' := relabelPerm r a |
| let A' := relabelEdges r a A |
| have ha' := relabelPerm_involutive r a M.property.1 |
| have hf' := relabelPerm_no_fixed r a M.property.2.1 |
| have ht' : relabelPerm r t=(List.finRange (2*(n+1))).formPerm := by |
| rw [formPerm_finRange_eq_rotate] |
| exact tourNumbering_relabel t ht |
| have hpart : partialReversal a' ha' A'=relabelPerm r (partialReversal a M.property.1 A) := |
| partialReversal_relabel r a M.property.1 A |
| have hpartc : partialReversal a' ha' A'ᶜ=relabelPerm r (partialReversal a M.property.1 Aᶜ) := by |
| change partialReversal (relabelPerm r a) ha' (relabelEdges r a A)ᶜ=_ |
| rw [← relabelEdges_compl,partialReversal_relabel] |
| have hct : Nat.card (Orbit t)=1 := (card_orbit_eq_one_iff _).mpr ht |
| have he : Nat.card (Orbit (partialReversal a' ha' A'*(List.finRange (2*(n+1))).formPerm))= |
| Nat.card (Orbit (List.finRange (2*(n+1))).formPerm)+A'.card := by |
| rw [hpart,← ht',← relabelPerm_mul,card_orbit_relabel,card_orbit_relabel,card_relabelEdges] |
| rw [card_orbit_mul_comm] |
| change Nat.card (Orbit ((s*partialReversal a M.property.1 A)*partialReversal a M.property.1 A))=_ |
| rw [reconstructed_tour,hct] |
| exact (tour_edge_card M A ht).trans (Nat.add_comm _ _) |
| have hf : Nat.card (Orbit (partialReversal a' ha' A'ᶜ*(List.finRange (2*(n+1))).formPerm))= |
| Nat.card (Orbit (List.finRange (2*(n+1))).formPerm)+A'ᶜ.card := by |
| rw [hpartc,← ht',← relabelPerm_mul,card_orbit_relabel,card_orbit_relabel, |
| ← relabelEdges_compl,card_relabelEdges] |
| rw [card_orbit_mul_comm] |
| have hc := planar_tour_compl_card M A ht |
| have hface := reconstructed_face a t M.property.1 A |
| have hrec : t*partialReversal a M.property.1 A=s := reconstructed_tour a s M.property.1 A |
| rw [hrec] at hface |
| rw [← hface,hct] |
| exact hc.trans (Nat.add_comm _ _) |
| obtain ⟨hw,E,F,hE,hF,hcov,hwE,hwF,hpair,hpart'⟩ := maximal_matching_word a' ha' hf' A' he hf |
| refine ⟨r,matchingWord a' A',E,F,tourNumbering_zero t ht,hw,hE,hF,hcov,hwE,hwF,?_,?_⟩ |
| · intro d |
| rw [hpair] |
| exact (r.apply_symm_apply _).symm |
| · intro d |
| rw [hpart',hpart,← ht',← relabelPerm_mul] |
| have hrec : t*partialReversal a M.property.1 A=s := reconstructed_tour a s M.property.1 A |
| rw [hrec] |
| exact (r.apply_symm_apply _).symm |
|
|
| end FKCRT |
| end |
|
|
|
|
| noncomputable section |
| open List Equiv Equiv.Perm |
| open scoped BigOperators |
| attribute [local instance] Classical.propDecidable |
| namespace FKCRT |
| open MapCycles Chords Inventory |
| variable {n : ℕ} |
|
|
| lemma opener_orbit_surjective (a : Perm (Dart n)) (ha : Function.Involutive a) |
| (hf : ∀ d,a d≠d) : Function.Surjective (fun x : Opener a => orbit a x.val) := by |
| intro e |
| by_cases h : e.out < a e.out |
| · exact ⟨⟨e.out,h⟩,Quotient.out_eq e⟩ |
| · refine ⟨⟨a e.out,?_⟩,?_⟩ |
| · rw [ha] |
| exact lt_of_le_of_ne (le_of_not_gt h) (hf e.out) |
| · change orbit a (a e.out)=e |
| rw [orbit_perm] |
| exact Quotient.out_eq e |
|
|
| def openerOrbitEquiv (a : Perm (Dart n)) (ha : Function.Involutive a) (hf : ∀ d,a d≠d) : |
| Opener a ≃ Orbit a := Equiv.ofBijective _ ⟨orbit_opener_injective a ha,opener_orbit_surjective a ha hf⟩ |
|
|
| lemma canonical_tourNumbering (p : Perm (Dart n)) (hp : ∀ d e,p.SameCycle d e) |
| (he : p=(List.finRange (2*(n+1))).formPerm) : tourNumbering p hp=1 := by |
| apply (tourNumbering_unique p hp 1 rfl ?_).symm |
| intro i |
| rw [he,formPerm_finRange_eq_rotate] |
| rfl |
|
|
| lemma edgeFirst_canonical (a p : Perm (Dart n)) (ha : Function.Involutive a) |
| (hp : ∀ d e,p.SameCycle d e) (he : p=(List.finRange (2*(n+1))).formPerm) |
| (x : Opener a) : edgeFirst a p hp (orbit a x.val)=x.val.val := by |
| rw [edgeFirst,canonical_tourNumbering p hp he] |
| have hh := (MapFinite.mk_eq_iff_involution a ha x.val (orbit a x.val)).mp rfl |
| have hx := x.property |
| rcases hh with hh|hh |
| · conv_rhs => rw [hh] |
| rw [hh] at hx |
| exact min_eq_left hx.le |
| · conv_rhs => rw [hh] |
| rw [hh,ha] at hx |
| exact min_eq_right hx.le |
|
|
| /-- The ordered fundamental activity of any edge is precisely the absence |
| of a later-first chord crossing. -/ |
| theorem orderedActive_chord (a s : Perm (Dart n)) (ha : Function.Involutive a) |
| (hf : ∀ d,a d≠d) (T : Finset (Orbit a)) (hT : Multiforest a s T) |
| (hp : ∀ d e,(s*partialReversal a ha T).SameCycle d e) |
| (ht : s*partialReversal a ha T=(List.finRange (2*(n+1))).formPerm) |
| (hdual : Nat.card (Orbit (partialReversal a ha Tᶜ*(List.finRange (2*(n+1))).formPerm))= |
| Nat.card (Orbit (List.finRange (2*(n+1))).formPerm)+Tᶜ.card) |
| (x : Opener a) : |
| OrderedActive a s T (edgeFirst a (s*partialReversal a ha T) hp) (orbit a x.val) ↔ |
| ¬∃ j : Dart n,x.val < j ∧ j < a x.val ∧ a x.val < a j := by |
| constructor |
| · intro h ⟨j,hxj,hjx,haxj⟩ |
| let y : Opener a := ⟨j,(hjx.trans haxj)⟩ |
| have hne : x≠y := fun h => (ne_of_lt hxj) (congrArg Subtype.val h) |
| apply h (orbit a y.val) |
| · rw [edgeFirst_canonical a _ ha hp ht x,edgeFirst_canonical a _ ha hp ht y] |
| exact hxj |
| · exact (fundamentalCross_iff_chord a s ha T hT ht hdual x y hne).mpr (Or.inl ⟨hxj,hjx,haxj⟩) |
| · intro h f hxf hcross |
| obtain ⟨y,rfl⟩ := opener_orbit_surjective a ha hf f |
| rw [edgeFirst_canonical a _ ha hp ht x,edgeFirst_canonical a _ ha hp ht y] at hxf |
| have hxy : x.val < y.val := hxf |
| have hne : x≠y := fun he => (ne_of_lt hxy) (congrArg Subtype.val he) |
| rcases (fundamentalCross_iff_chord a s ha T hT ht hdual x y hne).mp hcross with hh|hh |
| · exact h ⟨y.val,hh⟩ |
| · exact (not_lt_of_ge hxy.le) hh.1 |
|
|
| /-- Counting openers or their matching closers gives the identical activity |
| exponent, including deterministic one-edge cases. -/ |
| lemma sum_closers_eq_openers (a : Perm (Dart n)) (ha : Function.Involutive a) : |
| (∑ i : Dart n,if a i < i ∧ ¬∃ j : Dart n,a i < j ∧ j < i ∧ i < a j then 1 else 0)= |
| ∑ x : Opener a,if ¬∃ j : Dart n,x.val < j ∧ j < a x.val ∧ a x.val < a j then 1 else 0 := by |
| have hswap := Equiv.sum_comp a (fun i : Dart n => |
| if a i < i ∧ ¬∃ j : Dart n,a i < j ∧ j < i ∧ i < a j then (1:ℕ) else 0) |
| rw [← hswap] |
| trans ∑ i : Dart n,if i < a i then |
| (if ¬∃ j : Dart n,i < j ∧ j < a i ∧ a i < a j then (1:ℕ) else 0) else 0 |
| · apply Finset.sum_congr rfl |
| intro i _ |
| rw [ha] |
| by_cases hi : i < a i <;> simp [hi] |
| · rw [← Finset.sum_filter] |
| exact Finset.sum_subtype _ (by simp) _ |
| |
| end FKCRT |
| end |
| |
| |
| noncomputable section |
| open List Equiv Equiv.Perm |
| open scoped BigOperators |
| attribute [local instance] Classical.propDecidable |
| namespace FKCRT |
| open MapCycles Chords Inventory |
| variable {n : ℕ} |
|
|
| lemma canonical_tour_maximal (M : LabelledMap n) (T : Finset (Orbit M.val.1)) |
| (ht : M.val.2*partialReversal M.val.1 M.property.1 T=(List.finRange (2*(n+1))).formPerm) : |
| Nat.card (Orbit (partialReversal M.val.1 M.property.1 T*(List.finRange (2*(n+1))).formPerm))= |
| Nat.card (Orbit (List.finRange (2*(n+1))).formPerm)+T.card ∧ |
| Nat.card (Orbit (partialReversal M.val.1 M.property.1 Tᶜ*(List.finRange (2*(n+1))).formPerm))= |
| Nat.card (Orbit (List.finRange (2*(n+1))).formPerm)+Tᶜ.card := by |
| let a := M.val.1 |
| let s := M.val.2 |
| let t := s*partialReversal a M.property.1 T |
| have hp : ∀ d e,t.SameCycle d e := by |
| rw [show t=(List.finRange (2*(n+1))).formPerm from ht] |
| intro d e |
| exact sameCycle_of_list _ (List.nodup_finRange _) (fun _ _ => rfl) (List.mem_finRange d) (List.mem_finRange e) |
| have hct : Nat.card (Orbit t)=1 := (card_orbit_eq_one_iff _).mpr hp |
| constructor |
| · rw [← ht,card_orbit_mul_comm,reconstructed_tour,hct] |
| exact (tour_edge_card M T hp).trans (Nat.add_comm _ _) |
| · rw [← ht,card_orbit_mul_comm,hct] |
| have hc := planar_tour_compl_card M T hp |
| have hface := reconstructed_face a t M.property.1 T |
| have hrec : t*partialReversal a M.property.1 T=s := reconstructed_tour a s M.property.1 T |
| rw [hrec] at hface |
| rw [← hface] |
| exact hc.trans (Nat.add_comm _ _) |
|
|
| /-- The actual adaptive FK expansion exponent is the number of flexible |
| closing positions in the true identified word. No weight identity is assumed. -/ |
| theorem canonical_activity_eq_flexible (M : LabelledMap n) (T : Finset (Orbit M.val.1)) |
| (hT : T∈treeExtensions M.val.1 M.val.2 ∅ Finset.univ) |
| (ht : M.val.2*partialReversal M.val.1 M.property.1 T=(List.finRange (2*(n+1))).formPerm) : |
| explorationActivity M.val.1 M.val.2 (tourSelector M.val.1 M.val.2 M.property.1) |
| ∅ Finset.univ T (Fintype.card (Orbit M.val.1))= |
| flexibleCount (List.ofFn (matchingWord M.val.1 T)) [] := by |
| let a := M.val.1 |
| let s := M.val.2 |
| let ha := M.property.1 |
| let hf := M.property.2.1 |
| have hp := treeExtension_tour a s ha ∅ Finset.univ T hT |
| have hforest : Multiforest a s T := (mem_treeExtensions a s ∅ Finset.univ T).mp hT |>.2.2.1 |
| obtain ⟨hmax,hdual⟩ := canonical_tour_maximal M T ht |
| have hnc : ∀ x y : Dart n,decide (orbit a x∈T)=decide (orbit a y∈T) → |
| x < y → y < a x → a x < a y → False := by |
| intro x y hh hxy hyx haxy |
| have hh' : (orbit a x∈T) ↔ (orbit a y∈T) := by simpa only [decide_eq_decide] using hh |
| by_cases hx : orbit a x∈T |
| · exact ordered_no_crossing a ha _ (List.pairwise_lt_finRange _) List.mem_finRange T hmax x y hx (hh'.mp hx) hxy hyx haxy |
| · have hy : orbit a y∉T := fun h => hx (hh'.mpr h) |
| exact ordered_no_crossing a ha _ (List.pairwise_lt_finRange _) List.mem_finRange Tᶜ hdual x y |
| (Finset.mem_compl.mpr hx) (Finset.mem_compl.mpr hy) hxy hyx haxy |
| have hw := matching_flexibleCount a ha hf (fun i => decide (orbit a i∈T)) |
| (fun i => by rw [orbit_perm]) hnc |
| change flexibleCount (List.ofFn (matchingWord a T)) []=_ at hw |
| rw [tourActivity_eq_card M.val.1 M.val.2 M.property.1 T hT,hw,sum_closers_eq_openers a ha] |
| have he := Equiv.sum_comp (openerOrbitEquiv a ha hf) |
| (fun e : Orbit a => if OrderedActive a s T (edgeFirst a (s*partialReversal a ha T) hp) e then (1:ℕ) else 0) |
| rw [Finset.card_filter] |
| rw [← he] |
| apply Finset.sum_congr rfl |
| intro x _ |
| have hh := orderedActive_chord a s ha hf T hforest hp ht hdual x |
| change (if OrderedActive a s T (edgeFirst a (s*partialReversal a ha T) hp) (orbit a x.val) then 1 else 0)=_ |
| rw [hh] |
| split_ifs <;> rfl |
| |
| end FKCRT |
| end |
| |
| |
| noncomputable section |
| open List Equiv Equiv.Perm |
| attribute [local instance] Classical.propDecidable |
| namespace FKCRT |
| open MapCycles Inventory |
| variable {n : ℕ} |
|
|
| /-- Literal rooted-tour normal form, not a map with an assumed word inverse. -/ |
| structure CanonicalTreeMap (n : ℕ) where |
| a : Perm (Dart n) |
| s : Perm (Dart n) |
| A : Finset (Orbit a) |
| valid : MapConditions (a,s) |
| tour : s*partialReversal a valid.1 A=(List.finRange (2*(n+1))).formPerm |
|
|
| abbrev SuccessfulWord (n : ℕ) := {w : Dart n→TypedLetter // |
| stackTypedRun ((List.finRange (2*(n+1))).map w) []=some []} |
|
|
| def CanonicalTreeMap.word (X : CanonicalTreeMap n) : SuccessfulWord n := |
| ⟨matchingWord X.a X.A,by |
| have hh := canonical_tour_maximal ⟨(X.a,X.s),X.valid⟩ X.A X.tour |
| exact (maximal_matching_word X.a X.valid.1 X.valid.2.1 X.A hh.1 hh.2).1⟩ |
|
|
| lemma matchingWord_color (a : Perm (Dart n)) (A : Finset (Orbit a)) (i : Dart n) : |
| (matchingWord a A i).color=decide (orbit a i∈A) := by |
| unfold matchingWord |
| split_ifs <;> rfl |
| |
| lemma matchingWord_set_injective (a : Perm (Dart n)) : |
| Function.Injective (matchingWord a) := by |
| intro A B h |
| apply Finset.ext |
| intro e |
| induction e using Quotient.inductionOn with |
| | _ i => |
| have hh := congrArg (fun w => (w i).color) h |
| change orbit a i∈A ↔ orbit a i∈B |
| simpa only [matchingWord_color,decide_eq_decide] using hh |
|
|
| lemma CanonicalTreeMap.word_injective : Function.Injective (@CanonicalTreeMap.word n) := by |
| intro X Y h |
| have hw : matchingWord X.a X.A=matchingWord Y.a Y.A := congrArg Subtype.val h |
| have hX := canonical_tour_maximal ⟨(X.a,X.s),X.valid⟩ X.A X.tour |
| have hY := canonical_tour_maximal ⟨(Y.a,Y.s),Y.valid⟩ Y.A Y.tour |
| obtain ⟨_,E,F,he,hf,hc,htE,htF,ha,hp⟩ := |
| maximal_matching_word X.a X.valid.1 X.valid.2.1 X.A hX.1 hX.2 |
| obtain ⟨_,E',F',he',hf',hc',htE',htF',ha',hp'⟩ := |
| maximal_matching_word Y.a Y.valid.1 Y.valid.2.1 Y.A hY.1 hY.2 |
| rw [← hw] at htE' htF' |
| have hu := typed_map_unique (matchingWord X.a X.A) _ (List.nodup_finRange _) E F E' F' |
| he hf he' hf' hc hc' htE htF htE' htF' |
| have haeq : X.a=Y.a := ha.symm.trans (hu.1.trans ha') |
| cases X with |
| | mk a s A hv ht => |
| cases Y with |
| | mk a' s' A' hv' ht' => |
| dsimp only at haeq hw |
| subst a' |
| have hA : A=A' := matchingWord_set_injective a hw |
| subst A' |
| have hs : s=s' := mul_right_cancel (ht.trans ht'.symm) |
| subst s' |
| rfl |
|
|
| lemma matchingWord_of_matchings (w : Dart n→TypedLetter) |
| (E F : List (Dart n×Dart n)) |
| (hE : Arches (List.finRange (2*(n+1))) E) |
| (hF : Arches (List.finRange (2*(n+1))) F) |
| (hc : (endpoints (E++F)).Perm (List.finRange (2*(n+1)))) |
| (htE : ∀ e∈E,w e.1=.burger true ∧ w e.2=.order true) |
| (htF : ∀ e∈F,w e.1=.burger false ∧ w e.2=.order false) : |
| matchingWord (turns (E++F)) (matchingEdges E F)=w := by |
| have hn : (endpoints (E++F)).Nodup := hc.nodup_iff.mpr (List.nodup_finRange _) |
| have hdis : List.Disjoint (endpoints E) (endpoints F) := by |
| rw [endpoints_append,List.nodup_append] at hn |
| exact fun d hd hd' => hn.2.2 d hd d hd' rfl |
| funext i |
| obtain ⟨e,he,rfl|rfl⟩ := mem_endpoints.mp (hc.mem_iff.mpr (List.mem_finRange i)) |
| · simp only [matchingWord,(turns_pair hn e he).1,mem_matchingEdges E F hn] |
| rcases List.mem_append.mp he with he|he |
| · rw [ite_eq_left (hE.increasing (List.pairwise_lt_finRange _) e he), |
| decide_eq_true (mem_endpoints.mpr ⟨e,he,Or.inl rfl⟩), (htE e he).1] |
| · rw [ite_eq_left (hF.increasing (List.pairwise_lt_finRange _) e he), |
| decide_eq_false (fun hx => hdis hx (mem_endpoints.mpr ⟨e,he,Or.inl rfl⟩)),(htF e he).1] |
| · simp only [matchingWord,(turns_pair hn e he).2,mem_matchingEdges E F hn] |
| rcases List.mem_append.mp he with he|he |
| · rw [ite_eq_right (not_lt_of_ge (hE.increasing (List.pairwise_lt_finRange _) e he).le), |
| decide_eq_true (mem_endpoints.mpr ⟨e,he,Or.inr rfl⟩),(htE e he).2] |
| · rw [ite_eq_right (not_lt_of_ge (hF.increasing (List.pairwise_lt_finRange _) e he).le), |
| decide_eq_false (fun hx => hdis hx (mem_endpoints.mpr ⟨e,he,Or.inr rfl⟩)),(htF e he).2] |
|
|
| lemma CanonicalTreeMap.word_surjective : Function.Surjective (@CanonicalTreeMap.word n) := by |
| intro w |
| obtain ⟨E,F,hE,hF,hc,htE,htF⟩ := identified_matchings w.val w.property |
| have hv := matching_map_conditions E F hE hF hc |
| have hn : (endpoints (E++F)).Nodup := hc.nodup_iff.mpr (List.nodup_finRange _) |
| have ht : ((List.finRange (2*(n+1))).formPerm*turns E)* |
| partialReversal (turns (E++F)) hv.1 (matchingEdges E F)= |
| (List.finRange (2*(n+1))).formPerm := by |
| rw [partialReversal_matchingEdges E F hn,mul_assoc, |
| turns_self (by rw [endpoints_append] at hn; exact hn.of_append_left),mul_one] |
| refine ⟨⟨_,_,_,hv,ht⟩,Subtype.ext ?_⟩ |
| exact matchingWord_of_matchings w.val E F hE hF hc htE htF |
| |
| /-- Exact finite bimapping of the genuine canonical rooted planar tree maps |
| and successful typed words; no symmetry divisor and no assumed inverse. -/ |
| def canonicalWordEquiv (n : ℕ) : CanonicalTreeMap n ≃ SuccessfulWord n := |
| Equiv.ofBijective CanonicalTreeMap.word |
| ⟨CanonicalTreeMap.word_injective,CanonicalTreeMap.word_surjective⟩ |
|
|
| end FKCRT |
| end |
|
|
| end OAI |
|
|
