import OAI.Probability.FKMaps.CornerInverse

namespace OAI

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

omit [Fintype α] in
lemma StackMatching.empty_interval_preserves {w : α→TypedLetter} {u v z : List α}
    (M : StackMatching w (u++(v++z))) (hn : (u++(v++z)).Nodup)
    (hv : stackTypedRun (v.map w) []=some []) :
    (∀ d,M.mate d∈v ↔ d∈v) ∧ (∀ d,turns M.first d∈v ↔ d∈v) := by
  have hm (d : α) (hd : d∈v) : turns (M.first++M.second) d∈v := by
    exact empty_interval_matching_closed w u v z hn M.first M.second
      M.first_arches M.second_arches M.covers M.first_types M.second_types hv d hd
  have hn' : (endpoints (M.first++M.second)).Nodup := M.covers.nodup_iff.mpr hn
  exact ⟨turns_sublist_preserves hn' (List.Sublist.refl _) hm,
    turns_sublist_preserves hn' (List.sublist_append_left _ _) hm⟩

omit [Fintype α] in
lemma formPerm_append_comm (v z : List α) (hn : (v++z).Nodup) :
    (v++z).formPerm=(z++v).formPerm := by
  have h := List.formPerm_rotate (v++z) hn v.length
  rw [List.rotate_append_length_eq] at h
  exact h.symm

omit [Fintype α] in
/-- Cutting any nonempty successful insertion interval is a literal
one-vertex split of the original rotation. No random root/rotation is used. -/
lemma StackMatching.empty_interval_rotation {w : α→TypedLetter}
    (u L z : List α) (a b : α) (R : List α)
    (M : StackMatching w (u++((a::L)++z))) (hn : (u++((a::L)++z)).Nodup)
    (hcomp : z++u=b::R) :
    (u++((a::L)++z)).formPerm*turns M.first=
      swap a b*((a::L).formPerm*(b::R).formPerm*turns M.first) := by
  have he : (u++((a::L)++z)).formPerm=((a::L)++(b::R)).formPerm := by
    rw [formPerm_append_comm u _ hn,List.append_assoc,hcomp]
  have hh : ((a::L)++(b::R)).Nodup := by
    rw [← hcomp,← List.append_assoc]
    exact (List.perm_append_comm).nodup_iff.mp hn
  rw [he]
  have h := formPerm_cut a b L R (by simpa only [List.cons_append] using hh)
  change (a::(L++b::R)).formPerm*turns M.first=_
  rw [h]
  simp only [mul_assoc]

/-- The two graph pieces retain every edge, including both matching colours.
This is the actual all-edge graph at an arbitrary insertion interval. -/
def StackMatching.empty_interval_wedge {w : α→TypedLetter}
    (u L z : List α) (a b : α) (R : List α)
    (M : StackMatching w (u++((a::L)++z))) (hn : (u++((a::L)++z)).Nodup)
    (hv : stackTypedRun ((a::L).map w) []=some []) (hcomp : z++u=b::R) :
    let p := (a::L).formPerm*(b::R).formPerm*turns M.first
    let S : Set α := {d | d∈a::L}
    GraphWedge.Data (sideGraph M.mate p S (M.empty_interval_preserves hn hv).1)
      (sideGraph M.mate p Sᶜ (fun d => not_congr ((M.empty_interval_preserves hn hv).1 d)))
      (dartGraph M.mate (swap a b*p)) := by
  let S : Set α := {d | d∈a::L}
  let p := (a::L).formPerm*(b::R).formPerm*turns M.first
  have hh : ((a::L)++(b::R)).Nodup := by
    rw [← hcomp,← List.append_assoc]
    exact List.perm_append_comm.nodup_iff.mp hn
  have hd : (a::L).Disjoint (b::R) := List.disjoint_iff_ne.mpr (List.nodup_append.mp hh).2.2
  have hpres := M.empty_interval_preserves hn hv
  have hp : ∀ d,p d∈S ↔ d∈S := by
    intro d
    simp only [p,S,Set.mem_ofPred_eq,mul_apply,List.formPerm_mem_iff_mem,
      formPerm_other_mem_iff hd,hpres.2]
  exact PermutationWedge.data hp (by simp [S])
    (fun hb => List.disjoint_left.mp hd hb (by simp)) hpres.1

/-- The first dart following the successful subword and its first dart are
literally in the same original rotation vertex. This is the pole identity. -/
theorem StackMatching.empty_interval_pole {w : α→TypedLetter}
    (u L z : List α) (a b : α) (R : List α)
    (M : StackMatching w (u++((a::L)++z))) (hn : (u++((a::L)++z)).Nodup)
    (hv : stackTypedRun ((a::L).map w) []=some []) (hcomp : z++u=b::R) :
    vertex ((u++((a::L)++z)).formPerm*turns M.first) a=
      vertex ((u++((a::L)++z)).formPerm*turns M.first) b := by
  rw [M.empty_interval_rotation u L z a b R hn hcomp]
  let D := M.empty_interval_wedge u L z a b R hn hv hcomp
  have hD := D.shared
  dsimp only [D,StackMatching.empty_interval_wedge,PermutationWedge.data,
    PermutationWedge.inclusionHom,PermutationWedge.flipInclusionHom,
    PermutationWedge.inclusion,PermutationWedge.flipInclusion,sideMk] at hD
  exact hD

end FKCRT.Inventory
end


noncomputable section
open Equiv Equiv.Perm
namespace FKCRT.PermutationWedge
variable {α : Type*} [Fintype α]
attribute [local instance] Classical.propDecidable

