lean/OAI/Probability/FKMaps/MapEncoding.lean

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<q) (n : ℕ) : 0<partition q n := by
  classical
  unfold partition
  apply Finset.sum_pos
  · intro M _
    apply Finset.sum_pos
    · intro A _
      exact fkWeight_pos hq M A
    · exact Finset.univ_nonempty
  · exact Finset.univ_nonempty

end FKCRT
end



/-! The exact edge-reversal tour of the rotation-system maps. -/
noncomputable section
open Equiv Equiv.Perm Set
open scoped BigOperators
attribute [local instance] Classical.propDecidable
namespace FKCRT
variable {n : ℕ}

private lemma partial_involutive (a : Perm (Dart n)) (ha : Function.Involutive a)
    (A : Finset (Orbit a)) :
    Function.Involutive (fun d => 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