import OAI.Probability.FKMaps.MapCycles

namespace OAI

noncomputable section
open Equiv Equiv.Perm
open scoped BigOperators
namespace FKCRT.MapCycles
variable {α : Type*} [DecidableEq α]

/-- Ordered stack matching, with unpaired positions allowed. The skipped
positions will be endpoints of the other colour in the map tour. -/
inductive Arches : List α → List (α × α) → Prop
  | nil : Arches [] []
  | skip (a : α) {l E} : Arches l E → Arches (a :: l) E
  | pair (a b : α) {L R E F} : Arches L E → Arches R F →
      Arches (a :: (L ++ b :: R)) ((a,b) :: (E ++ F))

/-- Left transpositions in traversal order. -/
def turns : List (α × α) → Perm α
  | [] => 1
  | (a,b) :: E => turns E * swap a b

@[simp] lemma turns_nil : turns ([] : List (α × α)) = 1 := rfl
@[simp] lemma turns_cons (e : α × α) (E) :
    turns (e :: E) = turns E * swap e.1 e.2 := by cases e; rfl

lemma turns_append (E F : List (α × α)) :
    turns (E ++ F) = turns F * turns E := by
  induction E with
  | nil => simp
  | cons e E ih => simp only [List.cons_append,turns_cons,ih,mul_assoc]

omit [DecidableEq α] in
lemma Arches.endpoints {l : List α} {E} (h : Arches l E) :
    ∀ e ∈ E, e.1 ∈ l ∧ e.2 ∈ l := by
  induction h with
  | nil => simp
  | skip a h ih =>
    intro e he
    exact ⟨List.mem_cons_of_mem _ (ih e he).1,List.mem_cons_of_mem _ (ih e he).2⟩
  | pair a b hL hR ihL ihR =>
    intro e he
    rcases List.mem_cons.mp he with he | he
    · subst e
      simp
    · rcases List.mem_append.mp he with he | he
      · exact ⟨by simp [(ihL e he).1],by simp [(ihL e he).2]⟩
      · exact ⟨by simp [(ihR e he).1],by simp [(ihR e he).2]⟩

lemma turns_fixed (E : List (α × α)) {x : α}
    (hx : ∀ e ∈ E, x ≠ e.1 ∧ x ≠ e.2) : turns E x = x := by
  induction E with
  | nil => rfl
  | cons e E ih =>
    rw [turns_cons,mul_apply,swap_apply_of_ne_of_ne (hx e List.mem_cons_self).1
      (hx e List.mem_cons_self).2]
    exact ih (fun e he => hx e (List.mem_cons_of_mem _ he))

lemma Arches.turns_fixed {l : List α} {E} (h : Arches l E) {x : α} (hx : x ∉ l) :
    turns E x = x := by
  apply FKCRT.MapCycles.turns_fixed
  intro e he
  exact ⟨fun hh => hx (hh ▸ (h.endpoints e he).1),
    fun hh => hx (hh ▸ (h.endpoints e he).2)⟩

lemma formPerm_append_comm (L R : List α) (hn : (L ++ R).Nodup) :
    (L ++ R).formPerm = (R ++ L).formPerm := by
  have h : (L ++ R).rotate L.length = R ++ L := by simp
  rw [← h,List.formPerm_rotate _ hn]

lemma cut_local_action (p : Perm α) (a b : α) (L R : List α)
    (hn : ((a :: L) ++ (b :: R)).Nodup)
    (hp : ∀ x ∈ (a :: L) ++ (b :: R), p x = ((a :: L) ++ (b :: R)).formPerm x) :
    (∀ x ∈ a :: L, (swap a b * p) x = (a :: L).formPerm x) ∧
    (∀ x ∈ b :: R, (swap a b * p) x = (b :: R).formPerm x) := by
  have hd : List.Disjoint (a :: L) (b :: R) :=
    List.disjoint_iff_ne.mpr (List.nodup_append.mp hn).2.2
  constructor
  · intro x hx
    have hxr : x ∉ b :: R := fun hh => List.disjoint_left.mp hd hx hh
    have hh := congrArg (fun u : Perm α => u x) (swap_mul_formPerm_cut a b L R hn)
    simpa only [mul_apply,hp x (List.mem_append_left _ hx),List.cons_append,
      List.formPerm_apply_of_notMem hxr] using hh
  · intro x hx
    have hxl : (b :: R).formPerm x ∉ a :: L := fun hh =>
      List.disjoint_left.mp hd hh (List.formPerm_apply_mem_of_mem hx)
    have hh := congrArg (fun u : Perm α => u x) (swap_mul_formPerm_cut a b L R hn)
    simpa only [mul_apply,hp x (List.mem_append_right _ hx),List.cons_append,
      List.formPerm_apply_of_notMem hxl] using hh

