import OAI.Computability.MatchingCount.BinaryAlgorithm

namespace OAI

section

namespace BinaryMatching.DenseOracle
open Finset UnitFlow CutAlgebra OddCutParity
variable {n : ℕ}

abbrev Matrix (n : ℕ) (α : Type) := Vector (Vector α n) n

def make {α : Type} (f : Fin n → Fin n → α) : Matrix n α :=
  Vector.ofFn (fun i => Vector.ofFn (f i))

def view {α : Type} (a : Matrix n α) : Fin n → Fin n → α := fun i j => a[i][j]

@[simp] lemma view_make {α : Type} (f : Fin n → Fin n → α) : view (make f)=f := by
  funext i j; simp [view,make]

abbrev Paths (n : ℕ) := Vector (Option (List (Fin n))) n

def pathView (p : Paths n) : ResidualSearch.Table n := fun v => p[v]

def pathInitial (a : Fin n) : Paths n := Vector.ofFn (ResidualSearch.initial a)

def pathStep (c : Matrix n ℕ) (b : Matrix n ℤ) (p : Paths n) : Paths n :=
  Vector.ofFn (ResidualSearch.step (UnitMincut.residual (view c) (view b)) (pathView p))

def search (c : Matrix n ℕ) (b : Matrix n ℤ) (a : Fin n) : ℕ → Paths n
  | 0 => pathInitial a
  | k+1 => pathStep c b (search c b a k)

lemma pathView_ofFn (p : ResidualSearch.Table n) : pathView (Vector.ofFn p)=p := by
  funext v; simp [pathView]

lemma search_view (c : Matrix n ℕ) (b : Matrix n ℤ) (a : Fin n) (k : ℕ) :
    pathView (search c b a k)=ResidualSearch.search (UnitMincut.residual (view c) (view b)) a k := by
  induction k with
  | zero => exact pathView_ofFn _
  | succ k ih => simp only [search,pathStep,pathView_ofFn,ih,ResidualSearch.search]

def augment (c : Matrix n ℕ) (a z : Fin n) (b : Matrix n ℤ) : Matrix n ℤ :=
  match (search c b a n)[z] with
  | none => b
  | some p => make (fun i j => view b i j+pathFlow p i j)

def iterate (c : Matrix n ℕ) (a z : Fin n) : ℕ → Matrix n ℤ
  | 0 => make (fun _ _ => 0)
  | k+1 => augment c a z (iterate c a z k)

lemma augment_view (c : Matrix n ℕ) (a z : Fin n) (b : Matrix n ℤ) :
    view (augment c a z b)=UnitMincut.augment (view c) a z (view b) := by
  have hs := congrFun (search_view c b a n) z
  change (search c b a n)[z]=_ at hs
  simp only [augment,hs,UnitMincut.augment]
  cases h : ResidualSearch.search (UnitMincut.residual (view c) (view b)) a n z <;>
    simp only [view_make]

lemma iterate_view (c : Matrix n ℕ) (a z : Fin n) (k : ℕ) :
    view (iterate c a z k)=UnitMincut.iterate (view c) a z k := by
  induction k with
  | zero => exact view_make _
  | succ k ih => simp only [iterate,augment_view,ih,UnitMincut.iterate]

def mincut (c : Matrix n ℕ) (a z : Fin n) : Finset (Fin n) :=
  let b := iterate c a z (UnitMincut.sourceCapacity (view c) a)
  ResidualSearch.reached (pathView (search c b a n))

lemma mincut_eq (c : Matrix n ℕ) (a z : Fin n) : mincut c a z=UnitMincut.mincut (view c) a z := by
  unfold mincut UnitMincut.mincut
  dsimp only
  rw [search_view]
  have h := iterate_view c a z (UnitMincut.sourceCapacity (view c) a)
  rw [h]

def terminalCut (c : Matrix n ℕ) (U : Finset (Fin n)) : Finset (Fin n) :=
  let cuts := (((List.finRange n).product (List.finRange n)).filter
    (fun az => decide (az.1∈U ∧ az.2∈U ∧ az.1≠az.2))).map
    (fun az => mincut c az.1 az.2)
  ((cuts.argmin (cutCapacity (view c))).getD ∅)

lemma terminalCut_eq (c : Matrix n ℕ) (U : Finset (Fin n)) :
    terminalCut c U=TerminalMincut.terminalCut (view c) U := by
  simp only [terminalCut,mincut_eq,TerminalMincut.terminalCut,TerminalMincut.pairCuts]

def contract (c : Matrix n ℕ) (f : Fin n → Fin n) : Matrix n ℕ := make (push (view c) f)

@[simp] lemma contract_view (c : Matrix n ℕ) (f : Fin n → Fin n) :
    view (contract c f)=push (view c) f := view_make _

def recurse : ℕ → Matrix 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 OddMincut.outside A, OddMincut.outside Aᶜ with
      | some r,some q =>
        let f := contractMap A r
        let g := contractMap Aᶜ q
        let X := recurse k (contract c f) (A∩U)
        let Y := recurse k (contract c g) (Aᶜ∩U)
        OddMincut.cheaper (view c) (lift f X) (lift g Y)
      | _,_ => ∅

lemma recurse_eq (k : ℕ) (c : Matrix n ℕ) (U : Finset (Fin n)) :
    recurse k c U=OddMincut.recurse k (view c) U := by
  induction k generalizing c U with
  | zero => rfl
  | succ k ih =>
    simp only [recurse,terminalCut_eq,OddMincut.recurse]
    split
    · rfl
    · cases h₁ : OddMincut.outside (TerminalMincut.terminalCut (view c) U) <;>
        cases h₂ : OddMincut.outside (TerminalMincut.terminalCut (view c) U)ᶜ <;>
        simp only [ih,contract_view]

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

lemma oddCut_eq (c : Matrix n ℕ) (U : Finset (Fin n)) :
    oddCut c U=OddMincut.oddCut (view c) U := recurse_eq _ _ _

 theorem oddCut_correct (c : Matrix n ℕ) (hc : ∀ i j, view c i j=view 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 (view c) (oddCut c U) ≤ cutCapacity (view c) S := by
  rw [oddCut_eq]
  exact OddMincut.oddCut_correct _ hc _ he hU

end BinaryMatching.DenseOracle
end

end OAI