import OAI.Combinatorics.Automata.Wiring

namespace OAI

namespace OneWayLiveness

namespace Pairing
open scoped Classical
variable {A B C : Type*}

@[simp] lemma identity_link (x y : A ⊕ A) :
    (identity A).link x y ↔ Sum.swap x = y := by
  cases x <;> rfl

lemma eq_identity (a : Pairing (A ⊕ A))
    (h : ∀ i, a.link (.inl i) (.inr i)) : a = identity A := by
  apply Pairing.ext
  funext x y
  apply propext
  rw [a.link_iff, identity_link]
  have hm : a.mate x = Sum.swap x := by
    cases x with
    | inl i => exact (a.eq_mate (h i)).symm
    | inr i => exact (a.eq_mate (a.symm (h i))).symm
  rw [hm]

variable [Fintype A] [Fintype B] [Fintype C]

lemma compose_link_iff (a : Pairing (A ⊕ B)) (b : Pairing (B ⊕ C)) (x y : A ⊕ C) :
    (compose a b).link x y ↔ x ≠ y ∧ (glueGraph a b).Reachable (outer x) (outer y) := Iff.rfl

lemma compose_left_cap (a : Pairing (A ⊕ B)) (b : Pairing (B ⊕ C))
    {i j : A} (h : a.link (.inl i) (.inl j)) :
    (compose a b).link (.inl i) (.inl j) := by
  refine ⟨?_, ?_⟩
  · intro he
    have hij : i = j := Sum.inl.inj he
    subst j
    exact a.irrefl _ h
  · exact (show (glueGraph a b).Adj (.inl (.inl i)) (.inl (.inl j)) from h).reachable

lemma compose_right_cap (a : Pairing (A ⊕ B)) (b : Pairing (B ⊕ C))
    {i j : C} (h : b.link (.inr i) (.inr j)) :
    (compose a b).link (.inr i) (.inr j) := by
  refine ⟨?_, ?_⟩
  · intro he
    have hij : i = j := Sum.inr.inj he
    subst j
    exact b.irrefl _ h
  · exact (show (glueGraph a b).Adj (.inr (.inr i)) (.inr (.inr j)) from h).reachable

lemma compose_transversal (a : Pairing (A ⊕ B)) (b : Pairing (B ⊕ C))
    {i : A} {j : B} {k : C} (ha : a.link (.inl i) (.inr j))
    (hb : b.link (.inl j) (.inr k)) : (compose a b).link (.inl i) (.inr k) := by
  refine ⟨Sum.inl_ne_inr, ?_⟩
  exact (show (glueGraph a b).Adj (.inl (.inl i)) (.inl (.inr j)) from ha).reachable.trans
    ((show (glueGraph a b).Adj (.inl (.inr j)) (.inr (.inl j)) from rfl).reachable.trans
      (show (glueGraph a b).Adj (.inr (.inl j)) (.inr (.inr k)) from hb).reachable)

noncomputable def lefts (a : Pairing (A ⊕ B)) : Finset A :=
  Finset.univ.filter fun i => ∃ j, a.link (.inl i) (.inr j)
noncomputable def rights (a : Pairing (A ⊕ B)) : Finset B :=
  Finset.univ.filter fun j => ∃ i, a.link (.inl i) (.inr j)
noncomputable def rank (a : Pairing (A ⊕ B)) : ℕ := (lefts a).card

@[simp] lemma mem_lefts (a : Pairing (A ⊕ B)) (i : A) :
    i ∈ lefts a ↔ ∃ j, a.link (.inl i) (.inr j) := by simp [lefts]
@[simp] lemma mem_rights (a : Pairing (A ⊕ B)) (j : B) :
    j ∈ rights a ↔ ∃ i, a.link (.inl i) (.inr j) := by simp [rights]