lemma sameCycle_congr_on {p q : Perm α} {S : Set α}
    (hp : ∀ d,p d∈S ↔ d∈S) (_hq : ∀ d,q d∈S ↔ d∈S)
    (he : ∀ d∈S,p d=q d) {x y : α} (hx : x∈S) :
    p.SameCycle x y ↔ q.SameCycle x y := by
  have hpow : ∀ n : ℕ,(p^n) x=(q^n) x ∧ (p^n) x∈S := by
    intro n
    induction n with
    | zero => simpa using hx
    | succ n ih =>
      simp only [pow_succ',mul_apply]
      exact ⟨(he _ ih.2).trans (congrArg q ih.1),(hp _).mpr ih.2⟩
  constructor
  · intro h
    obtain ⟨n,hn⟩ := h.exists_nat_pow_eq
    exact ⟨(n:ℤ),by simpa only [zpow_natCast] using (hpow n).1.symm.trans hn⟩
  · intro h
    obtain ⟨n,hn⟩ := h.exists_nat_pow_eq
    exact ⟨(n:ℤ),by simpa only [zpow_natCast] using (hpow n).1.trans hn⟩

/-- Changing the ambient permutation off a retained invariant dart set does
not change its actual rotation vertices. -/
def sideCongr {p q : Perm α} {S : Set α}
    (hp : ∀ d,p d∈S ↔ d∈S) (hq : ∀ d,q d∈S ↔ d∈S)
    (he : ∀ d∈S,p d=q d) : Side p S ≃ Side q S :=
  Quotient.congrRight (fun x _ => sameCycle_congr_on hp hq he x.property)

lemma sideCongr_mk {p q : Perm α} {S : Set α}
    (hp : ∀ d,p d∈S ↔ d∈S) (hq : ∀ d,q d∈S ↔ d∈S)
    (he : ∀ d∈S,p d=q d) (d : α) (hd : d∈S) :
    sideCongr hp hq he (sideMk p S d hd)=sideMk q S d hd := rfl

/-- The all-edge graph is invariant under restriction/normalization on a
closed set of darts; only the two literal permutation actions are used. -/
def sideGraphCongr {p q e f : Perm α} {S : Set α}
    (hp : ∀ d,p d∈S ↔ d∈S) (hq : ∀ d,q d∈S ↔ d∈S)
    (he : ∀ d,e d∈S ↔ d∈S) (hf : ∀ d,f d∈S ↔ d∈S)
    (hpq : ∀ d∈S,p d=q d) (hef : ∀ d∈S,e d=f d) :
    sideGraph e p S he ≃g sideGraph f q S hf where
  toEquiv := sideCongr hp hq hpq
  map_rel_iff' := by
    intro x y
    constructor
    · rintro ⟨hne,h⟩
      refine ⟨fun h => hne (congrArg (sideCongr hp hq hpq) h),?_⟩
      have transport (x y : Side p S) (d : α) (hd : d∈S)
          (hx : sideMk q S d hd=sideCongr hp hq hpq x)
          (hy : sideMk q S (f d) ((hf d).mpr hd)=sideCongr hp hq hpq y) :
          ∃ d,∃ hd : d∈S,sideMk p S d hd=x ∧ sideMk p S (e d) ((he d).mpr hd)=y := by
        refine ⟨d,hd,(sideCongr hp hq hpq).injective hx,?_⟩
        apply (sideCongr hp hq hpq).injective
        rw [sideCongr_mk]
        simpa only [hef d hd] using hy
      rcases h with ⟨d,hd,hx,hy⟩|⟨d,hd,hy,hx⟩
      · exact Or.inl (transport x y d hd hx hy)
      · exact Or.inr (transport y x d hd hy hx)
    · rintro ⟨hne,h⟩
      refine ⟨fun h => hne ((sideCongr hp hq hpq).injective h),?_⟩
      have transport (x y : Side p S) (d : α) (hd : d∈S)
          (hx : sideMk p S d hd=x) (hy : sideMk p S (e d) ((he d).mpr hd)=y) :
          ∃ d,∃ hd : d∈S,sideMk q S d hd=sideCongr hp hq hpq x ∧
            sideMk q S (f d) ((hf d).mpr hd)=sideCongr hp hq hpq y := by
        refine ⟨d,hd,congrArg (sideCongr hp hq hpq) hx,?_⟩
        have hh := congrArg (sideCongr hp hq hpq) hy
        simpa only [sideCongr_mk,hef d hd] using hh
      rcases h with ⟨d,hd,hx,hy⟩|⟨d,hd,hy,hx⟩
      · exact Or.inl (transport x y d hd hx hy)
      · exact Or.inr (transport y x d hd hy hx)

def fullInclusion (p : Perm α) (S : Set α) : Side p S→Vertex p :=
  Quotient.lift (fun d => vertex p d.val) (fun _ _ h => Quotient.sound h)

omit [Fintype α] in
lemma fullInclusion_mk (p : Perm α) (S : Set α) (d : α) (hd : d∈S) :
    fullInclusion p S (sideMk p S d hd)=vertex p d := rfl

omit [Fintype α] in
lemma fullInclusion_injective (p : Perm α) (S : Set α) :
    Function.Injective (fullInclusion p S) := by
  intro x y
  induction x using Quotient.inductionOn with
  | h x =>
    induction y using Quotient.inductionOn with
    | h y =>
      intro h
      apply Quotient.sound
      change vertex p x.val=vertex p y.val at h
      have hh : p.SameCycle x.val y.val := Quotient.exact h
      exact hh

lemma fullRetract_wellDefined {p : Perm α} {S : Set α}
    (hp : ∀ d,p d∈S ↔ d∈S) (a : α) (ha : a∈S) {x y : α}
    (hxy : p.SameCycle x y) :
    (if hx : x∈S then sideMk p S x hx else sideMk p S a ha)=
      (if hy : y∈S then sideMk p S y hy else sideMk p S a ha) := by
  classical
  have hh := MapCycles.sameCycle_partition hp hxy
  by_cases hx : x∈S
  · rw [dite_eq_left hx,dite_eq_left (hh.mp hx)]
    exact Quotient.sound hxy
  · rw [dite_eq_right hx,dite_eq_right (fun h => hx (hh.mpr h))]

def fullRetract {p : Perm α} {S : Set α}
    (hp : ∀ d,p d∈S ↔ d∈S) (a : α) (ha : a∈S) : Vertex p→Side p S := by
  classical
  exact Quotient.lift (fun d => if hd : d∈S then sideMk p S d hd else sideMk p S a ha)
    (fun _ _ h => fullRetract_wellDefined hp a ha h)

lemma fullRetract_mk {p : Perm α} {S : Set α}
    (hp : ∀ d,p d∈S ↔ d∈S) (a : α) (ha : a∈S) (d : α) :
    fullRetract hp a ha (vertex p d)=
      (if hd : d∈S then sideMk p S d hd else sideMk p S a ha) := by
  classical
  rfl

lemma fullRetract_inclusion {p : Perm α} {S : Set α}
    (hp : ∀ d,p d∈S ↔ d∈S) (a : α) (ha : a∈S) (x : Side p S) :
    fullRetract hp a ha (fullInclusion p S x)=x := by
  induction x using Quotient.inductionOn with
  | h d => exact dite_eq_left d.property

def fullInclusionHom {p e : Perm α} {S : Set α}
    (he : ∀ d,e d∈S ↔ d∈S) : sideGraph e p S he →g dartGraph e p where
  toFun := fullInclusion p S
  map_rel' := by
    intro x y hxy
    refine ⟨fun h => hxy.1 (fullInclusion_injective p S h),?_⟩
    rcases hxy.2 with ⟨d,hd,hx,hy⟩|⟨d,hd,hy,hx⟩
    · exact Or.inl ⟨d,congrArg (fullInclusion p S) hx,congrArg (fullInclusion p S) hy⟩
    · exact Or.inr ⟨d,congrArg (fullInclusion p S) hy,congrArg (fullInclusion p S) hx⟩

lemma fullRetract_edge {p e : Perm α} {S : Set α}
    (hp : ∀ d,p d∈S ↔ d∈S) (he : ∀ d,e d∈S ↔ d∈S) (a : α) (ha : a∈S)
    {x y : Vertex p} (hxy : (dartGraph e p).Adj x y) :
    (sideGraph e p S he).edist (fullRetract hp a ha x) (fullRetract hp a ha y)≤1 := by
  classical
  have forward (d : α) (hne : vertex p d≠vertex p (e d)) :
      (sideGraph e p S he).edist (fullRetract hp a ha (vertex p d))
        (fullRetract hp a ha (vertex p (e d)))≤1 := by
    rw [fullRetract_mk,fullRetract_mk]
    by_cases hd : d∈S
    · rw [dite_eq_left hd,dite_eq_left ((he d).mpr hd)]
      apply (SimpleGraph.edist_eq_one_iff_adj.mpr ?_).le
      refine ⟨fun h => hne (congrArg (fullInclusion p S) h),Or.inl ⟨d,hd,rfl,rfl⟩⟩
    · rw [dite_eq_right hd,dite_eq_right (fun h => hd ((he d).mp h)),SimpleGraph.edist_self]
      exact zero_le_one
  rcases hxy.2 with ⟨d,rfl,rfl⟩|⟨d,rfl,rfl⟩
  · exact forward d hxy.1
  · rw [SimpleGraph.edist_comm]
    exact forward d hxy.1.symm

/-- Other invariant components, including isolated deleted darts, cannot
shorten distances in a retained component. -/
theorem fullInclusion_edist {p e : Perm α} {S : Set α}
    (hp : ∀ d,p d∈S ↔ d∈S) (he : ∀ d,e d∈S ↔ d∈S)
    (x y : Side p S) :
    (dartGraph e p).edist (fullInclusion p S x) (fullInclusion p S y)=
      (sideGraph e p S he).edist x y := by
  apply le_antisymm (GraphWedge.hom_edist_le (fullInclusionHom he) x y)
  obtain ⟨a,ha⟩ := Quotient.exists_rep x
  have h := GraphWedge.retraction_pair_edist_le (sideGraph e p S he)
    (⊥ : SimpleGraph Unit) (dartGraph e p) (fullRetract hp a.val a.property)
    (fun _ => ()) (by
      intro u v huv
      simpa only [SimpleGraph.edist_self,add_zero] using fullRetract_edge hp he a.val a.property huv)
    (fullInclusion p S x) (fullInclusion p S y)
  change (sideGraph e p S he).edist x y≤
    (dartGraph e p).edist (fullInclusion p S x) (fullInclusion p S y)
  simpa only [fullRetract_inclusion,SimpleGraph.edist_self,add_zero] using h

end FKCRT.PermutationWedge
end


noncomputable section
open List Equiv Equiv.Perm
namespace FKCRT.Chords
variable {N K : ℕ}

/-- Reachability lifts through a strictly increasing matching embedding
whenever its image contains the whole component being lifted. -/
theorem reachable_lift (a : Perm (Fin N)) (b : Perm (Fin K))
    (e : Fin K ↪o Fin N) (hmatch : ∀ i,a (e i)=e (b i))
    (r : Opener b)
    (himage : ∀ x : Opener a,(graph a).Reachable (openerEmbedding a b e hmatch r) x →
      x.val∈Set.range e) :
    ∀ x : Opener a,(graph a).Reachable (openerEmbedding a b e hmatch r) x →
      ∃ y : Opener b,openerEmbedding a b e hmatch y=x ∧ (graph b).Reachable r y := by
  intro x hx
  have hh := (SimpleGraph.reachable_iff_reflTransGen _ _).mp hx
  induction hh with
  | refl => exact ⟨r,rfl,SimpleGraph.Reachable.refl r⟩
  | @tail x z hpath hadj ih =>
    obtain ⟨y,hy,hry⟩ := ih ((SimpleGraph.reachable_iff_reflTransGen _ _).mpr hpath)
    have hz : (graph a).Reachable (openerEmbedding a b e hmatch r) z :=
      ((SimpleGraph.reachable_iff_reflTransGen _ _).mpr hpath).trans hadj.reachable
    obtain ⟨v,hv⟩ := opener_range a b e hmatch z (himage z hz)
    refine ⟨v,hv,hry.trans ?_⟩
    apply SimpleGraph.Adj.reachable
    exact (cross_embedding a b e hmatch y v).mp (by rw [hy,hv];exact hadj)

theorem component_compression (a : Perm (Fin N)) (ha : Function.Involutive a) (b : Perm (Fin K))
    (e : Fin K ↪o Fin N) (hmatch : ∀ i,a (e i)=e (b i))
    (r : Opener b)
    (himage : Set.range e={d | d∈componentDarts a (openerEmbedding a b e hmatch r)}) :
    ∀ x : Opener b,(graph b).Reachable r x := by
  intro x
  have hx : (e x.val)∈componentDarts a (openerEmbedding a b e hmatch r) := by
    change e x.val∈({d | d∈componentDarts a (openerEmbedding a b e hmatch r)} : Set (Fin N))
    rw [← himage];exact Set.mem_range_self _
  have hxa : (graph a).Reachable (openerEmbedding a b e hmatch r)
      (openerEmbedding a b e hmatch x) := by
    obtain ⟨y,hy,he|he⟩ := (mem_componentDarts _ _ _).mp hx
    · have hy' : y=openerEmbedding a b e hmatch x := Subtype.ext he.symm
      exact hy' ▸ hy
    · have hxp := e.strictMono x.property
      rw [← hmatch,he] at hxp
      rw [ha] at hxp
      exact False.elim ((not_lt_of_ge y.property.le) hxp)
  obtain ⟨v,hv,hrv⟩ := reachable_lift a b e hmatch r (by
    intro y hy
    rw [himage]
    exact (mem_componentDarts _ _ _).mpr ⟨y,hy,Or.inl rfl⟩)
    (openerEmbedding a b e hmatch x) hxa
  exact (openerEmbedding a b e hmatch).injective hv ▸ hrv

end FKCRT.Chords
end


noncomputable section
open List Equiv Equiv.Perm
namespace FKCRT.Inventory.StackMatching
open MapCycles
variable {α : Type*} [DecidableEq α] {w : α→TypedLetter} {l : List α}

lemma pair_mask (M : StackMatching w l) (hn : l.Nodup) (p : α→Bool)
    (hp : ∀ d∈l,p (M.mate d)=p d) : ∀ e∈M.first++M.second,p e.1=p e.2 := by
  intro e he
  have hh := hp e.1 (M.endpoints_mem e he).1
  rw [mate,(turns_pair (M.covers.nodup_iff.mpr hn) e he).1] at hh
  exact hh.symm

def filter (M : StackMatching w l) (hn : l.Nodup) (p : α→Bool)
    (hp : ∀ d∈l,p (M.mate d)=p d) : StackMatching w (l.filter p) where
  first := M.first.filter (fun e => p e.1)
  second := M.second.filter (fun e => p e.1)
  first_arches := M.first_arches.filter p (fun e he =>
    M.pair_mask hn p hp e (List.mem_append_left _ he))
  second_arches := M.second_arches.filter p (fun e he =>
    M.pair_mask hn p hp e (List.mem_append_right _ he))
  covers := by
    rw [← List.filter_append,endpoints_filter p _ (M.pair_mask hn p hp)]
    exact M.covers.filter p
  first_types := fun e he => M.first_types e (List.mem_filter.mp he).1
  second_types := fun e he => M.second_types e (List.mem_filter.mp he).1

lemma filter_mate (M : StackMatching w l) (hn : l.Nodup) (p : α→Bool)
    (hp : ∀ d∈l,p (M.mate d)=p d) (i : α) (hi : i∈l) (hpi : p i=true) :
    (M.filter hn p hp).mate i=M.mate i := by
  have hnp := M.covers.nodup_iff.mpr hn
  have hnf := (M.filter hn p hp).covers.nodup_iff.mpr (hn.filter p)
  obtain ⟨e,he,rfl|rfl⟩ := mem_endpoints.mp (M.covers.mem_iff.mpr hi)
  · have hmem : e∈(M.filter hn p hp).first++(M.filter hn p hp).second := by
      change e∈M.first.filter (fun e => p e.1)++M.second.filter (fun e => p e.1)
      rw [← List.filter_append]
      exact List.mem_filter.mpr ⟨he,hpi⟩
    exact (turns_pair hnf e hmem).1.trans (turns_pair hnp e he).1.symm
  · have hmem : e∈(M.filter hn p hp).first++(M.filter hn p hp).second := by
      change e∈M.first.filter (fun e => p e.1)++M.second.filter (fun e => p e.1)
      rw [← List.filter_append]
      exact List.mem_filter.mpr ⟨he,(M.pair_mask hn p hp e he).trans hpi⟩
    exact (turns_pair hnf e hmem).2.trans (turns_pair hnp e he).2.symm

end FKCRT.Inventory.StackMatching
end


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

lemma turns_filter_on (E : List (α×α)) (hn : (endpoints E).Nodup)
    (p : α→Bool) (hp : ∀ e∈E,p e.1=p e.2) (d : α) (hd : p d=true) :
    turns (E.filter (fun e => p e.1)) d=turns E d := by
  have hs : E.filter (fun e => p e.1)<+E := List.filter_sublist
  have hn' := hn.sublist (hs.flatMap _)
  by_cases hm : d∈endpoints E
  · obtain ⟨e,he,rfl|rfl⟩ := mem_endpoints.mp hm
    · have hf : e∈E.filter (fun e => p e.1) := List.mem_filter.mpr ⟨he,hd⟩
      exact (turns_pair hn' e hf).1.trans (turns_pair hn e he).1.symm
    · have hf : e∈E.filter (fun e => p e.1) := List.mem_filter.mpr ⟨he,(hp e he).trans hd⟩
      exact (turns_pair hn' e hf).2.trans (turns_pair hn e he).2.symm
  · rw [turns_fixed_of_notMem hm,turns_fixed_of_notMem]
    exact fun h => hm ((hs.flatMap _).subset h)

omit [DecidableEq α] in
lemma perm_preserves_of_fixed {p : Perm α} {S : Set α} (h : ∀ d∈S,p d=d) :
    ∀ d,p d∈S ↔ d∈S := by
  intro d
  constructor
  · intro hd
    have hh : p (p d)=p d := h _ hd
    exact p.injective hh ▸ hd
  · intro hd
    simpa only [h d hd] using hd

end FKCRT.MapCycles
namespace FKCRT.Inventory.StackMatching
open MapCycles
variable {α : Type*} [DecidableEq α] {w : α→TypedLetter} {l : List α}

lemma filter_first (M : StackMatching w l) (hn : l.Nodup) (p : α→Bool)
    (hp : ∀ d∈l,p (M.mate d)=p d) (i : α) (hpi : p i=true) :
    turns (M.filter hn p hp).first i=turns M.first i := by
  have hE : (endpoints M.first).Nodup :=
    (M.covers.nodup_iff.mpr hn).sublist ((List.sublist_append_left _ _).flatMap _)
  exact turns_filter_on M.first hE p (fun e he => M.pair_mask hn p hp e (List.mem_append_left _ he)) i hpi

lemma filter_mate_on (M : StackMatching w l) (hn : l.Nodup) (p : α→Bool)
    (hp : ∀ d∈l,p (M.mate d)=p d) (i : α) (hpi : p i=true) :
    (M.filter hn p hp).mate i=M.mate i := by
  change turns (M.first.filter (fun e => p e.1)++M.second.filter (fun e => p e.1)) i=_
  rw [← List.filter_append]
  exact turns_filter_on _ (M.covers.nodup_iff.mpr hn) p (M.pair_mask hn p hp) i hpi

lemma filter_mate_fixed (M : StackMatching w l) (hn : l.Nodup) (p : α→Bool)
    (hp : ∀ d∈l,p (M.mate d)=p d) (i : α) (hpi : p i=false) :
    (M.filter hn p hp).mate i=i := by
  apply turns_fixed_of_notMem
  intro h
  have hh := (M.filter hn p hp).covers.mem_iff.mp h
  exact Bool.noConfusion (hpi.symm.trans (List.mem_filter.mp hh).2)

lemma filter_first_fixed (M : StackMatching w l) (hn : l.Nodup) (p : α→Bool)
    (hp : ∀ d∈l,p (M.mate d)=p d) (i : α) (hpi : p i=false) :
    turns (M.filter hn p hp).first i=i := by
  apply turns_fixed_of_notMem
  intro h
  have h' : i∈endpoints ((M.filter hn p hp).first++(M.filter hn p hp).second) := by
    rw [endpoints_append]
    exact List.mem_append_left _ h
  have hf := (M.filter hn p hp).covers.mem_iff.mp h'
  exact Bool.noConfusion (hpi.symm.trans (List.mem_filter.mp hf).2)

end FKCRT.Inventory.StackMatching
end


noncomputable section
open List Equiv Equiv.Perm
namespace FKCRT.GraphWedge
lemma iso_edist {α β : Type*} {G : SimpleGraph α} {H : SimpleGraph β}
    (E : G ≃g H) (x y : α) : H.edist (E x) (E y)=G.edist x y := by
  apply le_antisymm (hom_edist_le E.toHom x y)
  simpa using hom_edist_le E.symm.toHom (E x) (E y)
end FKCRT.GraphWedge
namespace FKCRT.Inventory
open MapCycles PermutationWedge
attribute [local instance] Classical.propDecidable
variable {α : Type*} [DecidableEq α] [Fintype α]

omit [Fintype α] in
lemma filter_delete_interval (u v z : List α) (hn : (u++(v++z)).Nodup) :
    (u++(v++z)).filter (fun d => decide (d∉v))=u++z := by
  have hu : u.Disjoint v := List.disjoint_iff_ne.mpr (fun x hx y hy he =>
    (List.nodup_append.mp hn).2.2 x hx y (List.mem_append_left _ hy) he)
  have hz : v.Disjoint z := List.disjoint_iff_ne.mpr
    (List.nodup_append.mp (List.nodup_append.mp hn).2.1).2.2
  simp only [List.filter_append]
  have hfU : u.filter (fun d => decide (d∉v))=u := by
    apply List.filter_eq_self.mpr
    intro d hd
    exact decide_eq_true (fun h => List.disjoint_left.mp hu hd h)
  have hfV : v.filter (fun d => decide (d∉v))=[] := by
    apply List.filter_eq_nil_iff.mpr
    intro d hd
    simp [hd]
  have hfZ : z.filter (fun d => decide (d∉v))=z := by
    apply List.filter_eq_self.mpr
    intro d hd
    exact decide_eq_true (fun h => List.disjoint_left.mp hz h hd)
  rw [hfU,hfV,hfZ,List.nil_append]

/-- The actual retained matching after a successful insertion is erased. -/
def StackMatching.deleteInterval {w : α→TypedLetter} {u v z : List α}
    (M : StackMatching w (u++(v++z))) (hn : (u++(v++z)).Nodup)
    (hv : stackTypedRun (v.map w) []=some []) : StackMatching w (u++z) := by
  have hpres := (M.empty_interval_preserves hn hv).1
  let keep : α→Bool := fun d => decide (d∉v)
  have hk : ∀ d∈u++(v++z),keep (M.mate d)=keep d := by
    intro d _
    simp only [keep,decide_eq_decide]
    exact not_congr (hpres d)
  exact filter_delete_interval u v z hn ▸ M.filter hn keep hk

omit [Fintype α] [DecidableEq α] in
lemma StackMatching.cast_first {w : α→TypedLetter} {l l' : List α}
    (h : l=l') (M : StackMatching w l) : (h ▸ M).first=M.first := by cases h;rfl

/-- Removing any genuine successful interval preserves *all-edge* distances
between retained darts, not just spanning-tree distances. The resulting
rotation is that of the original ordered word with the interval deleted. -/
theorem StackMatching.delete_interval_distance {w : α→TypedLetter}
    (u L z : List α) (a b : α) (R : List α)
    (M : StackMatching w (u++((a::L)++z))) (hn : (u++((a::L)++z)).Nodup)
    (hv : stackTypedRun ((a::L).map w) []=some []) (hcomp : z++u=b::R)
    (x y : α) (hx : x∉a::L) (hy : y∉a::L) :
    let D := M.deleteInterval hn hv
    let s := (u++((a::L)++z)).formPerm*turns M.first
    let r := (u++z).formPerm*turns D.first
    (dartGraph M.mate s).edist (vertex s x) (vertex s y)=
      (dartGraph D.mate r).edist (vertex r x) (vertex r y) := by
  let S : Set α := {d | d∈a::L}
  let keep : α→Bool := fun d => decide (d∉a::L)
  have hpres := M.empty_interval_preserves hn hv
  have hk : ∀ d∈u++((a::L)++z),keep (M.mate d)=keep d := by
    intro d _
    simp only [keep,decide_eq_decide]
    exact not_congr (hpres.1 d)
  let D := M.deleteInterval hn hv
  have hDfirst : D.first=(M.filter hn keep hk).first := StackMatching.cast_first _ _
  have hDmate : D.mate=(M.filter hn keep hk).mate := StackMatching.cast_mate _ _
  have hd : (a::L).Disjoint (b::R) := by
    have hh : ((a::L)++(b::R)).Nodup := by
      rw [← hcomp,← List.append_assoc]
      exact List.perm_append_comm.nodup_iff.mp hn
    exact List.disjoint_iff_ne.mpr (List.nodup_append.mp hh).2.2
  have hnu : (u++z).Nodup := by
    exact hn.sublist (List.Sublist.append (List.Sublist.refl u) (List.sublist_append_right _ _))
  have hrotate : (u++z).formPerm=(b::R).formPerm := by
    rw [formPerm_append_comm u z hnu,hcomp]
  let p := (a::L).formPerm*(b::R).formPerm*turns M.first
  let r := (u++z).formPerm*turns D.first
  have hp : ∀ d,p d∈S ↔ d∈S := by
    intro d
    simp only [p,S,Set.mem_ofPred_eq,mul_apply,List.formPerm_mem_iff_mem,
      formPerm_other_mem_iff hd,hpres.2]
  have hfixed (d : α) (hd' : d∈a::L) : r d=d := by
    have hf : turns D.first d=d := by
      rw [hDfirst]
      exact M.filter_first_fixed hn keep hk d (by simp only [keep,decide_eq_false_iff_not,not_not];exact hd')
    simp only [r,mul_apply,hf,hrotate]
    exact List.formPerm_apply_of_notMem (fun h => List.disjoint_left.mp hd hd' h)
  have hr : ∀ d,r d∈S ↔ d∈S := perm_preserves_of_fixed hfixed
  have hep : ∀ d,D.mate d∈S ↔ d∈S := by
    apply perm_preserves_of_fixed
    intro d hd'
    rw [hDmate]
    exact M.filter_mate_fixed hn keep hk d (by simp only [keep,decide_eq_false_iff_not,not_not];exact hd')
  have hpq (d : α) (hd' : d∈Sᶜ) : p d=r d := by
    have hf : turns D.first d=turns M.first d := by
      rw [hDfirst]
      exact M.filter_first hn keep hk d (by exact decide_eq_true hd')
    have hnd : turns M.first d∉a::L := fun h => hd' ((hpres.2 d).mp h)
    have hnr : (b::R).formPerm (turns M.first d)∉a::L := fun h => hnd ((formPerm_other_mem_iff hd _).mp h)
    simp only [p,r,mul_apply,hf,hrotate,List.formPerm_apply_of_notMem hnr]
  have hef (d : α) (hd' : d∈Sᶜ) : M.mate d=D.mate d := by
    rw [hDmate]
    exact (M.filter_mate_on hn keep hk d (by exact decide_eq_true hd')).symm
  let E := sideGraphCongr (fun d => not_congr (hp d)) (fun d => not_congr (hr d))
    (fun d => not_congr (hpres.1 d)) (fun d => not_congr (hep d)) hpq hef
  dsimp only
  rw [M.empty_interval_rotation u L z a b R hn hcomp]
  change (dartGraph M.mate (swap a b*p)).edist _ _=(dartGraph D.mate r).edist _ _
  calc
    _=(sideGraph M.mate p Sᶜ (fun d => not_congr (hpres.1 d))).edist
      (sideMk p Sᶜ x hx) (sideMk p Sᶜ y hy) :=
        (M.empty_interval_wedge u L z a b R hn hv hcomp).edist_right _ _
    _=(sideGraph D.mate r Sᶜ (fun d => not_congr (hep d))).edist
      (sideMk r Sᶜ x hx) (sideMk r Sᶜ y hy) := (GraphWedge.iso_edist E _ _).symm
    _=_ := (fullInclusion_edist (fun d => not_congr (hr d))
      (fun d => not_congr (hep d)) (sideMk r Sᶜ x hx) (sideMk r Sᶜ y hy)).symm

end FKCRT.Inventory
end


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

/-- Each genuine inserted successful word has precisely one metric gate in
its complement in the original all-edge map. This equality is in the original
graph, not an independently postulated block-tree metric. -/
theorem StackMatching.empty_interval_gate {w : α→TypedLetter}
    (u L z : List α) (a b : α) (R : List α)
    (M : StackMatching w (u++((a::L)++z))) (hn : (u++((a::L)++z)).Nodup)
    (hv : stackTypedRun ((a::L).map w) []=some []) (hcomp : z++u=b::R)
    (x y : α) (hx : x∈a::L) (hy : y∉a::L) :
    let s := (u++((a::L)++z)).formPerm*turns M.first
    (dartGraph M.mate s).edist (vertex s x) (vertex s y)=
      (dartGraph M.mate s).edist (vertex s x) (vertex s a)+
      (dartGraph M.mate s).edist (vertex s a) (vertex s y) := by
  dsimp only
  rw [M.empty_interval_rotation u L z a b R hn hcomp]
  let S : Set α := {d | d∈a::L}
  let p := (a::L).formPerm*(b::R).formPerm*turns M.first
  let D := M.empty_interval_wedge u L z a b R hn hv hcomp
  let xx := sideMk p S x hx
  let yy := sideMk p Sᶜ y hy
  change _ = _+_
  have hl := D.edist_left xx D.poleLeft
  have hr := D.edist_right D.poleRight yy
  have hc := D.edist_cross xx yy
  rw [← D.shared] at hr
  dsimp only [D,StackMatching.empty_interval_wedge,PermutationWedge.data,
    PermutationWedge.inclusionHom,PermutationWedge.flipInclusionHom,
    PermutationWedge.inclusion,PermutationWedge.flipInclusion,xx,yy] at hl hr hc
  exact hc.trans (congrArg₂ (·+·) hl.symm hr.symm)

end FKCRT.Inventory
end


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

omit [DecidableEq α] in
lemma complement_disjoint_interval (u v z : List α) (hn : (u++(v++z)).Nodup) :
    (u++z).Disjoint v := by
  apply List.disjoint_append_left.mpr
  constructor
  · apply List.disjoint_iff_ne.mpr
    intro x hx y hy h
    exact (List.nodup_append.mp hn).2.2 x hx y (List.mem_append_left _ hy) h
  · exact (List.disjoint_iff_ne.mpr
      (List.nodup_append.mp (List.nodup_append.mp hn).2.1).2.2).symm

/-- A notation for the actual original all-edge distance of a typed matching. -/
def StackMatching.distance {w : α→TypedLetter} {l : List α}
    (M : StackMatching w l) (x y : α) : ℕ∞ :=
  let s := l.formPerm*turns M.first
  (dartGraph M.mate s).edist (vertex s x) (vertex s y)

lemma StackMatching.distance_cast {w : α→TypedLetter} {l l' : List α}
    (h : l=l') (M : StackMatching w l) (x y : α) :
    (h ▸ M).distance x y=M.distance x y := by cases h;rfl

/-- Erasing a possibly empty successful interval does not shorten any
retained all-edge distance. Both vertices are kept literal dart vertices. -/
lemma StackMatching.erase_distance [Fintype α] {w : α→TypedLetter}
    (u v z : List α) (M : StackMatching w (u++(v++z)))
    (hn : (u++(v++z)).Nodup) (hv : stackTypedRun (v.map w) []=some [])
    (hc : u++z≠[]) (x y : α) (hx : x∈u++z) (hy : y∈u++z) :
    ∃ D : StackMatching w (u++z),M.distance x y=D.distance x y := by
  cases v with
  | nil =>
    refine ⟨(by simpa only [List.nil_append] using M),?_⟩
    rfl
  | cons a L =>
    have hcomp : z++u≠[] := by
      intro h
      obtain ⟨rfl,rfl⟩ := List.append_eq_nil_iff.mp h
      exact hc rfl
    obtain ⟨b,R,hR⟩ := List.exists_cons_of_ne_nil hcomp
    refine ⟨M.deleteInterval hn hv,?_⟩
    exact M.delete_interval_distance u L z a b R hn hv hR x y
      (fun h => List.disjoint_left.mp (complement_disjoint_interval u (a::L) z hn) hx h)
      (fun h => List.disjoint_left.mp (complement_disjoint_interval u (a::L) z hn) hy h)

/-- Literal dart order for all successive corner insertions. -/
def dartInsert (l : List (α×List α)) : List α := l.flatMap fun p => p.1::p.2

omit [DecidableEq α] in
lemma core_sublist_insert (l : List (α×List α)) : l.map Prod.fst <+ dartInsert l := by
  induction l with
  | nil => exact List.Sublist.refl _
  | cons p l ih =>
    change p.1::l.map Prod.fst <+ p.1::(p.2++dartInsert l)
    exact (ih.trans (List.sublist_append_right _ _)).cons_cons _

/-- Iterated exact preservation of INTERIOR CORE distances under all its
actual successful corner insertions, including trivial leaf intervals.
No stochastic estimate and no replacement metric is assumed. -/
theorem StackMatching.core_distance [Fintype α] {w : α→TypedLetter}
    (p : List α) (l : List (α×List α))
    (M : StackMatching w (p++dartInsert l)) (hn : (p++dartInsert l).Nodup)
    (he : ∀ c∈l,stackTypedRun (c.2.map w) []=some [])
    (hc : p++l.map Prod.fst≠[]) (x y : α)
    (hx : x∈p++l.map Prod.fst) (hy : y∈p++l.map Prod.fst) :
    ∃ D : StackMatching w (p++l.map Prod.fst),M.distance x y=D.distance x y := by
  induction l generalizing p with
  | nil =>
    refine ⟨M,?_⟩
    rfl
  | cons c l ih =>
    let q := p++[c.1]
    have hword : p++dartInsert (c::l)=q++(c.2++dartInsert l) := by
      simp only [q,dartInsert,List.flatMap_cons,List.append_assoc,List.cons_append,List.nil_append]
    let M' : StackMatching w (q++(c.2++dartInsert l)) := hword ▸ M
    have hn' : (q++(c.2++dartInsert l)).Nodup := hword ▸ hn
    have he' : stackTypedRun (c.2.map w) []=some [] := he c (by simp)
    have hcore : p++(c::l).map Prod.fst=q++l.map Prod.fst := by
      simp only [q,List.map_cons,List.append_assoc,List.singleton_append]
    have hsub : q++l.map Prod.fst <+ q++dartInsert l :=
      List.Sublist.append (List.Sublist.refl _) (core_sublist_insert _)
    have hx' : x∈q++dartInsert l := hsub.subset (hcore ▸ hx)
    have hy' : y∈q++dartInsert l := hsub.subset (hcore ▸ hy)
    have hnon : q++dartInsert l≠[] := List.ne_nil_of_mem hx'
    obtain ⟨D,hD⟩ := M'.erase_distance q c.2 (dartInsert l) hn' he' hnon x y hx' hy'
    have hnD : (q++dartInsert l).Nodup :=
      hn'.sublist (List.Sublist.append (List.Sublist.refl _) (List.sublist_append_right _ _))
    obtain ⟨E,hE⟩ := ih q D hnD (fun t ht => he t (by simp [ht]))
      (hcore ▸ hc) (hcore ▸ hx) (hcore ▸ hy)
    refine ⟨hcore.symm ▸ E,?_⟩
    rw [StackMatching.distance_cast]
    exact (M.distance_cast hword x y).symm.trans (hD.trans hE)

end FKCRT.Inventory
end


noncomputable section
open List Equiv Equiv.Perm
namespace FKCRT.Inventory
open MapCycles PermutationWedge
attribute [local instance] Classical.propDecidable
variable {α : Type*} [DecidableEq α] [Fintype α]

omit [Fintype α] in
lemma filter_keep_interval (u v z : List α) (hn : (u++(v++z)).Nodup) :
    (u++(v++z)).filter (fun d => decide (d∈v))=v := by
  have hd := complement_disjoint_interval u v z hn
  rw [List.filter_append,List.filter_append]
  have hu : u.filter (fun d => decide (d∈v))=[] := by
    apply List.filter_eq_nil_iff.mpr
    intro d hm
    simp only [decide_eq_true_eq]
    exact fun h => List.disjoint_left.mp hd (List.mem_append_left _ hm) h
  have hz : z.filter (fun d => decide (d∈v))=[] := by
    apply List.filter_eq_nil_iff.mpr
    intro d hm
    simp only [decide_eq_true_eq]
    exact fun h => List.disjoint_left.mp hd (List.mem_append_right _ hm) h
  have hv : v.filter (fun d => decide (d∈v))=v := by
    apply List.filter_eq_self.mpr
    intro d hd
    exact decide_eq_true hd
  rw [hu,hv,hz,List.nil_append,List.append_nil]

/-- The literal restricted successful matching, retaining an inserted word. -/
def StackMatching.keepInterval {w : α→TypedLetter} {u v z : List α}
    (M : StackMatching w (u++(v++z))) (hn : (u++(v++z)).Nodup)
    (hv : stackTypedRun (v.map w) []=some []) : StackMatching w v := by
  have hpres := (M.empty_interval_preserves hn hv).1
  let keep : α→Bool := fun d => decide (d∈v)
  have hk : ∀ d∈u++(v++z),keep (M.mate d)=keep d := by
    intro d _
    simp only [keep,decide_eq_decide]
    exact hpres d
  exact filter_keep_interval u v z hn ▸ M.filter hn keep hk

/-- All-edge distances inside inserted words are unchanged in the ambient
map, and agree with the actual isolated typed matching of that word. -/
theorem StackMatching.keep_interval_distance {w : α→TypedLetter}
    (u L z : List α) (a b : α) (R : List α)
    (M : StackMatching w (u++((a::L)++z))) (hn : (u++((a::L)++z)).Nodup)
    (hv : stackTypedRun ((a::L).map w) []=some []) (hcomp : z++u=b::R)
    (x y : α) (hx : x∈a::L) (hy : y∈a::L) :
    M.distance x y=(M.keepInterval hn hv).distance x y := by
  let S : Set α := {d | d∈a::L}
  let keep : α→Bool := fun d => decide (d∈a::L)
  have hpres := M.empty_interval_preserves hn hv
  have hk : ∀ d∈u++((a::L)++z),keep (M.mate d)=keep d := by
    intro d _
    simp only [keep,decide_eq_decide]
    exact hpres.1 d
  let D := M.keepInterval hn hv
  have hDfirst : D.first=(M.filter hn keep hk).first := StackMatching.cast_first _ _
  have hDmate : D.mate=(M.filter hn keep hk).mate := StackMatching.cast_mate _ _
  have hd : (a::L).Disjoint (b::R) := by
    have hh : ((a::L)++(b::R)).Nodup := by
      rw [← hcomp,← List.append_assoc]
      exact List.perm_append_comm.nodup_iff.mp hn
    exact List.disjoint_iff_ne.mpr (List.nodup_append.mp hh).2.2
  let p := (a::L).formPerm*(b::R).formPerm*turns M.first
  let r := (a::L).formPerm*turns D.first
  have hp : ∀ d,p d∈S ↔ d∈S := by
    intro d
    simp only [p,S,Set.mem_ofPred_eq,mul_apply,List.formPerm_mem_iff_mem,
      formPerm_other_mem_iff hd,hpres.2]
  have hfixed (d : α) (hd' : d∉a::L) : r d=d := by
    have hf : turns D.first d=d := by
      rw [hDfirst]
      exact M.filter_first_fixed hn keep hk d (by exact decide_eq_false hd')
    simp only [r,mul_apply,hf,List.formPerm_apply_of_notMem hd']
  have hrC : ∀ d,r d∈Sᶜ ↔ d∈Sᶜ := perm_preserves_of_fixed hfixed
  have hr : ∀ d,r d∈S ↔ d∈S := by
    intro d
    exact not_iff_not.mp (hrC d)
  have hepC : ∀ d,D.mate d∈Sᶜ ↔ d∈Sᶜ := by
    apply perm_preserves_of_fixed
    intro d hd'
    rw [hDmate]
    exact M.filter_mate_fixed hn keep hk d (by exact decide_eq_false hd')
  have hep : ∀ d,D.mate d∈S ↔ d∈S := fun d => not_iff_not.mp (hepC d)
  have hpq (d : α) (hd' : d∈S) : p d=r d := by
    have hf : turns D.first d=turns M.first d := by
      rw [hDfirst]
      exact M.filter_first hn keep hk d (by exact decide_eq_true hd')
    have hnr : turns M.first d∉b::R := fun h =>
      List.disjoint_left.mp hd ((hpres.2 d).mpr hd') h
    simp only [p,r,mul_apply,hf,List.formPerm_apply_of_notMem hnr]
  have hef (d : α) (hd' : d∈S) : M.mate d=D.mate d := by
    rw [hDmate]
    exact (M.filter_mate_on hn keep hk d (by exact decide_eq_true hd')).symm
  let E := sideGraphCongr hp hr hpres.1 hep hpq hef
  unfold StackMatching.distance
  rw [M.empty_interval_rotation u L z a b R hn hcomp]
  change (dartGraph M.mate (swap a b*p)).edist _ _=(dartGraph D.mate r).edist _ _
  calc
    _=(sideGraph M.mate p S hpres.1).edist (sideMk p S x hx) (sideMk p S y hy) :=
      (M.empty_interval_wedge u L z a b R hn hv hcomp).edist_left _ _
    _=(sideGraph D.mate r S hep).edist (sideMk r S x hx) (sideMk r S y hy) :=
      (GraphWedge.iso_edist E _ _).symm
    _=_ := (fullInclusion_edist hr hep (sideMk r S x hx) (sideMk r S y hy)).symm

end FKCRT.Inventory
end

end OAI