import OAI.Combinatorics.ListHadwiger.StageDeletion

namespace OAI

namespace LinearListHadwiger.Stage
open SimpleGraph Finset
attribute [local instance] Classical.propDecidable

structure RoleRouting {V : Type} (G : SimpleGraph V) {t a : ℕ}
    (w : Fin t → V) (u : Fin a → V) (F H : Set V) (D : Finset V) (U : Set V) where
  fresh : Fin t → V
  fresh_injective : Function.Injective fresh
  fresh_mem : ∀ i, fresh i∈H
  target : Roles t a → ↥D
  route : ∀ p, G.Path (roleStart w u fresh p) (target p).val
  disjoint : ∀ p q, p≠q → Disjoint {v | v∈(route p).val.support} {v | v∈(route q).val.support}
  old_only : ∀ p v, v∈(route p).val.support → v∈F → ∃ i, p=Sum.inl i ∧ v=w i
  new_only : ∀ p v, v∈(route p).val.support → v∈H → ∃ i, p=Sum.inr (Sum.inr i) ∧ v=fresh i
  root_only : ∀ p j, u j∈(route p).val.support → u j=roleStart w u fresh p
  target_only : ∀ p v, v∈(route p).val.support → v∈D → v=(target p).val
  inside : ∀ p v, v∈(route p).val.support → v∈U

namespace RoleRouting
variable {V : Type} [DecidableEq V] {G : SimpleGraph V} {t a : ℕ}
    {w : Fin t → V} {u : Fin a → V} {F H U : Set V} {D : Finset V}

omit [DecidableEq V] in
lemma start_injective (R : RoleRouting G w u F H D U) :
    Function.Injective (roleStart w u R.fresh) := by
  intro p q he
  by_contra hpq
  exact Set.disjoint_left.mp (R.disjoint p q hpq) (R.route p).val.start_mem_support
    (Eq.mpr (congrArg (fun v => v∈(R.route q).val.support) he) (R.route q).val.start_mem_support)

omit [DecidableEq V] in
lemma target_injective (R : RoleRouting G w u F H D U) : Function.Injective R.target := by
  intro p q he
  by_contra hpq
  exact Set.disjoint_left.mp (R.disjoint p q hpq) (R.route p).val.end_mem_support
    (Eq.mpr (congrArg (fun v => v∈(R.route q).val.support) (congrArg Subtype.val he))
      (R.route q).val.end_mem_support)

