import OAI.Probability.FKMaps.ExcursionGeometry import OAI.Probability.FKMaps.Noncrossing namespace OAI noncomputable section open Set Filter MeasureTheory ProbabilityTheory open scoped Topology BigOperators ENNReal NNReal namespace FKCRT lemma orbit_eq_iff {n : ℕ} (s : Equiv.Perm (Dart n)) (d e : Dart n) : orbit s d=orbit s e ↔ s.SameCycle d e := Quotient.eq lemma orbit_perm {n : ℕ} (s : Equiv.Perm (Dart n)) (d : Dart n) : orbit s (s d)=orbit s d := by apply Quotient.sound exact (Equiv.Perm.sameCycle_apply_left).2 (Equiv.Perm.SameCycle.refl s d) lemma closed_of_sameCycle {n : ℕ} {s : Equiv.Perm (Dart n)} {P : Dart n → Prop} (hs : ∀ d,P d → P (s d)) {d e : Dart n} (hd : P d) (h : s.SameCycle d e) : P e := by obtain ⟨k,hk⟩ := h.exists_nat_pow_eq have hp (j : ℕ) : P ((s^j) d) := by induction j with | zero => simpa using hd | succ j ih => simpa only [pow_succ',Equiv.Perm.mul_apply] using hs _ ih exact hk ▸ hp k /-- Graph connectivity propagates a dart property through the two generating permutations. This is the precise permutation form of connected rooted-map rigidity, including loops and repeated edges. -/ lemma connected_dart_induction {n : ℕ} {a s : Equiv.Perm (Dart n)} (ha : Function.Involutive a) (hc : (spanningGraph a s univ).Connected) {P : Dart n → Prop} {d₀ : Dart n} (h₀ : P d₀) (haP : ∀ d,P d → P (a d)) (hsP : ∀ d,P d → P (s d)) : ∀ d,P d := by have hcycle {d e : Dart n} (hd : P d) (he : orbit s d=orbit s e) : P e := closed_of_sameCycle hsP hd ((orbit_eq_iff ..).1 he) have hstep {v w : Orbit s} (h : (spanningGraph a s univ).Adj v w) (hv : ∀ d,orbit s d=v → P d) : ∀ d,orbit s d=w → P d := by rcases h.2 with ⟨d,_,hd,he⟩ | ⟨d,_,he,hd⟩ · intro e he' exact hcycle (haP d (hv d hd)) (he.trans he'.symm) · intro e he' have hh := haP (a d) (hv (a d) hd) rw [ha d] at hh exact hcycle hh (he.trans he'.symm) have hall (v : Orbit s) : ∀ d,orbit s d=v → P d := by have hp := (SimpleGraph.reachable_iff_reflTransGen ..).1 (hc (orbit s d₀) v) induction hp with | refl => exact fun d hd => hcycle h₀ hd.symm | tail hp hadj ih => exact hstep hadj ih exact fun d => hall (orbit s d) d rfl lemma MapIso.refl {n : ℕ} (M : LabelledMap n) : MapIso M M := ⟨Equiv.refl _,rfl,fun _ => rfl,fun _ => rfl⟩ lemma MapIso.symm {n : ℕ} {M N : LabelledMap n} (h : MapIso M N) : MapIso N M := by obtain ⟨r,h₀,ha,hs⟩ := h refine ⟨r.symm,?_,?_,?_⟩ · exact (r.symm_apply_eq).2 h₀.symm · intro d apply r.injective simpa using (ha (r.symm d)).symm · intro d apply r.injective simpa using (hs (r.symm d)).symm lemma MapIso.trans {n : ℕ} {M N K : LabelledMap n} (h : MapIso M N) (h' : MapIso N K) : MapIso M K := by obtain ⟨r,hr,ha,hs⟩ := h obtain ⟨r',hr',ha',hs'⟩ := h' refine ⟨r.trans r',?_,?_,?_⟩ · simp [hr,hr'] · intro d simp only [Equiv.trans_apply,ha',ha] · intro d simp only [Equiv.trans_apply,hs',hs] lemma mapIso_eqvGen {n : ℕ} {M N : LabelledMap n} : Relation.EqvGen MapIso M N ↔ MapIso M N := by constructor · intro h induction h with | rel _ _ he => exact he | refl M => exact MapIso.refl M | symm _ _ _ ih => exact ih.symm | trans _ _ _ _ _ ih ih' => exact ih.trans ih' · exact Relation.EqvGen.rel _ _ /-- A rooted connected rotation system has no nontrivial automorphisms. Consequently the source's distinguished corners carry no symmetry divisor. -/ lemma rooted_automorphism_eq_one {n : ℕ} (M : LabelledMap n) (r : Equiv.Perm (Dart n)) (h₀ : r 0=0) (ha : ∀ d,M.val.1 (r d)=r (M.val.1 d)) (hs : ∀ d,M.val.2 (r d)=r (M.val.2 d)) : r=1 := by apply Equiv.ext change ∀ d,r d=d apply connected_dart_induction M.property.1 M.property.2.2.1 (P := fun d => r d=d) h₀ · intro d hd rw [← ha,hd] · intro d hd rw [← hs,hd] lemma root_isomorphism_unique {n : ℕ} {M N : LabelledMap n} {r r' : Equiv.Perm (Dart n)} (hr : r 0=0) (ha : ∀ d,N.val.1 (r d)=r (M.val.1 d)) (hs : ∀ d,N.val.2 (r d)=r (M.val.2 d)) (hr' : r' 0=0) (ha' : ∀ d,N.val.1 (r' d)=r' (M.val.1 d)) (hs' : ∀ d,N.val.2 (r' d)=r' (M.val.2 d)) : r=r' := by have hh : r.trans r'.symm=1 := by apply rooted_automorphism_eq_one M · change r'.symm (r 0)=0 rw [hr] exact r'.symm_apply_eq.mpr hr'.symm · intro d apply r'.injective simp only [Equiv.trans_apply,Equiv.apply_symm_apply] rw [← ha',Equiv.apply_symm_apply,ha] · intro d apply r'.injective simp only [Equiv.trans_apply,Equiv.apply_symm_apply] rw [← hs',Equiv.apply_symm_apply,hs] apply Equiv.ext intro d have he := congrArg (fun e : Equiv.Perm (Dart n) => r' (e d)) hh simpa using he end FKCRT end noncomputable section open Set Filter open scoped BigOperators attribute [local instance] Classical.propDecidable namespace FKCRT.MapFinite abbrev CycleQuot {α : Type*} (s : Equiv.Perm α) := Quotient (Equiv.Perm.SameCycle.setoid s) instance {α : Type*} [Finite α] (s : Equiv.Perm α) : Fintype (CycleQuot s) := Fintype.ofFinite _ lemma sameCycle_involution {α : Type*} [Finite α] (s : Equiv.Perm α) (hs : Function.Involutive s) (x y : α) : s.SameCycle x y ↔ y=x ∨ y=s x := by constructor · intro h obtain ⟨k,hk⟩ := h.exists_nat_pow_eq rw [← hk] clear h hk y induction k with | zero => exact Or.inl rfl | succ k ih => rw [pow_succ',Equiv.Perm.mul_apply] rcases ih with he | he · exact Or.inr (congrArg s he) · exact Or.inl ((congrArg s he).trans (hs x)) · intro h rcases h with h | h · simpa only [h] using Equiv.Perm.SameCycle.refl s x · rw [h] exact Equiv.Perm.sameCycle_apply_right.mpr (Equiv.Perm.SameCycle.refl s x) lemma mk_eq_iff_involution {α : Type*} [Finite α] (s : Equiv.Perm α) (hs : Function.Involutive s) (d : α) (q : CycleQuot s) : Quotient.mk _ d=q ↔ d=q.out ∨ d=s q.out := by calc Quotient.mk _ d=q ↔ Quotient.mk _ d=Quotient.mk _ q.out := by rw [Quotient.out_eq] _ ↔ s.SameCycle d q.out := Quotient.eq _ ↔ s.SameCycle q.out d := ⟨Equiv.Perm.SameCycle.symm,Equiv.Perm.SameCycle.symm⟩ _ ↔ d=q.out ∨ d=s q.out := sameCycle_involution s hs q.out d lemma card_orbit_fiber {α : Type*} [Fintype α] (s : Equiv.Perm α) (hs : Function.Involutive s) (q : CycleQuot s) : Fintype.card {d : α // Quotient.mk (Equiv.Perm.SameCycle.setoid s) d=q}= if s q.out=q.out then 1 else 2 := by classical rw [Fintype.card_subtype] have he : Finset.univ.filter (fun d : α => Quotient.mk (Equiv.Perm.SameCycle.setoid s) d=q)= {q.out,s q.out} := by ext d simp only [Finset.mem_filter,Finset.mem_univ,true_and,Finset.mem_insert,Finset.mem_singleton] exact mk_eq_iff_involution s hs d q rw [he] by_cases h : s q.out=q.out · simp [h] · simp [h,Ne.symm h] lemma fixed_out_iff {α : Type*} [Finite α] (s : Equiv.Perm α) (hs : Function.Involutive s) (d : α) : s (Quotient.mk (Equiv.Perm.SameCycle.setoid s) d).out= (Quotient.mk (Equiv.Perm.SameCycle.setoid s) d).out ↔ s d=d := by have he := (mk_eq_iff_involution s hs d (Quotient.mk _ d)).mp rfl rcases he with he | he · conv_rhs => rw [he] · conv_rhs => rw [he,hs] exact eq_comm def fixedOrbitEquiv {α : Type*} [Finite α] (s : Equiv.Perm α) (hs : Function.Involutive s) : {d : α // s d=d} ≃ {q : CycleQuot s // s q.out=q.out} where toFun d := ⟨Quotient.mk _ d.val,(fixed_out_iff s hs d.val).mpr d.property⟩ invFun q := ⟨q.val.out,q.property⟩ left_inv d := by apply Subtype.ext have he := (mk_eq_iff_involution s hs d.val (Quotient.mk _ d.val)).mp rfl rcases he with he | he · exact he.symm · have hh := congrArg s he rw [d.property,hs] at hh exact hh.symm right_inv q := Subtype.ext (Quotient.out_eq q.val) /-- Orbit count for an involution, retaining its fixed points. A reversal has no fixed darts, whereas the path-map vertex rotation has exactly two. -/ lemma twice_card_orbits {α : Type*} [Fintype α] (s : Equiv.Perm α) (hs : Function.Involutive s) : 2*Fintype.card (CycleQuot s)=Fintype.card α+Fintype.card {d : α // s d=d} := by classical have hd : Fintype.card α=∑ q : CycleQuot s,if s q.out=q.out then 1 else 2 := by rw [← Fintype.card_congr (Equiv.sigmaFiberEquiv (Quotient.mk (Equiv.Perm.SameCycle.setoid s))), Fintype.card_sigma] exact Finset.sum_congr rfl (fun q _ => card_orbit_fiber s hs q) have hf : Fintype.card {d : α // s d=d}=∑ q : CycleQuot s,if s q.out=q.out then 1 else 0 := by rw [Fintype.card_congr (fixedOrbitEquiv s hs),Fintype.card_subtype] simp only [Finset.sum_boole, Nat.cast_id] rw [hd,hf,← Finset.sum_add_distrib] calc 2*Fintype.card (CycleQuot s)=∑ _q : CycleQuot s,2 := by simp [mul_comm] _ = _ := Finset.sum_congr rfl (fun q _ => by split_ifs <;> rfl) end FKCRT.MapFinite end noncomputable section open Set Filter MeasureTheory ProbabilityTheory open scoped Topology BigOperators ENNReal NNReal namespace FKCRT lemma spanningGraph_reachable_reversal {n : ℕ} (a s : Equiv.Perm (Dart n)) (d : Dart n) : (spanningGraph a s univ).Reachable (orbit s d) (orbit s (a d)) := by classical by_cases h : orbit s d=orbit s (a d) · rw [h] · apply SimpleGraph.Adj.reachable exact ⟨h,Or.inl ⟨d,mem_univ _,rfl,rfl⟩⟩ lemma spanningGraph_connected_of_face_cycle {n : ℕ} (a s : Equiv.Perm (Dart n)) (hc : ∀ d e,(s*a).SameCycle d e) : (spanningGraph a s univ).Connected := by refine {preconnected := ?_, nonempty := ⟨orbit s 0⟩} intro v w induction v using Quotient.inductionOn with | h d => induction w using Quotient.inductionOn with | h e => obtain ⟨k,hk⟩ := (hc d e).exists_nat_pow_eq rw [← hk] have hp (j : ℕ) : (spanningGraph a s univ).Reachable (orbit s d) (orbit s (((s*a)^j) d)) := by induction j with | zero => exact SimpleGraph.Reachable.refl _ | succ j ih => rw [pow_succ',Equiv.Perm.mul_apply,Equiv.Perm.mul_apply,orbit_perm] exact ih.trans (spanningGraph_reachable_reversal a s _) exact hp k def pathRotation (n : ℕ) : Equiv.Perm (Dart n) := finRotate (2*(n+1))*Fin.revPerm lemma pathRotation_val (n : ℕ) (d : Dart n) : (pathRotation n d).val=if d.val=0 then 0 else 2*(n+1)-d.val := by simp only [pathRotation,Equiv.Perm.mul_apply,Fin.revPerm_apply,finRotate_apply, Fin.val_add,Fin.val_rev,Fin.val_one] by_cases h : d.val=0 · rw [ite_eq_left h,h] have he : 2*(n+1)-(0+1)+1=2*(n+1) := by omega rw [he,Nat.mod_self] · rw [ite_eq_right h,Nat.mod_eq_of_lt (by have := d.isLt; omega)] omega lemma pathRotation_involutive (n : ℕ) : Function.Involutive (pathRotation n) := by intro d apply Fin.ext rw [pathRotation_val,pathRotation_val] have := d.isLt split_ifs <;> omega lemma pathRotation_fixed (n : ℕ) (d : Dart n) : pathRotation n d=d ↔ d.val=0 ∨ d.val=n+1 := by rw [Fin.ext_iff,pathRotation_val] have := d.isLt split_ifs <;> omega lemma pathRotation_fixed_card (n : ℕ) : Nat.card {d : Dart n // pathRotation n d=d}=2 := by classical rw [Nat.card_eq_fintype_card,Fintype.card_subtype] have he : Finset.univ.filter (fun d : Dart n => pathRotation n d=d)= {(0 : Dart n),⟨n+1,by omega⟩} := by ext d simp only [Finset.mem_filter,Finset.mem_univ,true_and,Finset.mem_insert,Finset.mem_singleton] rw [pathRotation_fixed] simp only [Fin.ext_iff,Fin.val_zero] rw [he] have hd : (0 : Dart n)≠⟨n+1,by omega⟩ := by intro h; have := congrArg Fin.val h; simp only [Fin.val_zero] at this; omega simp [hd] lemma pathRotation_orbits (n : ℕ) : Nat.card (Orbit (pathRotation n))=n+2 := by have hh := MapFinite.twice_card_orbits (pathRotation n) (pathRotation_involutive n) simp only [← Nat.card_eq_fintype_card,pathRotation_fixed_card] at hh have hd : Nat.card (Dart n)=2*(n+1) := by simp [Dart] rw [hd] at hh change 2*Nat.card (Orbit (pathRotation n))=2*(n+1)+2 at hh omega lemma rotate_sameCycle (n : ℕ) (d e : Dart n) : (finRotate (2*(n+1))).SameCycle d e := by apply (isCycle_finRotate_of_le (by omega : 2≤2*(n+1))).sameCycle · apply Equiv.Perm.mem_support.mp rw [support_finRotate_of_le (by omega : 2≤2*(n+1))] exact Finset.mem_univ _ · apply Equiv.Perm.mem_support.mp rw [support_finRotate_of_le (by omega : 2≤2*(n+1))] exact Finset.mem_univ _ lemma pathRotation_face (n : ℕ) : pathRotation n*Fin.revPerm=finRotate (2*(n+1)) := by ext d simp only [pathRotation,Equiv.Perm.mul_apply,Fin.revPerm_apply,Fin.rev_rev] lemma rotate_orbits (n : ℕ) : Nat.card (Orbit (finRotate (2*(n+1))))=1 := by have : Subsingleton (Orbit (finRotate (2*(n+1)))) := ⟨fun v w => by induction v using Quotient.inductionOn with | h d => induction w using Quotient.inductionOn with | h e => exact Quotient.sound (rotate_sameCycle n d e)⟩ have : Nonempty (Orbit (finRotate (2*(n+1)))) := ⟨orbit _ 0⟩ exact Nat.card_eq_one_iff_unique.mpr ⟨inferInstance,inferInstance⟩ /-- A concrete genus-zero path map with every positive edge size. -/ def pathLabelledMap (n : ℕ) : LabelledMap n := ⟨(Fin.revPerm,pathRotation n),by refine ⟨Fin.rev_involutive,?_,?_,?_⟩ · intro d h have he := congrArg Fin.val h simp only [Fin.revPerm_apply,Fin.val_rev] at he have := d.isLt omega · apply spanningGraph_connected_of_face_cycle rw [pathRotation_face] exact rotate_sameCycle n · change Nat.card (Orbit (pathRotation n))+Nat.card (Orbit (pathRotation n*Fin.revPerm))=n+3 rw [pathRotation_face,pathRotation_orbits,rotate_orbits]⟩ instance rootedMap_nonempty (n : ℕ) : Nonempty (RootedMap n) := ⟨Quotient.mk _ (pathLabelledMap n)⟩ lemma partition_pos {q : ℝ} (hq : 0 if orbit a d ∈ A then a d else d) := by classical intro d by_cases hd : orbit a d ∈ A · simp only [orbit_perm, hd, ite_true] exact ha d · simp only [hd, ite_false] def partialReversal (a : Perm (Dart n)) (ha : Function.Involutive a) (A : Finset (Orbit a)) : Perm (Dart n) := by classical exact (partial_involutive a ha A).toPerm _ lemma partialReversal_apply (a : Perm (Dart n)) (ha : Function.Involutive a) (A : Finset (Orbit a)) (d : Dart n) : partialReversal a ha A d = if orbit a d ∈ A then a d else d := rfl lemma partialReversal_involutive (a : Perm (Dart n)) (ha : Function.Involutive a) (A : Finset (Orbit a)) : Function.Involutive (partialReversal a ha A) := partial_involutive a ha A lemma partialReversal_empty (a : Perm (Dart n)) (ha : Function.Involutive a) : partialReversal a ha ∅ = 1 := by apply Equiv.ext intro d simp [partialReversal_apply] lemma partialReversal_self (a : Perm (Dart n)) (ha : Function.Involutive a) (A : Finset (Orbit a)) : partialReversal a ha A * partialReversal a ha A = 1 := by apply Equiv.ext intro d exact partialReversal_involutive a ha A d lemma partialReversal_compl (a : Perm (Dart n)) (ha : Function.Involutive a) (A : Finset (Orbit a)) : partialReversal a ha A * a = partialReversal a ha Aᶜ := by classical apply Equiv.ext intro d simp only [mul_apply, partialReversal_apply, orbit_perm, Finset.mem_compl] by_cases h : orbit a d ∈ A · simpa only [h, ite_true, not_true_eq_false, ite_false] using ha d · simp only [h, ite_false, not_false_eq_true, ite_true] lemma partialReversal_insert (a : Perm (Dart n)) (ha : Function.Involutive a) (A : Finset (Orbit a)) (e : Orbit a) (he : e ∉ A) : partialReversal a ha (insert e A) = partialReversal a ha A * swap e.out (a e.out) := by classical have heq (d : Dart n) : orbit a d = e ↔ d = e.out ∨ d = a e.out := MapFinite.mk_eq_iff_involution a ha d e have ho : orbit a e.out = e := Quotient.out_eq e apply Equiv.ext intro d by_cases hd₁ : d = e.out · subst d simp only [mul_apply, swap_apply_left, partialReversal_apply, orbit_perm, ho, Finset.mem_insert_self, ite_true, he, ite_false] by_cases hd₂ : d = a e.out · subst d simp only [mul_apply, swap_apply_right, partialReversal_apply, orbit_perm, ho, Finset.mem_insert_self, ite_true, he, ite_false] exact ha e.out · have hd : orbit a d ≠ e := fun h => (heq d).mp h |>.elim hd₁ hd₂ simp only [mul_apply, swap_apply_of_ne_of_ne hd₁ hd₂, partialReversal_apply, Finset.mem_insert, hd, false_or] lemma card_orbit_mul_swap_le (p : Perm (Dart n)) (d e : Dart n) : Nat.card (Orbit (p * swap d e)) ≤ Nat.card (Orbit p) + 1 := by rw [mul_swap_eq_swap_mul] exact MapCycles.card_orbits_swap_le p (p d) (p e) lemma card_orbit_partialReversal_le (a s : Perm (Dart n)) (ha : Function.Involutive a) (A : Finset (Orbit a)) : Nat.card (Orbit (s * partialReversal a ha A)) ≤ Nat.card (Orbit s) + A.card := by classical induction A using Finset.induction_on with | empty => simp [partialReversal_empty] | @insert e A he ih => rw [partialReversal_insert a ha A e he, ← mul_assoc, Finset.card_insert_of_notMem he] have hh := card_orbit_mul_swap_le (s * partialReversal a ha A) e.out (a e.out) omega lemma card_orbit_eq_one_iff (p : Perm (Dart n)) : Nat.card (Orbit p) = 1 ↔ ∀ d e, p.SameCycle d e := by rw [Nat.card_eq_one_iff_unique] constructor · intro hh d e have : Subsingleton (Orbit p) := hh.1 exact Quotient.exact (Subsingleton.elim (orbit p d) (orbit p e)) · intro hh refine ⟨⟨fun v w => ?_⟩, ⟨orbit p 0⟩⟩ induction v using Quotient.inductionOn with | h d => induction w using Quotient.inductionOn with | h e => exact Quotient.sound (hh d e) lemma spanningGraph_reachable_partial (a s : Perm (Dart n)) (ha : Function.Involutive a) (A : Finset (Orbit a)) (d : Dart n) : (spanningGraph a s (A : Set (Orbit a))).Reachable (orbit s d) (orbit s (partialReversal a ha A d)) := by classical rw [partialReversal_apply] split_ifs with h · by_cases hd : orbit s d = orbit s (a d) · rw [hd] · exact SimpleGraph.Adj.reachable ⟨hd, Or.inl ⟨d, h, rfl, rfl⟩⟩ · exact SimpleGraph.Reachable.refl _ lemma spanningGraph_connected_of_tour (a s : Perm (Dart n)) (ha : Function.Involutive a) (A : Finset (Orbit a)) (hc : ∀ d e, (s * partialReversal a ha A).SameCycle d e) : (spanningGraph a s (A : Set (Orbit a))).Connected := by refine {preconnected := ?_, nonempty := ⟨orbit s 0⟩} intro v w induction v using Quotient.inductionOn with | h d => induction w using Quotient.inductionOn with | h e => obtain ⟨k,hk⟩ := (hc d e).exists_nat_pow_eq rw [← hk] have hp (j : ℕ) : (spanningGraph a s (A : Set (Orbit a))).Reachable (orbit s d) (orbit s (((s * partialReversal a ha A)^j) d)) := by induction j with | zero => exact SimpleGraph.Reachable.refl _ | succ j ih => rw [pow_succ', mul_apply, mul_apply, orbit_perm] exact ih.trans (spanningGraph_reachable_partial a s ha A _) exact hp k lemma reversal_card (a : Perm (Dart n)) (ha : Function.Involutive a) (hf : ∀ d, a d ≠ d) : Fintype.card (Orbit a) = n + 1 := by have hn : Fintype.card {d : Dart n // a d = d} = 0 := by have : IsEmpty {d : Dart n // a d = d} := ⟨fun d => hf d d.property⟩ exact Fintype.card_eq_zero have hh := MapFinite.twice_card_orbits a ha rw [Fintype.card_eq_nat_card] at hn simp only [Fintype.card_eq_nat_card] at hh ⊢ change 2*Nat.card (Orbit a)=Nat.card (Dart n)+Nat.card {d : Dart n // a d=d} at hh rw [hn] at hh simp only [Dart, Nat.card_fin, add_zero] at hh omega /-- A one-cycle tour in a genuine planar map has exactly V-1 chosen edges. The proof uses the Euler equality and the two complementary tour bounds, so loops and parallel edges are fully retained. -/ theorem tour_edge_card (M : LabelledMap n) (A : Finset (Orbit M.val.1)) (hc : ∀ d e, (M.val.2 * partialReversal M.val.1 M.property.1 A).SameCycle d e) : Nat.card (Orbit M.val.2) = A.card + 1 := by classical let a := M.val.1 let s := M.val.2 let ha := M.property.1 let p := s * partialReversal a ha A have hp : Nat.card (Orbit p) = 1 := (card_orbit_eq_one_iff _).mpr hc have hv := card_orbit_partialReversal_le a p ha A have hf := card_orbit_partialReversal_le a p ha Aᶜ have hv_eq : p * partialReversal a ha A = s := by dsimp [p] rw [mul_assoc, partialReversal_self, mul_one] have hf_eq : p * partialReversal a ha Aᶜ = s * a := by dsimp [p] rw [← partialReversal_compl a ha A, ← mul_assoc, mul_assoc s, partialReversal_self, mul_one] rw [hv_eq, hp] at hv rw [hf_eq, hp, Finset.card_compl, reversal_card a ha M.property.2.1] at hf have he := M.property.2.2.2 change Nat.card (Orbit s) + Nat.card (Orbit (s * a)) = n + 3 at he have ha_card : A.card ≤ n + 1 := by have hh := Finset.card_le_univ A change A.card ≤ Fintype.card (Orbit a) at hh rwa [reversal_card a ha M.property.2.1] at hh change Nat.card (Orbit s)=A.card+1 omega end FKCRT end noncomputable section open Set Equiv Equiv.Perm open scoped BigOperators attribute [local instance] Classical.propDecidable namespace FKCRT variable {n : ℕ} /-- An edge's unordered endpoints; representatives do not change this pair. -/ def edgeEnds (a s : Perm (Dart n)) (e : Orbit a) : Sym2 (Orbit s) := s(orbit s e.out, orbit s (a e.out)) lemma edgeEnds_orbit (a s : Perm (Dart n)) (ha : Function.Involutive a) (d : Dart n) : edgeEnds a s (orbit a d) = s(orbit s d, orbit s (a d)) := by have hh := (MapFinite.mk_eq_iff_involution a ha d (orbit a d)).mp rfl rcases hh with hh | hh · conv_rhs => rw [hh] rfl · conv_rhs => rw [hh, ha] exact Sym2.eq_swap lemma spanningGraph_edgeSet_subset (a s : Perm (Dart n)) (ha : Function.Involutive a) (A : Finset (Orbit a)) : (spanningGraph a s (A : Set (Orbit a))).edgeSet ⊆ edgeEnds a s '' (A : Set (Orbit a)) := by rintro e he induction e using Sym2.ind with | _ v w => rcases (SimpleGraph.mem_edgeSet _).mp he with ⟨_,h | h⟩ · obtain ⟨d,hd,hv,hw⟩ := h refine ⟨orbit a d, hd, ?_⟩ rw [edgeEnds_orbit a s ha d, hv, hw] · obtain ⟨d,hd,hw,hv⟩ := h refine ⟨orbit a d, hd, ?_⟩ rw [edgeEnds_orbit a s ha d, hv, hw] exact Sym2.eq_swap lemma spanningGraph_card_edgeSet_le (a s : Perm (Dart n)) (ha : Function.Involutive a) (A : Finset (Orbit a)) : Nat.card (spanningGraph a s (A : Set (Orbit a))).edgeSet ≤ A.card := by rw [Nat.card_coe_set_eq] exact (Set.ncard_le_ncard (spanningGraph_edgeSet_subset a s ha A)).trans ((Set.ncard_image_le (f := edgeEnds a s) (s := (A : Set (Orbit a)))).trans (Set.ncard_coe_finset A).le) /-- The selected edges of a one-cycle planar tour form an actual spanning tree of the all-edge graph. There are no suppressed loop/parallel edges in its size: the cardinality equality forces every chosen edge to be distinct and non-loop. -/ theorem tour_spanningTree (M : LabelledMap n) (A : Finset (Orbit M.val.1)) (hc : ∀ d e, (M.val.2 * partialReversal M.val.1 M.property.1 A).SameCycle d e) : (spanningGraph M.val.1 M.val.2 (A : Set (Orbit M.val.1))).IsTree ∧ Nat.card (spanningGraph M.val.1 M.val.2 (A : Set (Orbit M.val.1))).edgeSet = A.card := by have hconn := spanningGraph_connected_of_tour M.val.1 M.val.2 M.property.1 A hc have hle := hconn.card_vert_le_card_edgeSet_add_one have hle' := spanningGraph_card_edgeSet_le M.val.1 M.val.2 M.property.1 A have he := tour_edge_card M A hc have hh : Nat.card (spanningGraph M.val.1 M.val.2 (A : Set (Orbit M.val.1))).edgeSet = A.card := by omega exact ⟨SimpleGraph.isTree_iff_connected_and_card.mpr ⟨hconn, by omega⟩, hh⟩ end FKCRT end noncomputable section open Set Equiv Equiv.Perm open scoped BigOperators attribute [local instance] Classical.propDecidable namespace FKCRT variable {n : ℕ} lemma card_orbit_mul_comm (p q : Perm (Dart n)) : Nat.card (Orbit (p*q)) = Nat.card (Orbit (q*p)) := by apply Nat.card_congr apply Quotient.congr q intro d e change (p*q).SameCycle d e ↔ (q*p).SameCycle (q d) (q e) have he : q * (p*q) * q⁻¹ = q*p := by group rw [← he, sameCycle_conj] simp lemma card_orbit_partialReversal_mul_le (a p : Perm (Dart n)) (ha : Function.Involutive a) (A : Finset (Orbit a)) : Nat.card (Orbit (partialReversal a ha A * p)) ≤ Nat.card (Orbit p) + A.card := by rw [card_orbit_mul_comm] exact card_orbit_partialReversal_le a p ha A lemma edgeSwap_eq (a : Perm (Dart n)) (ha : Function.Involutive a) (d : Dart n) : swap (orbit a d).out (a (orbit a d).out) = swap d (a d) := by have hh := (MapFinite.mk_eq_iff_involution a ha d (orbit a d)).mp rfl rcases hh with hh | hh · conv_rhs => rw [hh] · conv_rhs => rw [hh, ha] exact swap_comm _ _ lemma partialReversal_insert_orbit (a : Perm (Dart n)) (ha : Function.Involutive a) (A : Finset (Orbit a)) (d : Dart n) (hd : orbit a d ∉ A) : partialReversal a ha (insert (orbit a d) A) = partialReversal a ha A * swap d (a d) := by rw [partialReversal_insert a ha A (orbit a d) hd, edgeSwap_eq a ha d] /-- Alternating chords first split and then rejoin a tour cycle. -/ lemma crossing_two_swaps (p : Perm (Dart n)) (x y z w : Dart n) (L M N R : List (Dart n)) (he : MapCycles.orbitList p x = x :: (L ++ y :: (M ++ z :: (N ++ w :: R)))) : Nat.card (Orbit (swap y w * (swap x z * p))) = Nat.card (Orbit p) := by have hn := MapCycles.nodup_orbitList p x rw [he] at hn have hxz : x ≠ z := fun h => hn.notMem (by simp [h]) have hcycle : p.SameCycle x z := by apply (MapCycles.mem_orbitList p x z).mp rw [he] simp have hcount := MapCycles.card_orbits_swap_of_sameCycle p hxz hcycle let U := x :: (L ++ y :: M) let V := z :: (N ++ w :: R) have hnodup : (U ++ V).Nodup := by simpa [U,V,List.append_assoc] using hn have hdisj := (List.nodup_append.mp hnodup).2.2 have hyU : y ∈ U := by simp [U] have hwV : w ∈ V := by simp [V] have hp (d : Dart n) (hd : d ∈ U ++ V) : p d = (U ++ V).formPerm d := by have he' : MapCycles.orbitList p x = U ++ V := by simpa [U,V,List.append_assoc] using he simpa only [he'] using MapCycles.orbitList_action p x d (he' ▸ hd) have hq (d : Dart n) (hd : d ∈ U) : (swap x z * p) d = U.formPerm d := by change swap x z (p d) = U.formPerm d rw [hp d (List.mem_append_left _ hd)] have hh := congrArg (fun r : Perm (Dart n) => r d) (MapCycles.swap_mul_formPerm_cut x z (L ++ y :: M) (N ++ w :: R) hnodup) change swap x z ((U ++ V).formPerm d) = U.formPerm (V.formPerm d) at hh have hdV : d ∉ V := fun hv => List.disjoint_left.mp (List.disjoint_iff_ne.mpr hdisj) hd hv rw [hh, List.formPerm_apply_of_notMem hdV] have hnot : ¬ (swap x z * p).SameCycle y w := by intro h obtain ⟨k,hk⟩ := h.exists_nat_pow_eq have hh := (MapCycles.pow_eq_on_list (swap x z * p) U hq hyU k).2 rw [hk] at hh exact hdisj w hh w hwV rfl have hh := MapCycles.card_orbits_swap_of_not_sameCycle (swap x z * p) hnot change Nat.card (Orbit (swap x z * p)) = Nat.card (Orbit p) + 1 at hcount change Nat.card (Orbit (swap y w * (swap x z * p))) + 1 = Nat.card (Orbit (swap x z * p)) at hh omega /-- An orbit-count-maximal matching on a tour has no alternating pair of selected edges. This is the exact combinatorial planarity criterion needed for the two parenthesis families, rather than a topological picture. -/ theorem no_crossing_of_maximal_orbits (a p : Perm (Dart n)) (ha : Function.Involutive a) (A : Finset (Orbit a)) (hmax : Nat.card (Orbit (partialReversal a ha A * p)) = Nat.card (Orbit p) + A.card) (x y : Dart n) (hx : orbit a x ∈ A) (hy : orbit a y ∈ A) (hxy : orbit a x ≠ orbit a y) (L M N R : List (Dart n)) : MapCycles.orbitList p x ≠ x :: (L ++ y :: (M ++ a x :: (N ++ a y :: R))) := by classical intro he let B := (A.erase (orbit a x)).erase (orbit a y) have hxB : orbit a x ∉ B := by simp [B] have hyB : orbit a y ∉ B := by simp [B] have hyxB : orbit a y ∉ insert (orbit a x) B := by simp [hyB, Ne.symm hxy] have hA : A = insert (orbit a y) (insert (orbit a x) B) := by ext e simp only [B,Finset.mem_insert,Finset.mem_erase] constructor · intro hh by_cases he₁ : e=orbit a y · exact Or.inl he₁ by_cases he₂ : e=orbit a x · exact Or.inr (Or.inl he₂) · exact Or.inr (Or.inr ⟨he₁,he₂,hh⟩) · rintro (rfl | rfl | ⟨_,_,hh⟩) <;> assumption have hcard : A.card = B.card + 2 := by rw [hA,Finset.card_insert_of_notMem hyxB,Finset.card_insert_of_notMem hxB] have hP : partialReversal a ha A * p = partialReversal a ha B * (swap y (a y) * (swap x (a x) * p)) := by have hx_yB : orbit a x ∉ insert (orbit a y) B := by simp [hxB,hxy] have hA' : A = insert (orbit a x) (insert (orbit a y) B) := by rw [hA,Finset.insert_comm] rw [hA',partialReversal_insert_orbit a ha _ x hx_yB, partialReversal_insert_orbit a ha _ y hyB] group have hle := card_orbit_partialReversal_mul_le a (swap y (a y) * (swap x (a x) * p)) ha B rw [← hP,crossing_two_swaps p x y (a x) (a y) L M N R he,hmax,hcard] at hle omega /-- For every actual planar map and every one-cycle tour, both edge colours are noncrossing in that tour. -/ theorem planar_tour_no_crossing (M₀ : LabelledMap n) (A : Finset (Orbit M₀.val.1)) (hc : ∀ d e, (M₀.val.2 * partialReversal M₀.val.1 M₀.property.1 A).SameCycle d e) (x y : Dart n) (hx : orbit M₀.val.1 x ∈ A) (hy : orbit M₀.val.1 y ∈ A) (hxy : orbit M₀.val.1 x ≠ orbit M₀.val.1 y) (L M N R : List (Dart n)) : MapCycles.orbitList (M₀.val.2 * partialReversal M₀.val.1 M₀.property.1 A) x ≠ x :: (L ++ y :: (M ++ M₀.val.1 x :: (N ++ M₀.val.1 y :: R))) := by apply no_crossing_of_maximal_orbits M₀.val.1 _ M₀.property.1 A ?_ x y hx hy hxy rw [card_orbit_mul_comm, mul_assoc,partialReversal_self,mul_one] have hv := tour_edge_card M₀ A hc have hp := (card_orbit_eq_one_iff _).mpr hc omega end FKCRT end noncomputable section open Set Equiv Equiv.Perm open scoped BigOperators attribute [local instance] Classical.propDecidable namespace FKCRT variable {n : ℕ} lemma dualRotation_mul (a s : Perm (Dart n)) (ha : Function.Involutive a) : s*a*a=s := by apply Equiv.ext intro d exact congrArg s (ha d) lemma spanningGraph_dual_connected (a s : Perm (Dart n)) (ha : Function.Involutive a) (hc : (spanningGraph a s univ).Connected) : (spanningGraph a (s*a) univ).Connected := by let t := s*a have hreach : ∀ d, (spanningGraph a t univ).Reachable (orbit t 0) (orbit t d) := by apply connected_dart_induction ha hc (P := fun d => (spanningGraph a t univ).Reachable (orbit t 0) (orbit t d)) (SimpleGraph.Reachable.refl _) · exact fun d hd => hd.trans (spanningGraph_reachable_reversal a t d) · intro d hd have he : s d = t (a d) := (congrArg s (ha d)).symm rw [he,orbit_perm] exact hd.trans (spanningGraph_reachable_reversal a t d) refine {preconnected := ?_, nonempty := ⟨orbit t 0⟩} intro v w induction v using Quotient.inductionOn with | h d => induction w using Quotient.inductionOn with | h e => exact (hreach d).symm.trans (hreach e) /-- The combinatorial dual in the dart convention. Choosing the inverse face orientation is unnecessary: this rotation gives the same planar oriented dual after reversing edge darts. -/ def dualLabelledMap (M : LabelledMap n) : LabelledMap n := ⟨(M.val.1,M.val.2*M.val.1),M.property.1,M.property.2.1, spanningGraph_dual_connected M.val.1 M.val.2 M.property.1 M.property.2.2.1,by rw [dualRotation_mul _ _ M.property.1] exact (Nat.add_comm _ _).trans M.property.2.2.2⟩ lemma dual_tour (a s : Perm (Dart n)) (ha : Function.Involutive a) (A : Finset (Orbit a)) : (s*a)*partialReversal a ha Aᶜ=s*partialReversal a ha A := by rw [← partialReversal_compl a ha A] apply Equiv.ext intro d simp only [mul_apply,partialReversal_apply,orbit_perm] by_cases h : orbit a d ∈ A · simp only [h,ite_true] rw [ha] · simp only [h,ite_false] rw [ha] theorem planar_tour_compl_card (M : LabelledMap n) (A : Finset (Orbit M.val.1)) (hc : ∀ d e, (M.val.2 * partialReversal M.val.1 M.property.1 A).SameCycle d e) : Nat.card (Orbit (M.val.2*M.val.1))=Aᶜ.card+1 := by apply tour_edge_card (dualLabelledMap M) Aᶜ change ∀ d e, (M.val.2*M.val.1*partialReversal M.val.1 M.property.1 Aᶜ).SameCycle d e rw [dual_tour M.val.1 M.val.2 M.property.1 A] exact hc /-- The non-tree pairs are noncrossing in precisely the same rooted tour order, proved via actual dual rotation systems rather than a disk axiom. -/ theorem planar_tour_compl_no_crossing (M₀ : LabelledMap n) (A : Finset (Orbit M₀.val.1)) (hc : ∀ d e, (M₀.val.2 * partialReversal M₀.val.1 M₀.property.1 A).SameCycle d e) (x y : Dart n) (hx : orbit M₀.val.1 x ∉ A) (hy : orbit M₀.val.1 y ∉ A) (hxy : orbit M₀.val.1 x ≠ orbit M₀.val.1 y) (L M N R : List (Dart n)) : MapCycles.orbitList (M₀.val.2 * partialReversal M₀.val.1 M₀.property.1 A) x ≠ x :: (L ++ y :: (M ++ M₀.val.1 x :: (N ++ M₀.val.1 y :: R))) := by have hh := planar_tour_no_crossing (dualLabelledMap M₀) Aᶜ (by change ∀ d e, (M₀.val.2*M₀.val.1*partialReversal M₀.val.1 M₀.property.1 Aᶜ).SameCycle d e rw [dual_tour M₀.val.1 M₀.val.2 M₀.property.1 A] exact hc) x y (Finset.mem_compl.mpr hx) (Finset.mem_compl.mpr hy) hxy L M N R change MapCycles.orbitList (M₀.val.2*M₀.val.1*partialReversal M₀.val.1 M₀.property.1 Aᶜ) x ≠ x :: (L ++ y :: (M ++ M₀.val.1 x :: (N ++ M₀.val.1 y :: R))) at hh rwa [dual_tour M₀.val.1 M₀.val.2 M₀.property.1 A] at hh end FKCRT end /-! A genuine multigraph spanning tree has one complete edge-reversal tour. This is the converse direction of the source's finite encoding, proved without invoking a topological thickening or assuming planarity. -/ noncomputable section open Set Equiv Equiv.Perm open scoped BigOperators attribute [local instance] Classical.propDecidable namespace FKCRT variable {n : ℕ} lemma spanningGraph_mono (a s : Perm (Dart n)) {A B : Set (Orbit a)} (h : A ⊆ B) : spanningGraph a s A ≤ spanningGraph a s B := by rintro v w ⟨hne, hh | hh⟩ · obtain ⟨d,hd,hv,hw⟩ := hh exact ⟨hne,Or.inl ⟨d,h hd,hv,hw⟩⟩ · obtain ⟨d,hd,hw,hv⟩ := hh exact ⟨hne,Or.inr ⟨d,h hd,hw,hv⟩⟩ lemma spanningGraph_reachable_of_sameCycle (a s : Perm (Dart n)) (ha : Function.Involutive a) (A : Finset (Orbit a)) {d e : Dart n} (h : (s * partialReversal a ha A).SameCycle d e) : (spanningGraph a s (A : Set (Orbit a))).Reachable (orbit s d) (orbit s e) := by obtain ⟨k,hk⟩ := h.exists_nat_pow_eq rw [← hk] clear hk induction k with | zero => exact .refl _ | succ k ih => rw [pow_succ',mul_apply,mul_apply,orbit_perm] exact ih.trans (spanningGraph_reachable_partial a s ha A _) lemma spanningGraph_edgeSet_of_card (a s : Perm (Dart n)) (ha : Function.Involutive a) (A : Finset (Orbit a)) (hc : Nat.card (spanningGraph a s (A : Set (Orbit a))).edgeSet = A.card) : (spanningGraph a s (A : Set (Orbit a))).edgeSet = edgeEnds a s '' (A : Set (Orbit a)) ∧ Set.InjOn (edgeEnds a s) (A : Set (Orbit a)) := by have hh := spanningGraph_edgeSet_subset a s ha A have hi := Set.ncard_image_le (f := edgeEnds a s) (s := (A : Set (Orbit a))) have hec : (spanningGraph a s (A : Set (Orbit a))).edgeSet.ncard = A.card := by simpa only [Nat.card_coe_set_eq] using hc have him : (edgeEnds a s '' (A : Set (Orbit a))).ncard = A.card := by have := Set.ncard_le_ncard hh rw [Set.ncard_coe_finset] at hi omega refine ⟨Set.eq_of_subset_of_ncard_le hh (by omega),?_⟩ apply Set.injOn_of_ncard_image_eq _ A.finite_toSet simpa only [Set.ncard_coe_finset] using him lemma spanningGraph_delete_edge_le (a s : Perm (Dart n)) (ha : Function.Involutive a) {A : Finset (Orbit a)} (e : Orbit a) (he : e ∉ A) (hi : Set.InjOn (edgeEnds a s) ((insert e A : Finset (Orbit a)) : Set (Orbit a))) : spanningGraph a s (A : Set (Orbit a)) ≤ (spanningGraph a s ((insert e A : Finset (Orbit a)) : Set (Orbit a))).deleteEdges {edgeEnds a s e} := by intro v w hvw apply SimpleGraph.deleteEdges_adj.mpr refine ⟨spanningGraph_mono a s (by intro x hx; exact Finset.mem_insert_of_mem hx) hvw,?_⟩ intro heq have hh := spanningGraph_edgeSet_subset a s ha A ((SimpleGraph.mem_edgeSet _).mpr hvw) obtain ⟨f,hf,hfvw⟩ := hh have hfe : f = e := hi (Finset.mem_insert_of_mem hf) (Finset.mem_insert_self _ _) (by exact hfvw.trans (Set.mem_singleton_iff.mp heq)) exact he (hfe ▸ hf) /-- Each chosen forest edge joins two tour cycles, hence the exact cycle count. -/ theorem forest_tour_cycle_card (a s : Perm (Dart n)) (ha : Function.Involutive a) (A : Finset (Orbit a)) (ht : (spanningGraph a s (A : Set (Orbit a))).IsAcyclic) (hn : ∀ e ∈ A, orbit s e.out ≠ orbit s (a e.out)) (hi : Set.InjOn (edgeEnds a s) (A : Set (Orbit a))) : Nat.card (Orbit (s * partialReversal a ha A)) + A.card = Nat.card (Orbit s) := by induction A using Finset.induction_on with | empty => simp [partialReversal_empty] | @insert e A he ih => have hsub : (A : Set (Orbit a)) ⊆ ((insert e A : Finset (Orbit a)) : Set (Orbit a)) := by intro f hf; exact Finset.mem_insert_of_mem hf have htA := ht.anti (spanningGraph_mono a s hsub) have hni : ∀ f ∈ A, orbit s f.out ≠ orbit s (a f.out) := fun f hf => hn f (hsub hf) have hii : Set.InjOn (edgeEnds a s) (A : Set (Orbit a)) := hi.mono hsub have ih' := ih htA hni hii have hedge : (spanningGraph a s ((insert e A : Finset (Orbit a)) : Set (Orbit a))).Adj (orbit s e.out) (orbit s (a e.out)) := by refine ⟨hn e (Finset.mem_insert_self _ _), Or.inl ⟨e.out,?_,rfl,rfl⟩⟩ change orbit a e.out ∈ insert e A rw [show orbit a e.out = e from Quotient.out_eq e] exact Finset.mem_insert_self e A have hbridge := SimpleGraph.isAcyclic_iff_forall_isBridge.mp ht ((SimpleGraph.mem_edgeSet _).mpr hedge) have hnr : ¬(spanningGraph a s (A : Set (Orbit a))).Reachable (orbit s e.out) (orbit s (a e.out)) := by intro hh apply (SimpleGraph.isBridge_iff.mp hbridge) exact hh.mono (spanningGraph_delete_edge_le a s ha e he hi) have hnc : ¬(s * partialReversal a ha A).SameCycle e.out (a e.out) := fun h => hnr (spanningGraph_reachable_of_sameCycle a s ha A h) have hjoin := MapCycles.card_orbits_swap_of_not_sameCycle (s * partialReversal a ha A) (a := (s * partialReversal a ha A) e.out) (b := (s * partialReversal a ha A) (a e.out)) (by simpa only [sameCycle_apply_left, sameCycle_apply_right] using hnc) rw [← mul_swap_eq_swap_mul] at hjoin rw [partialReversal_insert a ha A e he, ← mul_assoc, Finset.card_insert_of_notMem he] change Nat.card (Orbit ((s * partialReversal a ha A) * swap e.out (a e.out))) + (A.card+1) = _ change Nat.card (Orbit ((s * partialReversal a ha A) * swap e.out (a e.out))) + 1 = Nat.card (Orbit (s * partialReversal a ha A)) at hjoin omega /-- No suppressed parallel edge or loop is allowed in a multigraph tree; the cardinality condition records precisely this source convention. -/ theorem spanningTree_one_cycle_tour (a s : Perm (Dart n)) (ha : Function.Involutive a) (A : Finset (Orbit a)) (ht : (spanningGraph a s (A : Set (Orbit a))).IsTree) (hc : Nat.card (spanningGraph a s (A : Set (Orbit a))).edgeSet = A.card) : ∀ d e, (s * partialReversal a ha A).SameCycle d e := by obtain ⟨hedges,hi⟩ := spanningGraph_edgeSet_of_card a s ha A hc have hn : ∀ e ∈ A, orbit s e.out ≠ orbit s (a e.out) := by intro e he have hh : edgeEnds a s e ∈ (spanningGraph a s (A : Set (Orbit a))).edgeSet := hedges.symm ▸ ⟨e,he,rfl⟩ exact ((SimpleGraph.mem_edgeSet _).mp hh).ne have hcount := forest_tour_cycle_card a s ha A ht.isAcyclic hn hi have hcard := (SimpleGraph.isTree_iff_connected_and_card.mp ht).2 apply (card_orbit_eq_one_iff _).mp omega end FKCRT end /-! Exact reconstruction in the rotation-system convention. The Euler equalities on the two coloured matchings are equivalent to their noncrossing property; maximum orbit counts are proved for stack matchings in `WorkNoncrossing`, rather than postulated for a map. -/ noncomputable section open Set Equiv Equiv.Perm open scoped BigOperators attribute [local instance] Classical.propDecidable namespace FKCRT variable {n : ℕ} lemma reconstructed_tour (a t : Perm (Dart n)) (ha : Function.Involutive a) (A : Finset (Orbit a)) : (t * partialReversal a ha A) * partialReversal a ha A = t := by rw [mul_assoc,partialReversal_self,mul_one] lemma reconstructed_face (a t : Perm (Dart n)) (ha : Function.Involutive a) (A : Finset (Orbit a)) : (t * partialReversal a ha A) * a = t * partialReversal a ha Aᶜ := by rw [mul_assoc,partialReversal_compl] /-- Reconstructing a two-coloured noncrossing tour gives a genuine connected planar map, including the empty-tree and all-loop cases. -/ theorem reconstruction_conditions (a t : Perm (Dart n)) (ha : Function.Involutive a) (hf : ∀ d,a d ≠ d) (A : Finset (Orbit a)) (ht : ∀ d e,t.SameCycle d e) (hv : Nat.card (Orbit (t * partialReversal a ha A)) = A.card+1) (hF : Nat.card (Orbit (t * partialReversal a ha Aᶜ)) = Aᶜ.card+1) : MapConditions (a,t * partialReversal a ha A) := by refine ⟨ha,hf,?_,?_⟩ · have hc := spanningGraph_connected_of_tour a (t * partialReversal a ha A) ha A (by simpa only [reconstructed_tour] using ht) exact hc.mono (spanningGraph_mono _ _ (Set.subset_univ _)) · change Nat.card (Orbit (t * partialReversal a ha A)) + Nat.card (Orbit ((t * partialReversal a ha A)*a)) = n+3 rw [reconstructed_face,hv,hF] have hc := Finset.card_add_card_compl A rw [reversal_card a ha hf] at hc omega /-- The inverse is literal permutation multiplication, so it retains the cyclic seam and the designated root dart without any quotient choice. -/ lemma reconstruction_inverse (M : LabelledMap n) (A : Finset (Orbit M.val.1)) : (M.val.2 * partialReversal M.val.1 M.property.1 A) * partialReversal M.val.1 M.property.1 A = M.val.2 := reconstructed_tour M.val.1 M.val.2 M.property.1 A /-- Both maximum orbit counts follow from a genuine map and any genuine spanning tree. Together with reconstruction this is an algebraic form of the classical tree-rooted-map/two-colour matching correspondence. -/ theorem spanningTree_colour_euler (M : LabelledMap n) (A : Finset (Orbit M.val.1)) (ht : (spanningGraph M.val.1 M.val.2 (A : Set (Orbit M.val.1))).IsTree) (hc : Nat.card (spanningGraph M.val.1 M.val.2 (A : Set (Orbit M.val.1))).edgeSet = A.card) : let t := M.val.2 * partialReversal M.val.1 M.property.1 A (∀ d e,t.SameCycle d e) ∧ Nat.card (Orbit (t * partialReversal M.val.1 M.property.1 A)) = A.card+1 ∧ Nat.card (Orbit (t * partialReversal M.val.1 M.property.1 Aᶜ)) = Aᶜ.card+1 := by have hone := spanningTree_one_cycle_tour M.val.1 M.val.2 M.property.1 A ht hc refine ⟨hone,?_,?_⟩ · rw [reconstructed_tour] exact tour_edge_card M A hone · have hh := planar_tour_compl_card M A hone have he := reconstructed_face M.val.1 (M.val.2 * partialReversal M.val.1 M.property.1 A) M.property.1 A rw [reconstructed_tour] at he rw [← he] exact hh end FKCRT end noncomputable section open Set Equiv Equiv.Perm attribute [local instance] Classical.propDecidable namespace FKCRT open MapCycles variable {n : ℕ} /-- Edges of the first colour, in the edge-orbit quotient of the complete matching. -/ def matchingEdges (E F : List (Dart n × Dart n)) : Finset (Orbit (turns (E++F))) := E.toFinset.image (fun e => orbit (turns (E++F)) e.1) lemma mem_matchingEdges (E F : List (Dart n × Dart n)) (hn : (endpoints (E++F)).Nodup) (d : Dart n) : orbit (turns (E++F)) d ∈ matchingEdges E F ↔ d∈endpoints E := by classical simp only [matchingEdges,Finset.mem_image,List.mem_toFinset] constructor · rintro ⟨e,he,hde⟩ have hh : (turns (E++F)).SameCycle e.1 d := Quotient.exact hde rw [MapFinite.sameCycle_involution _ (turns_involutive hn), (turns_pair hn e (List.mem_append_left _ he)).1] at hh exact mem_endpoints.mpr ⟨e,he,hh⟩ · intro hd obtain ⟨e,he,rfl|rfl⟩ := mem_endpoints.mp hd · exact ⟨e,he,rfl⟩ · refine ⟨e,he,?_⟩ apply Quotient.sound apply (MapFinite.sameCycle_involution _ (turns_involutive hn) _ _).mpr exact Or.inr (turns_pair hn e (List.mem_append_left _ he)).1.symm lemma partialReversal_matchingEdges (E F : List (Dart n × Dart n)) (hn : (endpoints (E++F)).Nodup) : partialReversal (turns (E++F)) (turns_involutive hn) (matchingEdges E F)=turns E := by apply Equiv.ext intro d simp only [partialReversal_apply,mem_matchingEdges E F hn] split_ifs with hd · exact (turns_sublist_apply hn (List.sublist_append_left _ _) hd).symm · exact (turns_fixed_of_notMem hd).symm lemma turns_mul_complete (E F : List (Dart n × Dart n)) (hn : (endpoints (E++F)).Nodup) : turns E * turns (E++F)=turns F := by have hE : turns E*turns E=1 := turns_self ((by rw [endpoints_append] at hn; exact hn.of_append_left)) have hF : turns F*turns F=1 := turns_self ((by rw [endpoints_append] at hn; exact hn.of_append_right)) have hEF := turns_self hn have he : turns (E++F)=turns E*turns F := by have h1 : (turns (E++F))⁻¹=turns (E++F) := inv_eq_of_mul_eq_one_left hEF have h2 : (turns E)⁻¹=turns E := inv_eq_of_mul_eq_one_left hE have h3 : (turns F)⁻¹=turns F := inv_eq_of_mul_eq_one_left hF rw [turns_append,mul_inv_rev,h2,h3] at h1 simpa only [turns_append] using h1.symm rw [he,← mul_assoc,hE,one_mul] /-- Two complete noncrossing colour matchings construct an actual planar rotation system in the map model, with no topological assumptions. -/ theorem matching_map_conditions (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)))) : MapConditions (turns (E++F),(List.finRange (2*(n+1))).formPerm * turns E) := by classical let l := List.finRange (2*(n+1)) let t := l.formPerm have hn : (endpoints (E++F)).Nodup := hc.nodup_iff.mpr (List.nodup_finRange _) have ha := turns_involutive hn have hf (d : Dart n) : turns (E++F) d≠d := by intro hh exact (turns_eq_self_iff hn d).mp hh (hc.mem_iff.mpr (List.mem_finRange d)) have ht : ∀ d e,t.SameCycle d e := by intro d e exact sameCycle_of_list t (List.nodup_finRange _) (fun _ _ => rfl) (List.mem_finRange d) (List.mem_finRange e) have htcard : Nat.card (Orbit t)=1 := (card_orbit_eq_one_iff t).mpr ht have hturn : (t*turns E)*partialReversal (turns (E++F)) ha (matchingEdges E F)=t := by rw [partialReversal_matchingEdges E F hn,mul_assoc,turns_self (by rw [endpoints_append] at hn; exact hn.of_append_left)] simp have hconn := spanningGraph_connected_of_tour (turns (E++F)) (t*turns E) ha (matchingEdges E F) (by simpa only [hturn] using ht) refine ⟨ha,hf,hconn.mono (spanningGraph_mono _ _ (Set.subset_univ _)),?_⟩ have he := hE.card_orbits_turns [] t (by simpa using List.nodup_finRange (2*(n+1))) (fun _ _ => rfl) have hff := hF.card_orbits_turns [] t (by simpa using List.nodup_finRange (2*(n+1))) (fun _ _ => rfl) change Nat.card (Orbit (t*turns E)) + Nat.card (Orbit ((t*turns E)*turns (E++F)))=n+3 rw [mul_assoc,turns_mul_complete E F hn,card_orbit_mul_comm t (turns E), card_orbit_mul_comm t (turns F),he,hff,htcard] have hlen := hc.length_eq have hl (Q : List (Dart n × Dart n)) : (endpoints Q).length=2*Q.length := by induction Q with | nil => rfl | cons e Q ih => simp only [endpoints_cons,List.length_cons,ih]; omega rw [hl,List.length_append,List.length_finRange] at hlen omega end FKCRT end end OAI