math / data /lean /OAI /Probability /FKMaps /CanonicalBijection.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
23.6 kB
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