theorem of_paired (hw : Function.Injective w) (hu : Function.Injective u)
    (hwu : ∀ i j, w i≠u j) (s : Fin t×Bool → V)
    (hs : Function.Injective s) (hsH : ∀ i, s i∈H)
    (hZH : Disjoint (↑(oldSources w u) : Set V) H)
    (P : PairedSources.Packing G
      (fun (i : ↥(oldSources w u)⊕Fin t) b => Sum.elim Subtype.val (fun j => s (j,b)) i) D U)
    (hPF : ∀ p v, v∈(P.route p).val.support → v∈F → ∃ i, w i=v)
    (hPH : ∀ p v, v∈(P.route p).val.support → v∈H → ∃ i b, s (i,b)=v) :
    Nonempty (RoleRouting G w u F H D U) := by
  classical
  let e := roleEquiv w u hw hu hwu
  let w' : Fin t → V := fun i => s (i,P.choose (.inr i))
  let tar : Roles t a → ↥D := fun p => P.target (e p)
  have hstart (p : Roles t a) :
      Sum.elim Subtype.val (fun j => s (j,P.choose (e p))) (e p)=roleStart w u w' p := by
    rcases p with i | (j|i) <;> rfl
  let paths : ∀ p, G.Path (roleStart w u w' p) (tar p).val := fun p =>
    ⟨(P.route (e p)).val.copy (hstart p) rfl,by simp⟩
  have hsup (p : Roles t a) (v : V) : v∈(paths p).val.support ↔ v∈(P.route (e p)).val.support := by
    simp [paths]
  have hsource (p : Roles t a) (v : V) (hv : v∈(paths p).val.support)
      (hi : ∃ i b, v=Sum.elim Subtype.val (fun j => s (j,b)) i) : v=roleStart w u w' p :=
    (P.source_only (e p) v ((hsup p v).mp hv) hi).trans (hstart p)
  have hxinj : Function.Injective (roleStart w u w') := by
    intro p q he
    apply e.injective
    apply P.source_injective
    exact (hstart p).trans (he.trans (hstart q).symm)
  refine ⟨⟨w',?_,fun i => hsH _,tar,paths,?_,?_,?_,?_,?_,?_⟩⟩
  · intro i j he
    exact congrArg Prod.fst (hs he)
  · intro p q hpq
    apply Set.disjoint_left.mpr
    intro v hv hw'
    exact Set.disjoint_left.mp (P.disjoint _ _ (fun he => hpq (e.injective he)))
      ((hsup p v).mp hv) ((hsup q v).mp hw')
  · intro p v hv hvF
    obtain ⟨i,hi⟩ := hPF (e p) v ((hsup p v).mp hv) hvF
    have he := hsource p v hv ⟨e (.inl i),false,by simpa [e,roleEquiv,roleTo] using hi.symm⟩
    refine ⟨i,hxinj ?_,hi.symm⟩
    exact he.symm.trans hi.symm
  · intro p v hv hvH
    obtain ⟨i,b,hi⟩ := hPH (e p) v ((hsup p v).mp hv) hvH
    have he := hsource p v hv ⟨Sum.inr i,b,hi.symm⟩
    rcases p with j | (j|j)
    · have he' : v=w j := he
      exact (Set.disjoint_left.mp hZH ((mem_oldSources w u _).mpr (Or.inl ⟨j,rfl⟩))
        (he' ▸ hvH)).elim
    · have he' : v=u j := he
      exact (Set.disjoint_left.mp hZH ((mem_oldSources w u _).mpr (Or.inr ⟨j,rfl⟩))
        (he' ▸ hvH)).elim
    · exact ⟨j,rfl,he⟩
  · intro p j hv
    exact hsource p (u j) hv ⟨e (.inr (.inl j)),false,rfl⟩
  · intro p v hv hvD
    exact P.target_only (e p) v ((hsup p v).mp hv) hvD
  · intro p v hv
    exact P.inside (e p) v ((hsup p v).mp hv)

theorem weave (R : RoleRouting G w u F H D U) (J : Set V) {b : ℕ}
    (hJ : WovenOn G J a b) (hu : Function.Injective u) (huJ : ∀ j, u j∈J)
    (hc : 2*t+a≤b) (hJF : Disjoint J F) (hJH : Disjoint J H)
    (hJD : Disjoint J (↑D : Set V)) :
    ∃ M : RootedCliqueModel G u, (∀ j, M.branch j⊆J) ∧
    ∃ R' : RoleRouting G w u F H D (U∪J), R'.fresh=R.fresh ∧
      ∀ p j v, v∈(R'.route p).val.support → v∈M.branch j → p=Sum.inr (Sum.inl j) := by
  have hcard : Fintype.card (Roles t a)≤b := by simpa [Roles,show t+(a+t)=2*t+a by omega] using hc
  obtain ⟨M,hMJ,Q,hQQ,hQP,hQM⟩ := reroute_sources J hJ u hu huJ
    (roleStart w u R.fresh) (fun p => (R.target p).val) R.route hcard R.disjoint R.root_only
  let R' : RoleRouting G w u F H D (U∪J) :=
    { fresh := R.fresh
      fresh_injective := R.fresh_injective
      fresh_mem := R.fresh_mem
      target := R.target
      route := Q
      disjoint := hQQ
      old_only := fun p v hv hvF => R.old_only p v
        (hQP p v hv (fun hvJ => Set.disjoint_left.mp hJF hvJ hvF)) hvF
      new_only := fun p v hv hvH => R.new_only p v
        (hQP p v hv (fun hvJ => Set.disjoint_left.mp hJH hvJ hvH)) hvH
      root_only := fun p j hv => (hQM p j (u j) hv (M.root_mem j)).1
      target_only := fun p v hv hvD => R.target_only p v
        (hQP p v hv (fun hvJ => Set.disjoint_left.mp hJD hvJ hvD)) hvD
      inside := fun p v hv => by
        by_cases hvJ : v∈J
        · exact Or.inr hvJ
        · exact Or.inl (R.inside p v (hQP p v hv hvJ)) }
  refine ⟨M,hMJ,R',rfl,?_⟩
  intro p j v hv hvm
  obtain ⟨he,he'⟩ := hQM p j v hv hvm
  exact R.start_injective (he.symm.trans he')

end RoleRouting
end LinearListHadwiger.Stage

namespace LinearListHadwiger.Stage
open SimpleGraph Finset Footprint
attribute [local instance] Classical.propDecidable

variable {V : Type} [Fintype V] [DecidableEq V] {G : SimpleGraph V} {t a : ℕ}

theorem combine_systems (F H D : Finset V) (w : Fin t → V) (u : Fin a → V)
    (hw : Function.Injective w) (hu : Function.Injective u) (hwu : ∀ i j, w i≠u j)
    (hwF : ∀ i, w i∈F) (hZH : Disjoint (oldSources w u) H)
    (hZD : Disjoint (oldSources w u) D) (hHD : Disjoint H D)
    (R : System G) (hRU : R.domain=univ\(F\univ.image w))
    (P : DoublePacking G (oldSources w u) D)
    (hPR : ∀ i v, v∈(P.route i).val.support → v∈R.used)
    (hRH : Disjoint R.used H)
    (Q : Second G (univ\(F∪univ.image u)) H D (2*t)) :
    Nonempty (RoleRouting G w u (↑F : Set V) (↑H : Set V) D
      (↑(R.used∪Q.record.used) : Set V)) := by
  classical
  let e : (Fin t×Bool) ≃ Fin (2*t) := Fintype.equivOfCardEq (by simp; omega)
  let s : Fin t×Bool → V := Q.source ∘ e
  let tar : Fin t×Bool → ↥D := Q.target ∘ e
  let paths : ∀ i, G.Path (s i) (tar i).val := fun i => Q.route (e i)
  have hs : Function.Injective s := Q.source_injective.comp e.injective
  have hsH : ∀ i, s i∈H := fun i => Q.source_mem (e i)
  have hPH : ∀ i v, v∈(P.route i).val.support → v∉H :=
    fun i v hv hH => Finset.disjoint_left.mp hRH (hPR i v hv) hH
  have hQZ : ∀ i v, v∈(paths i).val.support → v∉oldSources w u := by
    intro i v hv hvZ
    have hdom := (mem_sdiff.mp (Q.route_domain (e i) hv)).2
    rcases (mem_oldSources w u v).mp hvZ with ⟨j,rfl⟩|⟨j,rfl⟩
    · exact hdom (mem_union_left _ (hwF j))
    · exact hdom (mem_union_right _ (mem_image.mpr ⟨j,mem_univ _,rfl⟩))
  obtain ⟨K⟩ := combine_double P s tar paths hs hsH hZH hZD hHD hPH hQZ
    (fun i v hv hvH => Q.source_only (e i) v hv hvH)
    (fun i j hij => Q.disjoint _ _ (fun he => hij (e.injective he)))
  have hinside (i) (v) (hv : v∈(K.route i).val.support) : v∈R.used∪Q.record.used := by
    rcases K.inside i v hv with ⟨j,hj⟩|⟨j,hj⟩
    · exact mem_union_left _ (hPR j v hj)
    · exact mem_union_right _ ((Q.mem_record_used v).mpr ⟨e j,hj⟩)
  let K' : PairedSources.Packing G
      (fun (i : ↥(oldSources w u)⊕Fin t) b => Sum.elim Subtype.val (fun j => s (j,b)) i) D
      (↑(R.used∪Q.record.used) : Set V) :=
    { choose := K.choose
      target := K.target
      route := K.route
      disjoint := K.disjoint
      source_only := K.source_only
      target_only := K.target_only
      inside := hinside }
  apply RoleRouting.of_paired hw hu hwu s hs hsH (by exact_mod_cast hZH) K'
  · intro i v hv hvF
    rcases K.inside i v hv with ⟨j,hj⟩|⟨j,hj⟩
    · have hdom := R.used_subset_domain (hPR j v hj)
      rw [hRU] at hdom
      have hvW : v∈univ.image w := by
        by_contra hn
        exact (mem_sdiff.mp hdom).2 (mem_sdiff.mpr ⟨hvF,hn⟩)
      simpa only [mem_image,mem_univ,true_and] using hvW
    · exact False.elim ((mem_sdiff.mp (Q.route_domain (e j) hj)).2 (mem_union_left _ hvF))
  · intro i v hv hvH
    rcases K.inside i v hv with ⟨j,hj⟩|⟨j,hj⟩
    · exact False.elim (hPH j v hj hvH)
    · exact ⟨j.1,j.2,(Q.source_only (e j) v hj hvH).symm⟩

omit [Fintype V] in
lemma Second.used_inter_region (F H D : Finset V) {n : ℕ}
    (Q : Second G F H D n) : Q.record.used∩H=Q.record.starts := by
  rw [Q.record_starts]
  ext v
  simp only [mem_inter,Q.mem_record_used,mem_image,mem_univ,true_and]
  constructor
  · rintro ⟨⟨i,hi⟩,hvH⟩
    exact ⟨i,(Q.source_only i v hi hvH).symm⟩
  · rintro ⟨i,rfl⟩
    exact ⟨⟨i,(Q.route i).val.start_mem_support⟩,Q.source_mem i⟩

omit [Fintype V] in
lemma Second.starts_card (F H D : Finset V) {n : ℕ}
    (Q : Second G F H D n) : Q.record.starts.card=n := by
  rw [Q.record_starts,card_image_of_injective _ Q.source_injective,card_univ,Fintype.card_fin]

end LinearListHadwiger.Stage

namespace LinearListHadwiger.Stage
open Finset SimpleGraph
attribute [local instance] Classical.propDecidable

lemma union_connected {V : Type} [Fintype V] [DecidableEq V]
    (G : SimpleGraph V) {A B : Finset V} {k : ℕ}
    (hA : KConnectedOn G A k) (hB : KConnectedOn G B k)
    (hAB : k ≤ (A∩B).card) : KConnectedOn G (A∪B) k := by
  classical
  refine ⟨hA.1.trans_le (card_le_card subset_union_left),?_⟩
  intro Z _ hZ
  have hZA : (Z∩A).card < k := (card_le_card inter_subset_left).trans_lt hZ
  have hZB : (Z∩B).card < k := (card_le_card inter_subset_left).trans_lt hZ
  have hAc := hA.2 (Z∩A) inter_subset_right hZA
  have hBc := hB.2 (Z∩B) inter_subset_right hZB
  have hn : ((A∩B)\Z).Nonempty := by
    apply nonempty_iff_ne_empty.mpr
    intro he
    have hs : A∩B ⊆ Z := sdiff_eq_empty_iff_subset.mp he
    have hh := card_le_card hs
    omega
  obtain ⟨v,hv⟩ := hn
  have hvA : v∈A\(Z∩A) := by simpa using (show v∈A ∧ v∉Z from
    ⟨(mem_inter.mp (mem_sdiff.mp hv).1).1,(mem_sdiff.mp hv).2⟩)
  have hvB : v∈B\(Z∩B) := by simpa using (show v∈B ∧ v∉Z from
    ⟨(mem_inter.mp (mem_sdiff.mp hv).1).2,(mem_sdiff.mp hv).2⟩)
  have he : (↑((A∪B)\Z):Set V) = (↑(A\(Z∩A)):Set V) ∪ (↑(B\(Z∩B)):Set V) := by
    ext w
    simp only [mem_coe,mem_sdiff,mem_union,mem_inter,Set.mem_union]
    tauto
  rw [he]
  exact SimpleGraph.induce_union_connected hAc.preconnected hBc.preconnected ⟨v,hvA,hvB⟩

def attached {V P : Type} {G : SimpleGraph V} (C : P → Set V)
    (x y : P → V) (paths : ∀ p, G.Path (x p) (y p)) (p : P) : Set V :=
  C p ∪ {v | v∈(paths p).val.support}

def extended {V P I : Type} {G : SimpleGraph V} (E : I → Set V) (C : P → Set V)
    (owner : P → I) (x y : P → V) (paths : ∀ p, G.Path (x p) (y p)) (i : I) : Set V :=
  E i ∪ {v | ∃ p, owner p=i ∧ v∈attached C x y paths p}

lemma attached_connected {V P : Type} {G : SimpleGraph V} (C : P → Set V)
    (x y : P → V) (paths : ∀ p, G.Path (x p) (y p))
    (hC : ∀ p, (G.induce (C p)).Connected) (hx : ∀ p, x p∈C p) (p : P) :
    (G.induce (attached C x y paths p)).Connected :=
  SimpleGraph.induce_union_connected (hC p).preconnected
    (paths p).val.connected_induce_support.preconnected ⟨x p,hx p,(paths p).val.start_mem_support⟩

lemma extended_connected {V P I : Type} {G : SimpleGraph V}
    (E : I → Set V) (C : P → Set V) (owner : P → I)
    (x y : P → V) (paths : ∀ p, G.Path (x p) (y p))
    (hE : ∀ i, (G.induce (E i)).Connected)
    (hC : ∀ p, (G.induce (C p)).Connected)
    (hx : ∀ p, x p∈C p) (hy : ∀ p, y p∈E (owner p)) (i : I) :
    (G.induce (extended E C owner x y paths i)).Connected := by
  obtain ⟨u,hu⟩ := (hE i).nonempty
  apply G.induce_connected_of_patches u (Or.inl hu)
  intro v hv
  rcases hv with hv | ⟨p,hpi,hvp⟩
  · exact ⟨E i,Set.subset_union_left,hu,hv,(hE i).preconnected _ _⟩
  · have hc := SimpleGraph.induce_union_connected (hE i).preconnected
      (attached_connected C x y paths hC hx p).preconnected
      ⟨y p,hpi ▸ hy p,Or.inr (paths p).val.end_mem_support⟩
    refine ⟨E i ∪ attached C x y paths p,?_,Or.inl hu,Or.inr hvp,hc.preconnected _ _⟩
    intro w hw
    rcases hw with hw | hw
    · exact Or.inl hw
    · exact Or.inr ⟨p,hpi,hw⟩

lemma extended_disjoint {V P I : Type} {G : SimpleGraph V}
    (E : I → Set V) (C : P → Set V) (owner : P → I)
    (x y : P → V) (paths : ∀ p, G.Path (x p) (y p))
    (hE : ∀ i j, i≠j → Disjoint (E i) (E j))
    (hC : ∀ p q, owner p≠owner q → Disjoint (C p) (C q))
    (hEC : ∀ i p, i≠owner p → Disjoint (E i) (C p))
    (hEP : ∀ i p, i≠owner p → Disjoint (E i) {v | v∈(paths p).val.support})
    (hCP : ∀ p q, owner p≠owner q → Disjoint (C p) {v | v∈(paths q).val.support})
    (hP : ∀ p q, owner p≠owner q → Disjoint {v | v∈(paths p).val.support}
      {v | v∈(paths q).val.support}) :
    ∀ i j, i≠j → Disjoint (extended E C owner x y paths i) (extended E C owner x y paths j) := by
  intro i j hij
  apply Set.disjoint_left.mpr
  intro v hv hw
  rcases hv with hv | ⟨p,hpi,hvp|hvp⟩ <;> rcases hw with hw | ⟨q,hqj,hvq|hvq⟩
  · exact Set.disjoint_left.mp (hE i j hij) hv hw
  · exact Set.disjoint_left.mp (hEC i q (hqj ▸ hij)) hv hvq
  · exact Set.disjoint_left.mp (hEP i q (hqj ▸ hij)) hv hvq
  · exact Set.disjoint_left.mp (hEC j p (hpi ▸ Ne.symm hij)) hw hvp
  · exact Set.disjoint_left.mp (hC p q (by simpa only [hpi,hqj] using hij)) hvp hvq
  · exact Set.disjoint_left.mp (hCP p q (by simpa only [hpi,hqj] using hij)) hvp hvq
  · exact Set.disjoint_left.mp (hEP j p (hpi ▸ Ne.symm hij)) hw hvp
  · exact Set.disjoint_left.mp (hCP q p (by simpa only [hpi,hqj] using Ne.symm hij)) hvq hvp
  · exact Set.disjoint_left.mp (hP p q (by simpa only [hpi,hqj] using hij)) hvp hvq

lemma satellite_subset {V P I : Type} {G : SimpleGraph V}
    (E : I → Set V) (C : P → Set V) (owner : P → I)
    (x y : P → V) (paths : ∀ p, G.Path (x p) (y p)) (p : P) :
    C p ⊆ extended E C owner x y paths (owner p) :=
  fun _ hv => Or.inr ⟨p,rfl,Or.inl hv⟩

lemma path_subset {V P I : Type} {G : SimpleGraph V}
    (E : I → Set V) (C : P → Set V) (owner : P → I)
    (x y : P → V) (paths : ∀ p, G.Path (x p) (y p)) (p : P) :
    {v | v∈(paths p).val.support} ⊆ extended E C owner x y paths (owner p) :=
  fun _ hv => Or.inr ⟨p,rfl,Or.inr hv⟩

lemma extended_subset {V P I : Type} {G : SimpleGraph V}
    (E : I → Set V) (C : P → Set V) (owner : P → I)
    (x y : P → V) (paths : ∀ p, G.Path (x p) (y p)) {F : Set V}
    (hE : ∀ i, E i ⊆ F) (hC : ∀ p, C p ⊆ F)
    (hP : ∀ p v, v∈(paths p).val.support → v∈F) (i : I) :
    extended E C owner x y paths i ⊆ F := by
  rintro v (hv|⟨p,_,hv|hv⟩)
  · exact hE i hv
  · exact hC p hv
  · exact hP p v hv

end LinearListHadwiger.Stage

namespace LinearListHadwiger.Stage
open SimpleGraph Finset
attribute [local instance] Classical.propDecidable

theorem grouped_ends {V P I : Type} [Fintype V] [DecidableEq V]
    [Fintype P] [Fintype I] [DecidableEq I]
    (G : SimpleGraph V) (D : Finset V) (y : P → V)
    (hy : Function.Injective y) (hyD : ∀ p, y p∈D)
    (owner : P → I) (hs : Function.Surjective owner)
    (hp : 1≤Fintype.card P) (hc : KConnectedOn G D (65536*Fintype.card P)) :
    ∃ E : I → Set V,
      (∀ i, (G.induce (E i)).Connected) ∧
      (∀ i j, i≠j → Disjoint (E i) (E j)) ∧
      (∀ i, E i⊆(↑D : Set V)) ∧ ∀ p, y p∈E (owner p) := by
  classical
  let yr : P → ↥D := fun p => ⟨y p,hyD p⟩
  have hyr : Function.Injective yr := fun _ _ he => hy (congrArg Subtype.val he)
  let A : Finset ↥D := univ.image yr
  have hAc : A.card=Fintype.card P := by rw [card_image_of_injective _ hyr,card_univ]
  have ha (p : P) : yr p∈A := mem_image.mpr ⟨p,mem_univ _,rfl⟩
  have hpre : ∀ a : ↥A, ∃ p, yr p=a.val := by
    intro a
    obtain ⟨p,_,he⟩ := mem_image.mp a.property
    exact ⟨p,he⟩
  choose idx hidx using hpre
  have hi (p : P) : idx ⟨yr p,ha p⟩=p := hyr (hidx ⟨yr p,ha p⟩)
  let lab : ↥A → I := fun a => owner (idx a)
  have hls : Function.Surjective lab := by
    intro i
    obtain ⟨p,rfl⟩ := hs i
    exact ⟨⟨yr p,ha p⟩,congrArg owner (hi p)⟩
  have hc' : KConnectedOn (G.induce (↑D : Set V)) univ (65536*A.card) := by
    rw [hAc]
    exact Knitting.induce_connected G D hc
  obtain ⟨E,hE,hEE,hterm⟩ := Knitting.group_terminals (G.induce (↑D : Set V)) A lab hls
    (by omega) hc'
  let M := Knitting.model_induce G D
  refine ⟨fun i => M.expand (E i),fun i => M.expand_connected (hE i),
    fun i j hij => M.expand_disjoint (hEE i j hij),?_,?_⟩
  · intro i v hv
    obtain ⟨w,_,hw⟩ := hv
    have he : v=w.val := hw
    exact he ▸ w.property
  · intro p
    refine ⟨yr p,?_,rfl⟩
    simpa only [lab,hi] using hterm ⟨yr p,ha p⟩

end LinearListHadwiger.Stage

end OAI