import OAI.Computability.MatchingCount.OddCutUncross

namespace OAI

section

namespace BinaryMatching.OddMincut
open Finset UnitFlow UnitMincut TerminalMincut CutAlgebra OddCutParity OddCutUncross
variable {n : ℕ}

def outside (A : Finset (Fin n)) : Option (Fin n) :=
  (List.finRange n).find? (fun v => decide (v∉A))

lemma outside_some (A : Finset (Fin n)) (hA : Aᶜ.Nonempty) :
    ∃ r, outside A=some r ∧ r∉A := by
  obtain ⟨v,hv⟩ := hA
  have hv' : v∉A := mem_compl.mp hv
  cases he : outside A with
  | none =>
    have hh := List.find?_eq_none.mp he v (by simp)
    simp [hv'] at hh
  | some r =>
    have hh := List.find?_some (show (List.finRange n).find?
      (fun v => decide (v∉A))=some r from he)
    exact ⟨r,rfl,by simpa using hh⟩

def cheaper (c : Fin n → Fin n → ℕ) (S T : Finset (Fin n)) : Finset (Fin n) :=
  if cutCapacity c S ≤ cutCapacity c T then S else T

lemma cheaper_le_left (c : Fin n → Fin n → ℕ) (S T : Finset (Fin n)) :
    cutCapacity c (cheaper c S T) ≤ cutCapacity c S := by
  unfold cheaper; split_ifs <;> omega

lemma cheaper_le_right (c : Fin n → Fin n → ℕ) (S T : Finset (Fin n)) :
    cutCapacity c (cheaper c S T) ≤ cutCapacity c T := by
  unfold cheaper; split_ifs <;> omega

lemma cheaper_odd (c : Fin n → Fin n → ℕ) (U S T : Finset (Fin n))
    (hS : OddSide U S) (hT : OddSide U T) : OddSide U (cheaper c S T) := by
  unfold cheaper; split_ifs <;> assumption

def recurse : ℕ → (Fin n → Fin n → ℕ) → Finset (Fin n) → Finset (Fin n)
  | 0,_,_ => ∅
  | k+1,c,U =>
    let A := terminalCut c U
    if OddSide U A then A else
      match outside A, outside Aᶜ with
      | some r, some q =>
        cheaper c
          (lift (contractMap A r) (recurse k (push c (contractMap A r)) (A∩U)))
          (lift (contractMap Aᶜ q) (recurse k (push c (contractMap Aᶜ q)) (Aᶜ∩U)))
      | _,_ => ∅

lemma recurse_correct (fuel : ℕ) (c : Fin n → Fin n → ℕ)
    (hc : ∀ i j, c i j=c j i) (U : Finset (Fin n)) (he : Even U.card)
    (hU : 2≤U.card) (hbound : U.card≤fuel) :
    OddSide U (recurse fuel c U) ∧
      ∀ S, OddSide U S → cutCapacity c (recurse fuel c U) ≤ cutCapacity c S := by
  induction fuel generalizing c U with
  | zero => omega
  | succ k ih =>
    let A := terminalCut c U
    obtain ⟨hsep,hmin⟩ := terminalCut_correct c U hU
    change Separates U A at hsep
    change ∀ T, Separates U T → cutCapacity c A ≤ cutCapacity c T at hmin
    by_cases hodd : OddSide U A
    · have heq : recurse (k+1) c U=A := by
        rw [recurse]
        change (if OddSide U A then A else _)=A
        exact ite_eq_left hodd
      rw [heq]
      exact ⟨hodd,fun S hS => hmin S (odd_separates U S he hS)⟩
    · have heA : Even (A∩U).card := by
        simp only [OddSide,Nat.odd_iff] at hodd
        rw [Nat.even_iff]; omega
      have heB := even_other U A he heA
      obtain ⟨hposA,hposB⟩ := separate_cards U A hsep
      have hpart := terminal_partition U A
      have htwoA : 2≤(A∩U).card := by rw [Nat.even_iff] at heA; omega
      have htwoB : 2≤(Aᶜ∩U).card := by rw [Nat.even_iff] at heB; omega
      have hboundA : (A∩U).card≤k := by omega
      have hboundB : (Aᶜ∩U).card≤k := by omega
      have hnonA : A.Nonempty := by
        obtain ⟨v,hv⟩ := card_pos.mp hposA
        exact ⟨v,(mem_inter.mp hv).1⟩
      have hnonB : Aᶜ.Nonempty := by
        obtain ⟨v,hv⟩ := card_pos.mp hposB
        exact ⟨v,(mem_inter.mp hv).1⟩
      obtain ⟨r,hr,hrA⟩ := outside_some A hnonB
      obtain ⟨q,hq,hqB⟩ := outside_some Aᶜ (by simpa using hnonA)
      let f := contractMap A r
      let g := contractMap Aᶜ q
      let X := recurse k (push c f) (A∩U)
      let Y := recurse k (push c g) (Aᶜ∩U)
      obtain ⟨hX,minX⟩ := ih (push c f) (push_symm c hc f) (A∩U) heA htwoA hboundA
      obtain ⟨hY,minY⟩ := ih (push c g) (push_symm c hc g) (Aᶜ∩U) heB htwoB hboundB
      change OddSide (A∩U) X at hX
      change OddSide (Aᶜ∩U) Y at hY
      have hLX : OddSide U (lift f X) := (odd_lift_iff U A X r heB).2 hX
      have hLY : OddSide U (lift g Y) :=
        (odd_lift_iff U Aᶜ Y q (by simpa using heA)).2 hY
      have heq : recurse (k+1) c U=cheaper c (lift f X) (lift g Y) := by
        rw [recurse]
        change (if OddSide U A then A else _) = _
        rw [ite_eq_right hodd,hr,hq]
      rw [heq]
      refine ⟨cheaper_odd c U _ _ hLX hLY,?_⟩
      intro S hS
      by_cases hSA : OddSide (A∩U) S
      · obtain ⟨T,hTA,hT,hcap⟩ := uncross_on_side c hc U A S hsep heA hmin hSA
        have hchild := (odd_subset_iff U A T hTA).2 hT
        have hminT := minX T hchild
        change cutCapacity (push c f) X ≤ cutCapacity (push c f) T at hminT
        rw [cut_push] at hminT
        rw [show f=contractMap A r from rfl,cut_contract_subset c A T r hrA hTA] at hminT
        exact (cheaper_le_left c _ _).trans (hminT.trans hcap)
      · have hSB := split_odd U S A hS hSA
        have hminB : ∀ T, Separates U T → cutCapacity c Aᶜ ≤ cutCapacity c T := by
          simpa only [cut_compl c hc] using hmin
        obtain ⟨T,hTB,hT,hcap⟩ := uncross_on_side c hc U Aᶜ S
          (separates_compl U A hsep) heB hminB hSB
        have hchild := (odd_subset_iff U Aᶜ T hTB).2 hT
        have hminT := minY T hchild
        change cutCapacity (push c g) Y ≤ cutCapacity (push c g) T at hminT
        rw [cut_push] at hminT
        rw [show g=contractMap Aᶜ q from rfl,cut_contract_subset c Aᶜ T q hqB hTB] at hminT
        exact (cheaper_le_right c _ _).trans (hminT.trans hcap)

def oddCut (c : Fin n → Fin n → ℕ) (U : Finset (Fin n)) : Finset (Fin n) :=
  recurse U.card c U

 theorem oddCut_correct (c : Fin n → Fin n → ℕ) (hc : ∀ i j, c i j=c j i)
    (U : Finset (Fin n)) (he : Even U.card) (hU : 2≤U.card) :
    OddSide U (oddCut c U) ∧
      ∀ S, OddSide U S → cutCapacity c (oddCut c U) ≤ cutCapacity c S :=
  recurse_correct U.card c hc U he hU le_rfl

end BinaryMatching.OddMincut
end

end OAI