import OAI.Probability.FKMaps.CanonicalBijection

namespace OAI

noncomputable section
open Set Equiv Equiv.Perm
attribute [local instance] Classical.propDecidable
namespace FKCRT
variable {n : ℕ}

def spanningGraphRelabel (r a s : Perm (Dart n)) (A : Set (Orbit a)) :
    spanningGraph (relabelPerm r a) (relabelPerm r s) ((relabelOrbit r a) ⁻¹' A) ≃g
      spanningGraph a s A where
  toEquiv := relabelOrbit r s
  map_rel_iff' := by
    intro v w
    change (_≠_ ∧ _) ↔ (_≠_ ∧ _)
    constructor
    · rintro ⟨hne,(⟨d,hd,hv,hw⟩|⟨d,hd,hw,hv⟩)⟩
      · refine ⟨fun h => hne (by rw [h]),Or.inl ⟨r.symm d,?_,?_,?_⟩⟩
        · simpa using hd
        · apply (relabelOrbit r s).injective
          simpa only [relabelOrbit_apply,relabelPerm_apply,Equiv.apply_symm_apply] using hv
        · apply (relabelOrbit r s).injective
          simpa only [relabelOrbit_apply,relabelPerm_apply,Equiv.apply_symm_apply] using hw
      · refine ⟨fun h => hne (by rw [h]),Or.inr ⟨r.symm d,?_,?_,?_⟩⟩
        · simpa using hd
        · apply (relabelOrbit r s).injective
          simpa only [relabelOrbit_apply,relabelPerm_apply,Equiv.apply_symm_apply] using hw
        · apply (relabelOrbit r s).injective
          simpa only [relabelOrbit_apply,relabelPerm_apply,Equiv.apply_symm_apply] using hv
    · rintro ⟨hne,(⟨d,hd,hv,hw⟩|⟨d,hd,hw,hv⟩)⟩
      · refine ⟨fun h => hne ((relabelOrbit r s).injective h),Or.inl ⟨r d,hd,?_,?_⟩⟩
        · simpa only [relabelOrbit_apply,relabelPerm_apply,Equiv.apply_symm_apply] using congrArg (relabelOrbit r s) hv
        · simpa only [relabelOrbit_apply,relabelPerm_apply,Equiv.apply_symm_apply] using congrArg (relabelOrbit r s) hw
      · refine ⟨fun h => hne ((relabelOrbit r s).injective h),Or.inr ⟨r d,hd,?_,?_⟩⟩
        · simpa only [relabelOrbit_apply,relabelPerm_apply,Equiv.apply_symm_apply] using congrArg (relabelOrbit r s) hw
        · simpa only [relabelOrbit_apply,relabelPerm_apply,Equiv.apply_symm_apply] using congrArg (relabelOrbit r s) hv

lemma mapConditions_relabel (M : LabelledMap n) (r : Perm (Dart n)) :
    MapConditions (relabelPerm r M.val.1,relabelPerm r M.val.2) := by
  refine ⟨relabelPerm_involutive r _ M.property.1,relabelPerm_no_fixed r _ M.property.2.1,?_,?_⟩
  · have hi := spanningGraphRelabel r M.val.1 M.val.2 Set.univ
    have hc := hi.symm.connected_iff.mp M.property.2.2.1
    simpa using hc
  · change Nat.card (Orbit (relabelPerm r M.val.2))+
        Nat.card (Orbit (relabelPerm r M.val.2*relabelPerm r M.val.1))=n+3
    rw [← relabelPerm_mul,card_orbit_relabel,card_orbit_relabel]
    exact M.property.2.2.2

def relabelMap (M : LabelledMap n) (r : Perm (Dart n)) : LabelledMap n :=
  ⟨(relabelPerm r M.val.1,relabelPerm r M.val.2),mapConditions_relabel M r⟩

lemma relabelMap_iso (M : LabelledMap n) (r : Perm (Dart n)) (hr : r 0=0) :
    MapIso (relabelMap M r) M := by
  refine ⟨r,hr,?_,?_⟩ <;> intro d <;>
    simp only [relabelMap,relabelPerm_apply,Equiv.apply_symm_apply]

/-- Actual tree tours put every map/tree pair into the rooted normal form. -/
def canonicalizeTree (M : LabelledMap n) (T : Finset (Orbit M.val.1))
    (hT : T∈treeExtensions M.val.1 M.val.2 ∅ Finset.univ) : CanonicalTreeMap n := by
  let t := M.val.2*partialReversal M.val.1 M.property.1 T
  have ht := treeExtension_tour M.val.1 M.val.2 M.property.1 ∅ Finset.univ T hT
  let r := tourNumbering t ht
  refine ⟨relabelPerm r M.val.1,relabelPerm r M.val.2,relabelEdges r M.val.1 T,
    mapConditions_relabel M r,?_⟩
  rw [partialReversal_relabel r M.val.1 M.property.1 T,← relabelPerm_mul,
    tourNumbering_relabel,formPerm_finRange_eq_rotate]

end FKCRT
end


noncomputable section
open Set Equiv Equiv.Perm
attribute [local instance] Classical.propDecidable
namespace FKCRT
variable {n : ℕ}

lemma sameCycle_intertwine (a b r : Perm (Dart n))
    (hh : ∀ d,b (r d)=r (a d)) (d e : Dart n) :
    a.SameCycle d e ↔ b.SameCycle (r d) (r e) := by
  have hp (k : ℕ) (x : Dart n) : (b^k) (r x)=r ((a^k) x) := by
    induction k with
    | zero => rfl
    | succ k ih => rw [pow_succ',pow_succ',mul_apply,mul_apply,ih,hh]
  constructor
  · intro h
    obtain ⟨k,hk⟩ := h.exists_nat_pow_eq
    refine ⟨(k:ℤ),?_⟩
    simp only [zpow_natCast,hp,hk]
  · intro h
    obtain ⟨k,hk⟩ := h.exists_nat_pow_eq
    refine ⟨(k:ℤ),?_⟩
    rw [zpow_natCast]
    apply r.injective
    rwa [← hp]

def isoOrbit (a b r : Perm (Dart n)) (hh : ∀ d,b (r d)=r (a d)) : Orbit a ≃ Orbit b :=
  Quotient.congr r (sameCycle_intertwine a b r hh)

@[simp] lemma isoOrbit_apply (a b r : Perm (Dart n)) (hh : ∀ d,b (r d)=r (a d)) (d : Dart n) :
    isoOrbit a b r hh (orbit a d)=orbit b (r d) := rfl

lemma partialReversal_intertwine (a b r : Perm (Dart n))
    (ha : Function.Involutive a) (hb : Function.Involutive b)
    (hh : ∀ d,b (r d)=r (a d)) (A : Finset (Orbit a)) (B : Finset (Orbit b))
    (hAB : ∀ d,orbit a d∈A ↔ orbit b (r d)∈B) (d : Dart n) :
    partialReversal b hb B (r d)=r (partialReversal a ha A d) := by
  simp only [partialReversal_apply]
  by_cases hd : orbit a d∈A
  · rw [ite_eq_left hd,ite_eq_left ((hAB d).mp hd),hh]
  · rw [ite_eq_right hd,ite_eq_right (fun h => hd ((hAB d).mpr h))]

lemma treeExtension_of_tour (M : LabelledMap n) (A : Finset (Orbit M.val.1))
    (h : ∀ d e,(M.val.2*partialReversal M.val.1 M.property.1 A).SameCycle d e) :
    A∈treeExtensions M.val.1 M.val.2 ∅ Finset.univ := by
  apply (mem_treeExtensions ..).mpr
  exact ⟨Finset.empty_subset _,by simp,multiforest_of_tour M A h,
    spanningGraph_connected_of_tour M.val.1 M.val.2 M.property.1 A h⟩

def CanonicalTreeMap.toMap (X : CanonicalTreeMap n) : LabelledMap n :=
  ⟨(X.a,X.s),X.valid⟩

lemma CanonicalTreeMap.tour_connected (X : CanonicalTreeMap n) :
    ∀ d e,(X.s*partialReversal X.a X.valid.1 X.A).SameCycle d e := by
  rw [X.tour]
  intro d e
  exact MapCycles.sameCycle_of_list _ (List.nodup_finRange _) (fun _ _ => rfl)
    (List.mem_finRange d) (List.mem_finRange e)

lemma CanonicalTreeMap.tree (X : CanonicalTreeMap n) :
    X.A∈treeExtensions X.a X.s ∅ Finset.univ := treeExtension_of_tour X.toMap X.A X.tour_connected

/-- Normalization respects a literal rooted map/tree isomorphism. The root
condition removes the cyclic seam ambiguity, rather than dividing by it. -/
lemma canonicalizeTree_of_iso (M : LabelledMap n) (T : Finset (Orbit M.val.1))
    (hT : T∈treeExtensions M.val.1 M.val.2 ∅ Finset.univ)
    (X : CanonicalTreeMap n) (r : Perm (Dart n)) (hr : r 0=0)
    (ha : ∀ d,M.val.1 (r d)=r (X.a d)) (hs : ∀ d,M.val.2 (r d)=r (X.s d))
    (hA : ∀ d,orbit X.a d∈X.A ↔ orbit M.val.1 (r d)∈T) :
    canonicalizeTree M T hT=X := by
  let t := M.val.2*partialReversal M.val.1 M.property.1 T
  have ht := treeExtension_tour M.val.1 M.val.2 M.property.1 ∅ Finset.univ T hT
  have hp : ∀ d,t (r d)=r ((X.s*partialReversal X.a X.valid.1 X.A) d) := by
    intro d
    change M.val.2 (partialReversal M.val.1 M.property.1 T (r d))=_
    rw [partialReversal_intertwine X.a M.val.1 r X.valid.1 M.property.1 ha X.A T hA,hs]
    rfl
  have he : r=tourNumbering t ht := by
    apply tourNumbering_unique t ht r hr
    intro i
    rw [hp,X.tour,formPerm_finRange_eq_rotate]
  have hea : relabelPerm r M.val.1=X.a := by
    apply Equiv.ext
    intro d
    simp only [relabelPerm_apply,ha,Equiv.symm_apply_apply]
  have hes : relabelPerm r M.val.2=X.s := by
    apply Equiv.ext
    intro d
    simp only [relabelPerm_apply,hs,Equiv.symm_apply_apply]
  subst r
  cases X with
  | mk a s A hv htX =>
    dsimp only at hea hes hA
    unfold canonicalizeTree
    dsimp only
    cases hea
    cases hes
    congr 1
    apply Finset.ext
    intro e
    induction e using Quotient.inductionOn with
    | _ d =>
      change orbit (relabelPerm (tourNumbering t ht) M.val.1) d∈relabelEdges (tourNumbering t ht) M.val.1 T ↔ orbit (relabelPerm (tourNumbering t ht) M.val.1) d∈A
      rw [mem_relabelEdges,relabelOrbit_apply]
      exact (hA d).symm

/-- Each rooted isomorphism class has its actual spanning trees as the fibre
of the canonical tree representation (existence half). -/
lemma canonical_root_fiber_surjective (M : LabelledMap n) (X : CanonicalTreeMap n)
    (h : MapIso X.toMap M) :
    ∃ (T : Finset (Orbit M.val.1)) (hT : T∈treeExtensions M.val.1 M.val.2 ∅ Finset.univ),
      canonicalizeTree M T hT=X := by
  obtain ⟨r,hr,ha,hs⟩ := h
  let e := isoOrbit X.a M.val.1 r ha
  let T := X.A.map e.toEmbedding
  have hA (d : Dart n) : orbit X.a d∈X.A ↔ orbit M.val.1 (r d)∈T := by
    change _ ↔ e (orbit X.a d)∈X.A.map e.toEmbedding
    simp
  have hp (d : Dart n) : (M.val.2*partialReversal M.val.1 M.property.1 T) (r d)=
      r ((X.s*partialReversal X.a X.valid.1 X.A) d) := by
    simp only [mul_apply,partialReversal_intertwine X.a M.val.1 r X.valid.1 M.property.1 ha X.A T hA,hs]
    rfl
  have ht : ∀ d e,(M.val.2*partialReversal M.val.1 M.property.1 T).SameCycle d e := by
    intro d f
    simpa using (sameCycle_intertwine _ _ r hp (r.symm d) (r.symm f)).mp
      (X.tour_connected (r.symm d) (r.symm f))
  have hT := treeExtension_of_tour M T ht
  exact ⟨T,hT,canonicalizeTree_of_iso M T hT X r hr ha hs hA⟩

end FKCRT
end


noncomputable section
open Set Equiv Equiv.Perm
attribute [local instance] Classical.propDecidable
namespace FKCRT
variable {n : ℕ}

lemma canonicalizeTree_iso (M : LabelledMap n) (T : Finset (Orbit M.val.1))
    (hT : T∈treeExtensions M.val.1 M.val.2 ∅ Finset.univ) :
    MapIso (canonicalizeTree M T hT).toMap M := by
  apply relabelMap_iso M _ (tourNumbering_zero _ _)

lemma canonicalizeTree_class (M : RootedMap n) (T : Finset (Edge M))
    (hT : T∈treeExtensions (reversal M) (rotation M) ∅ Finset.univ) :
    (Quotient.mk _ (canonicalizeTree M.out T hT).toMap : RootedMap n)=M := by
  calc
    _=Quotient.mk _ M.out := Quotient.sound (Relation.EqvGen.rel _ _ (canonicalizeTree_iso M.out T hT))
    _=M := Quotient.out_eq M

lemma canonicalizeTree_mem (M : LabelledMap n) (T : Finset (Orbit M.val.1))
    (hT : T∈treeExtensions M.val.1 M.val.2 ∅ Finset.univ) (d : Dart n) :
    orbit (canonicalizeTree M T hT).a d∈(canonicalizeTree M T hT).A ↔
      orbit M.val.1 (tourNumbering (M.val.2*partialReversal M.val.1 M.property.1 T)
        (treeExtension_tour _ _ _ _ _ _ hT) d)∈T := by
  exact mem_relabelEdges _ _ _ _

lemma canonicalizeTree_injective (M : LabelledMap n)
    {T U : Finset (Orbit M.val.1)}
    (hT : T∈treeExtensions M.val.1 M.val.2 ∅ Finset.univ)
    (hU : U∈treeExtensions M.val.1 M.val.2 ∅ Finset.univ)
    (hh : canonicalizeTree M T hT=canonicalizeTree M U hU) : T=U := by
  let X := canonicalizeTree M T hT
  let Y := canonicalizeTree M U hU
  let r := tourNumbering (M.val.2*partialReversal M.val.1 M.property.1 T)
    (treeExtension_tour _ _ _ _ _ _ hT)
  let s := tourNumbering (M.val.2*partialReversal M.val.1 M.property.1 U)
    (treeExtension_tour _ _ _ _ _ _ hU)
  have hr : r 0=0 := tourNumbering_zero _ _
  have hs : s 0=0 := tourNumbering_zero _ _
  have hra (d) : M.val.1 (r d)=r (X.a d) := by
    change _=r (relabelPerm r M.val.1 d)
    simp only [relabelPerm_apply,Equiv.apply_symm_apply]
  have hrs (d) : M.val.2 (r d)=r (X.s d) := by
    change _=r (relabelPerm r M.val.2 d)
    simp only [relabelPerm_apply,Equiv.apply_symm_apply]
  have hsa (d) : M.val.1 (s d)=s (X.a d) := by
    change _=s ((canonicalizeTree M T hT).a d)
    rw [hh]
    change _=s (relabelPerm s M.val.1 d)
    simp only [relabelPerm_apply,Equiv.apply_symm_apply]
  have hss (d) : M.val.2 (s d)=s (X.s d) := by
    change _=s ((canonicalizeTree M T hT).s d)
    rw [hh]
    change _=s (relabelPerm s M.val.2 d)
    simp only [relabelPerm_apply,Equiv.apply_symm_apply]
  have hrs' : r=s := root_isomorphism_unique (M:=X.toMap) (N:=M) hr hra hrs hs hsa hss
  apply Finset.ext
  intro e
  induction e using Quotient.inductionOn with
  | _ d =>
    have hm := congrArg (fun W : CanonicalTreeMap n => orbit W.a (r.symm d)∈W.A) hh
    have hm' : (orbit M.val.1 (r (r.symm d))∈T) ↔ (orbit M.val.1 (s (r.symm d))∈U) :=
      (canonicalizeTree_mem M T hT _).symm.trans ((Iff.of_eq hm).trans (canonicalizeTree_mem M U hU _))
    rw [← hrs'] at hm'
    change orbit M.val.1 d∈T ↔ orbit M.val.1 d∈U
    simpa only [Equiv.apply_symm_apply] using hm'

abbrev RootedSpanningTree (n : ℕ) :=
  Σ M : RootedMap n,{T : Finset (Edge M) // T∈treeExtensions (reversal M) (rotation M) ∅ Finset.univ}

def rootedTreeNormal (x : RootedSpanningTree n) : CanonicalTreeMap n :=
  canonicalizeTree x.1.out x.2.val x.2.property

lemma rootedTreeNormal_bijective : Function.Bijective (@rootedTreeNormal n) := by
  constructor
  · intro x y h
    have hM : x.1=y.1 := (canonicalizeTree_class x.1 x.2.val x.2.property).symm.trans
      ((congrArg (fun W => (Quotient.mk _ W.toMap : RootedMap n)) h).trans
        (canonicalizeTree_class y.1 y.2.val y.2.property))
    cases x with
    | mk M T =>
      cases y with
      | mk N U =>
        dsimp only at hM
        subst N
        have hh := canonicalizeTree_injective M.out T.property U.property h
        have he : T=U := Subtype.ext hh
        subst U
        rfl
  · intro X
    let M : RootedMap n := Quotient.mk _ X.toMap
    have hi : MapIso X.toMap M.out := by
      apply mapIso_eqvGen.mp
      exact @Quotient.exact _ (Relation.EqvGen.setoid (@MapIso n)) X.toMap M.out (Quotient.out_eq M).symm
    obtain ⟨T,hT,hh⟩ := canonical_root_fiber_surjective M.out X hi
    exact ⟨⟨M,⟨T,hT⟩⟩,hh⟩

/-- Actual root-isomorphism classes with actual spanning trees, not labelled
objects divided by an unproved automorphism factor. -/
def rootedCanonicalEquiv (n : ℕ) : RootedSpanningTree n ≃ CanonicalTreeMap n :=
  Equiv.ofBijective rootedTreeNormal rootedTreeNormal_bijective

/-- Exact finite rooted-map/spanning-tree to identified-word correspondence. -/
def rootedWordEquiv (n : ℕ) : RootedSpanningTree n ≃ SuccessfulWord n :=
  (rootedCanonicalEquiv n).trans (canonicalWordEquiv n)

end FKCRT
end


noncomputable section
open Set Equiv Equiv.Perm
attribute [local instance] Classical.propDecidable
namespace FKCRT
variable {n : ℕ}

lemma edge_reachable_rep (a s : Perm (Dart n)) (ha : Function.Involutive a)
    (A : Set (Orbit a)) (d : Dart n) :
    (spanningGraph a s A).Reachable (orbit s (orbit a d).out) (orbit s (a (orbit a d).out)) ↔
      (spanningGraph a s A).Reachable (orbit s d) (orbit s (a d)) := by
  rcases (MapFinite.mk_eq_iff_involution a ha d (orbit a d)).mp rfl with hh|hh
  · conv_rhs => rw [hh]
  · conv_rhs => rw [hh,ha]
    exact ⟨SimpleGraph.Reachable.symm,SimpleGraph.Reachable.symm⟩

lemma relabelEdges_erase (r a : Perm (Dart n)) (A : Finset (Orbit a))
    (e : Orbit (relabelPerm r a)) :
    relabelEdges r a (A.erase (relabelOrbit r a e))=(relabelEdges r a A).erase e := by
  ext f
  simp only [mem_relabelEdges,Finset.mem_erase]
  exact and_congr_left fun _ => not_congr (relabelOrbit r a).injective.eq_iff

lemma fundamentalCross_relabel (r a s : Perm (Dart n)) (ha : Function.Involutive a)
    (T : Finset (Orbit a)) (e f : Orbit (relabelPerm r a)) :
    FundamentalCross (relabelPerm r a) (relabelPerm r s) (relabelEdges r a T) e f ↔
      FundamentalCross a s T (relabelOrbit r a e) (relabelOrbit r a f) := by
  have hr (A : Finset (Orbit a)) (g : Orbit (relabelPerm r a)) :
      (spanningGraph (relabelPerm r a) (relabelPerm r s) (relabelEdges r a A : Set _)).Reachable
        (orbit (relabelPerm r s) g.out) (orbit (relabelPerm r s) (relabelPerm r a g.out)) ↔
      (spanningGraph a s (A : Set _)).Reachable (orbit s (relabelOrbit r a g).out)
        (orbit s (a (relabelOrbit r a g).out)) := by
    induction g using Quotient.inductionOn with
    | _ d =>
      change (spanningGraph (relabelPerm r a) (relabelPerm r s) (relabelEdges r a A : Set _)).Reachable
        (orbit (relabelPerm r s) (orbit (relabelPerm r a) d).out)
        (orbit (relabelPerm r s) (relabelPerm r a (orbit (relabelPerm r a) d).out)) ↔ (spanningGraph a s (A : Set _)).Reachable
        (orbit s (orbit a (r d)).out) (orbit s (a (orbit a (r d)).out))
      rw [edge_reachable_rep (relabelPerm r a) _ (relabelPerm_involutive r a ha),edge_reachable_rep a s ha]
      have he : (relabelEdges r a A : Set _)=(relabelOrbit r a) ⁻¹' (A : Set _) := by ext x; simp
      rw [he]
      have hh := @SimpleGraph.Iso.reachable_iff _ _ _ _ (spanningGraphRelabel r a s (A : Set _))
        (orbit (relabelPerm r s) d) (orbit (relabelPerm r s) (relabelPerm r a d))
      change (spanningGraph a s (A : Set _)).Reachable
        (relabelOrbit r s (orbit (relabelPerm r s) d))
        (relabelOrbit r s (orbit (relabelPerm r s) (relabelPerm r a d))) ↔ _ at hh
      simpa only [relabelOrbit_apply,relabelPerm_apply,Equiv.apply_symm_apply] using hh.symm
  unfold FundamentalCross
  rw [mem_relabelEdges,mem_relabelEdges,← relabelEdges_erase,← relabelEdges_erase,hr,hr]

lemma edgeFirst_rep (a p : Perm (Dart n)) (ha : Function.Involutive a)
    (hp : ∀ d e,p.SameCycle d e) (d : Dart n) :
    edgeFirst a p hp (orbit a d)=min ((tourNumbering p hp).symm d).val
      ((tourNumbering p hp).symm (a d)).val := by
  unfold edgeFirst
  rcases (MapFinite.mk_eq_iff_involution a ha d (orbit a d)).mp rfl with hh|hh
  · conv_rhs => rw [hh]
  · conv_rhs => rw [hh,ha]
    exact min_comm _ _

lemma canonicalizeTree_rank (M : LabelledMap n) (T : Finset (Orbit M.val.1))
    (hT : T∈treeExtensions M.val.1 M.val.2 ∅ Finset.univ)
    (e : Orbit (canonicalizeTree M T hT).a) :
    edgeFirst (canonicalizeTree M T hT).a
      ((canonicalizeTree M T hT).s*partialReversal _ (canonicalizeTree M T hT).valid.1
        (canonicalizeTree M T hT).A) (canonicalizeTree M T hT).tour_connected e =
    edgeFirst M.val.1 (M.val.2*partialReversal M.val.1 M.property.1 T)
      (treeExtension_tour _ _ _ _ _ _ hT)
      (relabelOrbit (tourNumbering (M.val.2*partialReversal M.val.1 M.property.1 T)
        (treeExtension_tour _ _ _ _ _ _ hT)) M.val.1 e) := by
  let p := M.val.2*partialReversal M.val.1 M.property.1 T
  let hp := treeExtension_tour M.val.1 M.val.2 M.property.1 ∅ Finset.univ T hT
  let r := tourNumbering p hp
  let X := canonicalizeTree M T hT
  induction e using Quotient.inductionOn with
  | _ d =>
    have hh := edgeFirst_rep X.a (X.s*partialReversal X.a X.valid.1 X.A)
      X.valid.1 X.tour_connected d
    rw [canonical_tourNumbering _ _ X.tour] at hh
    change edgeFirst X.a (X.s*partialReversal X.a X.valid.1 X.A) X.tour_connected (orbit X.a d)=_
    rw [hh]
    change min d.val ((relabelPerm r M.val.1) d).val = edgeFirst M.val.1 p hp (orbit M.val.1 (r d))
    rw [edgeFirst_rep M.val.1 p M.property.1]
    change min d.val (r.symm (M.val.1 (r d))).val=min (r.symm (r d)).val (r.symm (M.val.1 (r d))).val
    rw [Equiv.symm_apply_apply]

/-- Forced FK exponents are unchanged by the true rooted normal form. -/
theorem canonicalizeTree_activity (M : LabelledMap n) (T : Finset (Orbit M.val.1))
    (hT : T∈treeExtensions M.val.1 M.val.2 ∅ Finset.univ) :
    explorationActivity (canonicalizeTree M T hT).a (canonicalizeTree M T hT).s
      (tourSelector (canonicalizeTree M T hT).a (canonicalizeTree M T hT).s (canonicalizeTree M T hT).valid.1) ∅ Finset.univ
      (canonicalizeTree M T hT).A (Fintype.card (Orbit (canonicalizeTree M T hT).a)) =
    explorationActivity M.val.1 M.val.2 (tourSelector M.val.1 M.val.2 M.property.1) ∅ Finset.univ
      T (Fintype.card (Orbit M.val.1)) := by
  let X := canonicalizeTree M T hT
  let r := tourNumbering (M.val.2*partialReversal M.val.1 M.property.1 T)
    (treeExtension_tour _ _ _ _ _ _ hT)
  rw [tourActivity_eq_card _ _ X.valid.1 _ X.tree,tourActivity_eq_card _ _ M.property.1 _ hT]
  apply Finset.card_equiv (relabelOrbit r M.val.1)
  intro e
  change Orbit X.a at e
  change (e∈Finset.univ.filter (OrderedActive X.a X.s X.A
    (edgeFirst X.a (X.s*partialReversal X.a X.valid.1 X.A) X.tour_connected))) ↔
    ((relabelOrbit r M.val.1 e)∈Finset.univ.filter (OrderedActive M.val.1 M.val.2 T
      (edgeFirst M.val.1 (M.val.2*partialReversal M.val.1 M.property.1 T)
        (treeExtension_tour M.val.1 M.val.2 M.property.1 ∅ Finset.univ T hT))))
  simp only [Finset.mem_filter,Finset.mem_univ,true_and]
  unfold OrderedActive
  constructor
  · intro h f hlt
    have hf := h ((relabelOrbit r M.val.1).symm f)
    rw [canonicalizeTree_rank M T hT e] at hf
    have hrr := canonicalizeTree_rank M T hT ((relabelOrbit r M.val.1).symm f)
    rw [hrr] at hf
    have hef : relabelOrbit (tourNumbering (M.val.2*partialReversal M.val.1 M.property.1 T)
        (treeExtension_tour M.val.1 M.val.2 M.property.1 ∅ Finset.univ T hT)) M.val.1
        ((relabelOrbit r M.val.1).symm f)=f := (relabelOrbit r M.val.1).apply_symm_apply f
    rw [hef] at hf
    exact fun hh => hf hlt ((fundamentalCross_relabel r M.val.1 M.val.2 M.property.1 T e _).mpr
      (by simpa only [Equiv.apply_symm_apply] using hh))
  · intro h f hlt
    rw [canonicalizeTree_rank M T hT e,canonicalizeTree_rank M T hT f] at hlt
    exact fun hh => h _ hlt ((fundamentalCross_relabel r M.val.1 M.val.2 M.property.1 T e f).mp hh)

end FKCRT
end

end OAI