/-- The matching bijects its left and right transversal endpoints. -/
noncomputable def transversalEquiv (a : Pairing (A ⊕ B)) :
    {i // i ∈ lefts a} ≃ {j // j ∈ rights a} := by
  let f : {i // i ∈ lefts a} → {j // j ∈ rights a} := fun i =>
    ⟨(mem_lefts a i).mp i.property |>.choose,
      (mem_rights a _).mpr ⟨i, ((mem_lefts a i).mp i.property).choose_spec⟩⟩
  have hf (i : {i // i ∈ lefts a}) : a.link (.inl i.val) (.inr (f i).val) :=
    ((mem_lefts a i).mp i.property).choose_spec
  refine Equiv.ofBijective f ⟨?_, ?_⟩
  · intro i j hij
    apply Subtype.ext
    have hh := a.eq_mate (a.symm (hf i))
    have hj := a.eq_mate (a.symm (hf j))
    rw [hij] at hh
    exact Sum.inl.inj (hh.trans hj.symm)
  · intro j
    obtain ⟨i, hij⟩ := (mem_rights a j).mp j.property
    let i' : {i // i ∈ lefts a} := ⟨i, (mem_lefts a i).mpr ⟨j, hij⟩⟩
    refine ⟨i', Subtype.ext ?_⟩
    exact Sum.inr.inj ((a.eq_mate (hf i')).trans (a.eq_mate hij).symm)

lemma rank_eq_rights (a : Pairing (A ⊕ B)) : rank a = (rights a).card := by
  simpa only [Fintype.card_coe, rank] using Fintype.card_congr (transversalEquiv a)

lemma lefts_compose_subset (a : Pairing (A ⊕ B)) (b : Pairing (B ⊕ C)) :
    lefts (compose a b) ⊆ lefts a := by
  intro i hi
  obtain ⟨k, hik⟩ := (mem_lefts _ _).mp hi
  obtain ⟨j, hij, _⟩ := a.unique (.inl i)
  rcases j with j | j
  · have hh := compose_left_cap a b hij
    have he := ((compose a b).eq_mate hh).trans ((compose a b).eq_mate hik).symm
    cases he
  · exact (mem_lefts _ _).mpr ⟨j, hij⟩

lemma rights_compose_subset (a : Pairing (A ⊕ B)) (b : Pairing (B ⊕ C)) :
    rights (compose a b) ⊆ rights b := by
  intro k hk
  obtain ⟨i, hik⟩ := (mem_rights _ _).mp hk
  obtain ⟨j, hkj, _⟩ := b.unique (.inr k)
  rcases j with j | j
  · exact (mem_rights _ _).mpr ⟨j, b.symm hkj⟩
  · have hh := compose_right_cap a b hkj
    have he := ((compose a b).eq_mate hh).trans
      ((compose a b).eq_mate ((compose a b).symm hik)).symm
    cases he

lemma rank_compose_le_left (a : Pairing (A ⊕ B)) (b : Pairing (B ⊕ C)) :
    rank (compose a b) ≤ rank a := Finset.card_le_card (lefts_compose_subset a b)
lemma rank_compose_le_right (a : Pairing (A ⊕ B)) (b : Pairing (B ⊕ C)) :
    rank (compose a b) ≤ rank b := by
  rw [rank_eq_rights, rank_eq_rights]
  exact Finset.card_le_card (rights_compose_subset a b)
lemma rank_le_card (a : Pairing (A ⊕ B)) : rank a ≤ Fintype.card A :=
  Finset.card_le_univ _

noncomputable def support (a : Pairing (A ⊕ A)) : Finset A :=
  Finset.univ.filter fun i => ¬ a.link (.inl i) (.inr i)
@[simp] lemma mem_support (a : Pairing (A ⊕ A)) (i : A) :
    i ∈ support a ↔ ¬ a.link (.inl i) (.inr i) := by simp [support]

lemma defect_le_support (a : Pairing (A ⊕ A)) :
    Fintype.card A - rank a ≤ (support a).card := by
  have hs : Finset.univ \ support a ⊆ lefts a := by
    intro i hi
    simp only [Finset.mem_sdiff, Finset.mem_univ, mem_support, not_not, true_and] at hi
    exact (mem_lefts a i).mpr ⟨i, hi⟩
  have hc := Finset.card_le_card hs
  rw [Finset.card_sdiff_of_subset (Finset.subset_univ _), Finset.card_univ] at hc
  unfold rank
  omega

lemma support_compose_subset (a b : Pairing (A ⊕ A)) :
    support (compose a b) ⊆ support a ∪ support b := by
  intro i hi
  by_contra hn
  have ha : a.link (.inl i) (.inr i) := by
    simpa using (Finset.notMem_union.mp hn).1
  have hb : b.link (.inl i) (.inr i) := by
    simpa using (Finset.notMem_union.mp hn).2
  exact (mem_support _ _).mp hi (compose_transversal a b ha hb)

lemma support_idempotent_subset (e : Pairing (A ⊕ A)) (he : compose e e = e) :
    support e ⊆ (Finset.univ \ lefts e) ∪ (Finset.univ \ rights e) := by
  intro i hi
  by_contra hn
  have hl : i ∈ lefts e := by simpa using (Finset.notMem_union.mp hn).1
  have hr : i ∈ rights e := by simpa using (Finset.notMem_union.mp hn).2
  obtain ⟨j, hij⟩ := (mem_lefts _ _).mp hl
  obtain ⟨k, hki⟩ := (mem_rights _ _).mp hr
  have hkj := compose_transversal e e hki hij
  rw [he] at hkj
  have hji : j = i := Sum.inr.inj ((e.eq_mate hkj).trans (e.eq_mate hki).symm)
  subst j
  exact (mem_support _ _).mp hi hij

lemma support_idempotent_bound (e : Pairing (A ⊕ A)) (he : compose e e = e) :
    (support e).card ≤ 2 * (Fintype.card A - rank e) := by
  calc
    _ ≤ ((Finset.univ \ lefts e) ∪ (Finset.univ \ rights e)).card :=
      Finset.card_le_card (support_idempotent_subset e he)
    _ ≤ (Finset.univ \ lefts e).card + (Finset.univ \ rights e).card := Finset.card_union_le _ _
    _ = _ := by
      rw [Finset.card_sdiff_of_subset (Finset.subset_univ _),
        Finset.card_sdiff_of_subset (Finset.subset_univ _), Finset.card_univ,
        ← rank_eq_rights]
      simp only [rank, two_mul]

lemma idempotent_full_rank (e : Pairing (A ⊕ A)) (he : compose e e = e)
    (hr : rank e = Fintype.card A) : e = identity A := by
  apply eq_identity
  intro i
  have hs := support_idempotent_bound e he
  rw [hr, Nat.sub_self, mul_zero] at hs
  have hempty : support e = ∅ := Finset.card_eq_zero.mp (Nat.eq_zero_of_le_zero hs)
  have hni : i ∉ support e := by simp [hempty]
  simpa only [mem_support, not_not] using hni

end Pairing


namespace Pairing
open scoped Classical
variable {P : Type*} {A B C D : Type*}

lemma eq_of_link_imp (a b : Pairing P)
    (h : ∀ x y, a.link x y → b.link x y) : a = b := by
  apply Pairing.ext
  funext x y
  apply propext
  refine ⟨h x y, fun hb => ?_⟩
  have he : y = a.mate x := (b.eq_mate hb).trans (b.eq_mate (h x _ (a.mate_link x))).symm
  rw [he]
  exact a.mate_link x

def flip (a : Pairing (A ⊕ B)) : Pairing (B ⊕ A) := a.transport (Equiv.sumComm A B)

@[simp] lemma flip_link (a : Pairing (A ⊕ B)) (x y : B ⊕ A) :
    (flip a).link x y ↔ a.link (Sum.swap x) (Sum.swap y) := Iff.rfl

lemma flip_flip (a : Pairing (A ⊕ B)) : flip (flip a) = a := by
  ext x y
  simp only [flip_link, Sum.swap_swap]

variable [Fintype A] [Fintype B] [Fintype C] [Fintype D]

lemma left_cap_not_lefts (a : Pairing (A ⊕ B)) {i j : A}
    (h : a.link (.inl i) (.inl j)) : i ∉ lefts a := by
  intro hi
  obtain ⟨k, hik⟩ := (mem_lefts a i).mp hi
  have he := (a.eq_mate h).trans (a.eq_mate hik).symm
  cases he

lemma right_cap_not_rights (a : Pairing (A ⊕ B)) {i j : B}
    (h : a.link (.inr i) (.inr j)) : i ∉ rights a := by
  intro hi
  obtain ⟨k, hki⟩ := (mem_rights a i).mp hi
  have he := (a.eq_mate h).trans (a.eq_mate (a.symm hki)).symm
  cases he

lemma compose_flip_eq_identity (a : Pairing (A ⊕ B))
    (ha : ∀ i, i ∈ lefts a) : compose a (flip a) = identity A := by
  apply eq_identity
  intro i
  obtain ⟨j, hij⟩ := (mem_lefts a i).mp (ha i)
  exact compose_transversal a (flip a) hij (a.symm hij)

lemma compose_cancel_left (u : Pairing (A ⊕ B)) (v : Pairing (B ⊕ A))
    (hu : compose v u = identity B) {x y : Pairing (B ⊕ C)}
    (h : compose u x = compose u y) : x = y := by
  have hh := congrArg (compose v) h
  simpa only [← compose_assoc, hu, identity_compose] using hh

lemma compose_cancel_right (u : Pairing (A ⊕ B)) (v : Pairing (B ⊕ A))
    (hu : compose u v = identity A) {x y : Pairing (C ⊕ A)}
    (h : compose x u = compose y u) : x = y := by
  have hh := congrArg (fun z => compose z v) h
  simpa only [compose_assoc, hu, compose_identity] using hh

/-- Retain the left caps and straighten the left transversal endpoints. -/
noncomputable def splitLeft (e : Pairing (A ⊕ A)) : Pairing (A ⊕ {i // i ∈ lefts e}) where
  link
    | .inl i, .inl j => e.link (.inl i) (.inl j)
    | .inl i, .inr j => i = j.val
    | .inr i, .inl j => i.val = j
    | .inr _, .inr _ => False
  symm := by
    intro x y h
    rcases x with x | x <;> rcases y with y | y
    · exact e.symm h
    · exact h.symm
    · exact h.symm
    · exact h
  irrefl := by
    intro x
    cases x with
    | inl i => exact e.irrefl _
    | inr i => exact id
  unique := by
    intro x
    cases x with
    | inl i =>
      by_cases hi : i ∈ lefts e
      · refine ⟨.inr ⟨i, hi⟩, rfl, ?_⟩
        intro y hy
        cases y with
        | inl j => exact ((left_cap_not_lefts e hy) hi).elim
        | inr j => exact congrArg Sum.inr (Subtype.ext hy.symm)
      · obtain ⟨y, hy, hu⟩ := e.unique (.inl i)
        rcases y with j | j
        · refine ⟨.inl j, hy, ?_⟩
          intro y hy'
          cases y with
          | inl k => exact congrArg Sum.inl (Sum.inl.inj (hu (.inl k) hy'))
          | inr k => exact (hi (hy' ▸ k.property)).elim
        · exact (hi ((mem_lefts e i).mpr ⟨j, hy⟩)).elim
    | inr i =>
      refine ⟨.inl i.val, rfl, ?_⟩
      intro y hy
      cases y with
      | inl j => exact congrArg Sum.inl hy.symm
      | inr j => exact hy.elim

/-- Retain the right caps and all the original transversals. -/
noncomputable def splitRight (e : Pairing (A ⊕ A)) : Pairing ({i // i ∈ lefts e} ⊕ A) where
  link
    | .inl _, .inl _ => False
    | .inl i, .inr j => e.link (.inl i.val) (.inr j)
    | .inr i, .inl j => e.link (.inr i) (.inl j.val)
    | .inr i, .inr j => e.link (.inr i) (.inr j)
  symm := by
    intro x y h
    rcases x with x | x <;> rcases y with y | y
    · exact h
    all_goals exact e.symm h
  irrefl := by
    intro x
    cases x with
    | inl i => exact id
    | inr i => exact e.irrefl _
  unique := by
    intro x
    cases x with
    | inl i =>
      obtain ⟨j, hij⟩ := (mem_lefts e i).mp i.property
      refine ⟨.inr j, hij, ?_⟩
      intro y hy
      cases y with
      | inl k => exact hy.elim
      | inr k =>
        exact congrArg Sum.inr (Sum.inr.inj ((e.eq_mate hy).trans (e.eq_mate hij).symm))
    | inr i =>
      obtain ⟨y, hy, hu⟩ := e.unique (.inr i)
      rcases y with j | j
      · have hj : j ∈ lefts e := (mem_lefts e j).mpr ⟨i, e.symm hy⟩
        refine ⟨.inl ⟨j, hj⟩, hy, ?_⟩
        intro y hy'
        cases y with
        | inl k => exact congrArg Sum.inl (Subtype.ext (Sum.inl.inj (hu _ hy')))
        | inr k => have hh := hu _ hy'; cases hh
      · refine ⟨.inr j, hy, ?_⟩
        intro y hy'
        cases y with
        | inl k => have hh := hu _ hy'; cases hh
        | inr k => exact congrArg Sum.inr (Sum.inr.inj (hu _ hy'))

lemma splitLeft_splitRight (e : Pairing (A ⊕ A)) :
    compose (splitLeft e) (splitRight e) = e := by
  symm
  apply eq_of_link_imp
  intro x y hxy
  rcases x with x | x <;> rcases y with y | y
  · exact compose_left_cap _ _ hxy
  · let x' : {i // i ∈ lefts e} := ⟨x, (mem_lefts e x).mpr ⟨y, hxy⟩⟩
    exact compose_transversal _ _ (show (splitLeft e).link (.inl x) (.inr x') from rfl) hxy
  · let y' : {i // i ∈ lefts e} := ⟨y, (mem_lefts e y).mpr ⟨x, e.symm hxy⟩⟩
    exact (compose (splitLeft e) (splitRight e)).symm
      (compose_transversal _ _ (show (splitLeft e).link (.inl y) (.inr y') from rfl) (e.symm hxy))
  · exact compose_right_cap _ _ hxy

lemma splitLeft_inverse (e : Pairing (A ⊕ A)) :
    compose (flip (splitLeft e)) (splitLeft e) = identity {i // i ∈ lefts e} := by
  apply eq_identity
  intro i
  exact compose_transversal _ _
    (show (flip (splitLeft e)).link (.inl i) (.inr i.val) from rfl)
    (show (splitLeft e).link (.inl i.val) (.inr i) from rfl)

lemma splitRight_inverse (e : Pairing (A ⊕ A)) :
    compose (splitRight e) (flip (splitRight e)) = identity {i // i ∈ lefts e} := by
  apply compose_flip_eq_identity
  intro i
  obtain ⟨j, hij⟩ := (mem_lefts e i).mp i.property
  exact (mem_lefts _ _).mpr ⟨j, hij⟩

lemma splitRight_splitLeft (e : Pairing (A ⊕ A)) (he : compose e e = e) :
    compose (splitRight e) (splitLeft e) = identity {i // i ∈ lefts e} := by
  apply compose_cancel_left (splitLeft e) (flip (splitLeft e)) (splitLeft_inverse e)
  apply compose_cancel_right (splitRight e) (flip (splitRight e)) (splitRight_inverse e)
  have hh := he
  rw [← splitLeft_splitRight e] at hh
  simpa only [compose_assoc, identity_compose] using hh

end Pairing

end OneWayLiveness

end OAI