/-- Stack/noncrossing chords attain the maximum possible cycle count.
The unused initial string is arbitrary, so this also handles skipped darts
and the end/start seam of a rooted tour. -/
theorem Arches.card_orbits_turns [Fintype α] {l : List α} {E}
    (h : Arches l E) (Z : List α) (p : Perm α)
    (hn : (Z ++ l).Nodup)
    (hp : ∀ x ∈ Z ++ l, p x = (Z ++ l).formPerm x) :
    Nat.card (Orbits (turns E * p)) = Nat.card (Orbits p) + E.length := by
  induction h generalizing Z p with
  | nil => simp
  | @skip a l E h ih =>
    have he : Z ++ a :: l = (Z ++ [a]) ++ l := by simp
    exact ih (Z ++ [a]) p (he ▸ hn) (by simpa only [he] using hp)
  | @pair a b L R E F hL hR ihL ihR =>
    let C := (a :: L) ++ (b :: (R ++ Z))
    have hC : C.Nodup := by
      change ((a :: L) ++ (b :: (R ++ Z))).Nodup
      simpa only [List.cons_append,List.append_assoc] using
        (List.nodup_append_comm.mp hn)
    have he : (Z ++ a :: (L ++ b :: R)).formPerm = C.formPerm := by
      rw [formPerm_append_comm _ _ hn]
      simp only [C,List.cons_append,List.append_assoc]
    have hpC (x : α) (hx : x ∈ C) : p x = C.formPerm x := by
      rw [← he]
      apply hp
      simpa only [C,List.mem_append,List.mem_cons,or_assoc,or_comm,or_left_comm] using hx
    have hab : a ≠ b := fun h => hC.notMem (by simp [h])
    have hsame : p.SameCycle a b := sameCycle_of_list p hC hpC (by simp [C]) (by simp [C])
    have hzero := card_orbits_swap_of_sameCycle p hab hsame
    have hcut := cut_local_action p a b L (R ++ Z) hC hpC
    have hnL : ([a] ++ L).Nodup := (List.nodup_append.mp hC).1
    have hE := ihL [a] (swap a b * p) hnL hcut.1
    have hnR : ((Z ++ [b]) ++ R).Nodup := by
      have ht := (List.nodup_append.mp hC).2.1
      have hh : (b :: (R ++ Z)) = (b :: R) ++ Z := by simp
      rw [hh] at ht
      simpa only [List.append_assoc,List.singleton_append] using
        (List.nodup_append_comm.mp ht)
    have hother (x : α) (hx : x ∈ (Z ++ [b]) ++ R) :
        (turns E * (swap a b * p)) x = ((Z ++ [b]) ++ R).formPerm x := by
      have hxR : x ∈ b :: (R ++ Z) := by
        simpa only [List.mem_append,List.mem_cons,List.mem_singleton,List.not_mem_nil,or_false,false_or,or_assoc,or_comm,
          or_left_comm] using hx
      have hpx := hcut.2 x hxR
      have hpxR : (swap a b * p) x ∈ b :: (R ++ Z) := by
        rw [hpx]; exact List.formPerm_apply_mem_of_mem hxR
      have hnLR := (List.nodup_append.mp hC).2.2
      have hnot : (swap a b * p) x ∉ L := fun hh =>
        hnLR _ (List.mem_cons_of_mem _ hh) _ hpxR rfl
      rw [mul_apply,hL.turns_fixed hnot,hpx]
      have ht : (Z ++ (b :: R)).Nodup := by simpa using hnR
      have hh := formPerm_append_comm Z (b :: R) ht
      simpa only [List.append_assoc,List.singleton_append,List.cons_append,List.nil_append] using
        (congrArg (fun u : Perm α => u x) hh).symm
    have hF := ihR (Z ++ [b]) (turns E * (swap a b * p)) hnR hother
    simp only [turns_cons,turns_append,List.length_cons,List.length_append]
    rw [mul_assoc,mul_assoc,hF,hE,hzero]
    omega

end FKCRT.MapCycles
end


noncomputable section
open List
namespace FKCRT.MapCycles
variable {α : Type*}

lemma Arches.append {l r : List α} {E F : List (α×α)}
    (h : Arches l E) (h' : Arches r F) : Arches (l++r) (E++F) := by
  induction h with
  | nil => simpa using h'
  | skip a h ih => simpa using Arches.skip a ih
  | pair a b hL hR ihL ihR =>
    simpa only [List.cons_append,List.append_assoc] using Arches.pair a b hL ihR

lemma Arches.empty (l : List α) : Arches l [] := by
  induction l with
  | nil => exact .nil
  | cons a l ih => exact .skip a ih

lemma cons_sublist_split {a : α} {l r : List α} (h : a::l<+r) :
    ∃ s t,r=s++a::t ∧ l<+t := by
  induction r with
  | nil => simp at h
  | cons b r ih =>
    cases h with
    | cons _ h =>
      obtain ⟨s,t,rfl,ht⟩ := ih h
      exact ⟨b::s,t,rfl,ht⟩
    | cons_cons _ h => exact ⟨[],r,rfl,h⟩

lemma Arches.mono {l r : List α} {E : List (α×α)} (h : Arches l E)
    (hlr : l<+r) : Arches r E := by
  induction h generalizing r with
  | nil => exact Arches.empty r
  | skip a h ih => exact ih (List.sublist_of_cons_sublist hlr)
  | pair a b hL hR ihL ihR =>
    obtain ⟨S,T,rfl,hT⟩ := cons_sublist_split hlr
    obtain ⟨U,V,rfl,hU,hV⟩ := List.append_sublist_iff.mp hT
    obtain ⟨Q,R,rfl,hR'⟩ := cons_sublist_split hV
    have hu := (ihL hU).append (Arches.empty Q)
    have hp := Arches.pair a b (by simpa using hu) (ihR hR')
    have hf := (Arches.empty S).append hp
    simpa only [List.nil_append,List.append_nil,List.append_assoc] using hf

/-- Flatten the pair endpoints without imposing an artificial pair order. -/
def endpoints (E : List (α×α)) : List α := E.flatMap (fun e => [e.1,e.2])

@[simp] lemma endpoints_nil : endpoints ([] : List (α×α))=[] := rfl
@[simp] lemma endpoints_cons (e : α×α) (E : List (α×α)) :
    endpoints (e::E)=e.1::e.2::endpoints E := rfl
lemma endpoints_append (E F : List (α×α)) : endpoints (E++F)=endpoints E++endpoints F := by
  simp [endpoints]

/-- Every Dyck path, on an arbitrary ordered list of positions, has a complete
noncrossing arch pairing. This is a constructive existence statement, not a
planarity assumption on a map. -/
theorem dyck_arches (p : DyckWord) (l : List α) (f : α→DyckStep)
    (hl : l.map f=p.toList) :
    ∃ E : List (α×α), Arches l E ∧ (endpoints E).Perm l ∧
      ∀ e∈E,f e.1=.U ∧ f e.2=.D := by
  induction hp : p.semilength using Nat.strong_induction_on generalizing p l with
  | h n ih =>
    by_cases hz : p=0
    · subst p
      have hm : l.map f=[] := hl
      have hn : l=[] := List.map_eq_nil_iff.mp hm
      subst l
      exact ⟨[],.nil,.refl _,by simp⟩
    · have hdec := p.nest_insidePart_add_outsidePart hz
      have he : p.toList = DyckStep.U::(p.insidePart.toList++DyckStep.D::p.outsidePart.toList) := by
        have hh := (congrArg DyckWord.toList hdec).symm
        change p.toList = ([DyckStep.U]++p.insidePart.toList++[DyckStep.D])++p.outsidePart.toList at hh
        simpa only [List.append_assoc,List.singleton_append,List.cons_append,List.nil_append] using hh
      cases l with
      | nil => rw [he] at hl; simp at hl
      | cons a l =>
        rw [he,List.map_cons,List.cons.injEq] at hl
        obtain ⟨ha,hl⟩ := hl
        have hlen : p.insidePart.toList.length<l.length := by
          have hc := congrArg List.length hl
          simp only [List.length_map,List.length_append,List.length_cons] at hc
          omega
        let j := p.insidePart.toList.length
        let L := l.take j
        let b := l[j]
        let R := l.drop (j+1)
        have hl' : l=L++b::R := by
          dsimp [L,b,R,j]
          rw [← List.drop_eq_getElem_cons hlen,List.take_append_drop]
        have hL : L.map f=p.insidePart.toList := by
          dsimp [L,j]
          rw [List.map_take,hl,List.take_append_of_le_length (by rfl)]
          simp
        have hBR : (b::R).map f=DyckStep.D::p.outsidePart.toList := by
          rw [hl',List.map_append,hL] at hl
          exact List.append_cancel_left hl
        simp only [List.map_cons,List.cons.injEq] at hBR
        obtain ⟨hb,hR⟩ := hBR
        obtain ⟨E,hE,hEp,hEf⟩ := ih p.insidePart.semilength
          (by rw [← hp]; exact p.semilength_insidePart_lt hz) _ _ hL rfl
        obtain ⟨F,hF,hFp,hFf⟩ := ih p.outsidePart.semilength
          (by rw [← hp]; exact p.semilength_outsidePart_lt hz) _ _ hR rfl
        refine ⟨(a,b)::(E++F),?_,?_,?_⟩
        · rw [hl']; exact Arches.pair a b hE hF
        · rw [endpoints_cons,endpoints_append,hl']
          have hh := hEp.append hFp
          exact (hh.cons b |>.cons a).trans (List.Perm.cons a (List.perm_middle.symm))
        · intro e he
          rcases List.mem_cons.mp he with rfl | he
          · exact ⟨ha,hb⟩
          · rcases List.mem_append.mp he with he | he
            · exact hEf e he
            · exact hFf e he

end FKCRT.MapCycles
end


noncomputable section
open List Equiv Equiv.Perm
namespace FKCRT.MapCycles
variable {α : Type*} [DecidableEq α]

omit [DecidableEq α] in
lemma mem_endpoints {x : α} {E : List (α×α)} :
    x∈endpoints E ↔ ∃ e∈E,x=e.1 ∨ x=e.2 := by
  simp [endpoints,List.mem_flatMap]

lemma turns_fixed_of_notMem {E : List (α×α)} {x : α} (h : x∉endpoints E) :
    turns E x=x := by
  apply turns_fixed
  intro e he
  exact ⟨fun hh => h (mem_endpoints.mpr ⟨e,he,Or.inl hh⟩),
    fun hh => h (mem_endpoints.mpr ⟨e,he,Or.inr hh⟩)⟩

lemma turns_pair {E : List (α×α)} (hn : (endpoints E).Nodup) :
    ∀ e∈E,turns E e.1=e.2 ∧ turns E e.2=e.1 := by
  induction E with
  | nil => simp
  | cons e E ih =>
    obtain ⟨a,b⟩ := e
    simp only [endpoints_cons,List.nodup_cons] at hn
    have ha : a∉endpoints E := fun h => hn.1 (List.mem_cons_of_mem _ h)
    have hb : b∉endpoints E := hn.2.1
    intro e he
    rcases List.mem_cons.mp he with he | he
    · subst e
      constructor
      · rw [turns_cons,mul_apply,swap_apply_left,turns_fixed_of_notMem hb]
      · rw [turns_cons,mul_apply,swap_apply_right,turns_fixed_of_notMem ha]
    · have h1 := mem_endpoints.mpr ⟨e,he,Or.inl rfl⟩
      have h2 := mem_endpoints.mpr ⟨e,he,Or.inr rfl⟩
      have h1a : e.1≠a := fun hh => ha (hh ▸ h1)
      have h1b : e.1≠b := fun hh => hb (hh ▸ h1)
      have h2a : e.2≠a := fun hh => ha (hh ▸ h2)
      have h2b : e.2≠b := fun hh => hb (hh ▸ h2)
      simpa only [turns_cons,mul_apply,swap_apply_of_ne_of_ne h1a h1b,
        swap_apply_of_ne_of_ne h2a h2b] using ih hn.2.2 e he

omit [DecidableEq α] in
lemma endpoints_pair_ne {E : List (α×α)} (hn : (endpoints E).Nodup)
    {e : α×α} (he : e∈E) : e.1≠e.2 := by
  have hp : [e.1,e.2]<+endpoints E := by
    obtain ⟨L,R,rfl⟩ := List.mem_iff_append.mp he
    simp only [endpoints_append,endpoints_cons]
    exact (show [e.1,e.2] <+ [e.1,e.2]++endpoints R from List.sublist_append_left _ _).trans
      (show e.1::e.2::endpoints R <+ endpoints L++e.1::e.2::endpoints R from List.sublist_append_right _ _)
  have hh := hn.sublist hp
  simpa using hh

lemma turns_involutive {E : List (α×α)} (hn : (endpoints E).Nodup) :
    Function.Involutive (turns E) := by
  intro x
  by_cases hx : x∈endpoints E
  · obtain ⟨e,he,rfl|rfl⟩ := mem_endpoints.mp hx
    · rw [(turns_pair hn e he).1,(turns_pair hn e he).2]
    · rw [(turns_pair hn e he).2,(turns_pair hn e he).1]
  · rw [turns_fixed_of_notMem hx,turns_fixed_of_notMem hx]

lemma turns_self {E : List (α×α)} (hn : (endpoints E).Nodup) : turns E*turns E=1 := by
  apply Equiv.ext
  exact turns_involutive hn

lemma turns_eq_self_iff {E : List (α×α)} (hn : (endpoints E).Nodup) (x : α) :
    turns E x=x ↔ x∉endpoints E := by
  constructor
  · intro h hx
    obtain ⟨e,he,rfl|rfl⟩ := mem_endpoints.mp hx
    · exact endpoints_pair_ne hn he (h.symm.trans (turns_pair hn e he).1)
    · exact endpoints_pair_ne hn he ((turns_pair hn e he).2.symm.trans h)
  · exact turns_fixed_of_notMem

lemma turns_mem_iff {E : List (α×α)} (hn : (endpoints E).Nodup) (x : α) :
    turns E x∈endpoints E ↔ x∈endpoints E := by
  by_cases hx : x∈endpoints E
  · simp only [hx,iff_true]
    obtain ⟨e,he,rfl|rfl⟩ := mem_endpoints.mp hx
    · rw [(turns_pair hn e he).1]; exact mem_endpoints.mpr ⟨e,he,Or.inr rfl⟩
    · rw [(turns_pair hn e he).2]; exact mem_endpoints.mpr ⟨e,he,Or.inl rfl⟩
  · simp [turns_fixed_of_notMem hx,hx]

lemma turns_sublist_apply {E F : List (α×α)} (hn : (endpoints F).Nodup)
    (hEF : E<+F) {x : α} (hx : x∈endpoints E) : turns E x=turns F x := by
  have hs : (endpoints E)<+(endpoints F) := hEF.flatMap _
  have he := hn.sublist hs
  obtain ⟨e,he',rfl|rfl⟩ := mem_endpoints.mp hx
  · rw [(turns_pair he e he').1,(turns_pair hn e (hEF.subset he')).1]
  · rw [(turns_pair he e he').2,(turns_pair hn e (hEF.subset he')).2]

end FKCRT.MapCycles
end

end OAI