import OAI.Combinatorics.PerfectMatching.FeasibilityRepair

namespace OAI

section

namespace BinaryMatching.Algorithm
noncomputable section
open Finset MatchingEntropy
variable {n : ℕ}

def Affine.evalReal (r : Affine n) (x : Pair n → ℝ) : ℝ :=
  (∑ e,(r.coeff e:ℝ)*x e)+r.constant

def allRows (n : ℕ) : List (Affine n) :=
  zeroRow :: ((List.finRange n).flatMap (fun v => [degreeRow v true,degreeRow v false])) ++
    (univ.toList.filter (fun S : Finset (Fin n) => decide (Odd S.card))).map cutRow

def maxRow (x : Pair n → ℝ) : Affine n := by
  classical
  exact ((allRows n).argmax (fun r => r.evalReal x)).getD zeroRow

def violation (x : Pair n → ℝ) : ℝ := (maxRow x).evalReal x

lemma maxRow_mem_argmax (x : Pair n → ℝ) :
    maxRow x ∈ (allRows n).argmax (fun r => r.evalReal x) := by
  classical
  unfold maxRow
  cases he : (allRows n).argmax (fun r => r.evalReal x) with
  | none => have hh := List.argmax_eq_none.mp he; simp [allRows] at hh
  | some r => simp

lemma row_le_violation (x : Pair n → ℝ) (r : Affine n) (hr : r∈allRows n) :
    r.evalReal x≤violation x := List.le_of_mem_argmax hr (maxRow_mem_argmax x)

lemma violation_le (x : Pair n → ℝ) (b : ℝ) (h : ∀ r∈allRows n,r.evalReal x≤b) :
    violation x≤b := h _ (List.argmax_mem (maxRow_mem_argmax x))

lemma mem_allRows (r : Affine n) : r∈allRows n ↔
    r=zeroRow ∨ (∃ v,r=degreeRow v true ∨ r=degreeRow v false) ∨
      ∃ S : Finset (Fin n),Odd S.card ∧ r=cutRow S := by
  simp only [allRows,List.mem_append,List.mem_cons,List.mem_flatMap,List.mem_finRange,
    true_and,List.mem_map,List.mem_filter,mem_toList,mem_univ]
  aesop

lemma zero_row_eval (x : Pair n → ℝ) : (zeroRow : Affine n).evalReal x=0 := by
  simp [Affine.evalReal,zeroRow]

lemma degree_row_eval_pos (x : Pair n → ℝ) (v : Fin n) :
    (degreeRow v true).evalReal x=(completeGraph n).degree x v-1 := by
  simp [Affine.evalReal,degreeRow,LooplessGraph.degree,LooplessGraph.Incident,completeGraph,
    ite_mul,sub_eq_add_neg]
  apply sum_congr rfl; intro e _; rfl

lemma degree_row_eval_neg (x : Pair n → ℝ) (v : Fin n) :
    (degreeRow v false).evalReal x=1-(completeGraph n).degree x v := by
  simp only [Affine.evalReal,degreeRow,Bool.false_eq_true,↓reduceIte,Int.cast_one,
    Int.cast_ite,Int.cast_neg,Int.cast_zero,ite_mul,neg_one_mul,zero_mul]
  have he : (∑ e : Pair n,if e.val.1=v ∨ e.val.2=v then -x e else 0)=
      -(completeGraph n).degree x v := by
    simp only [LooplessGraph.degree,LooplessGraph.Incident,completeGraph,←sum_neg_distrib]
    apply sum_congr rfl; intro e _; split_ifs <;> simp_all
  rw [he]; ring

lemma cut_row_eval (x : Pair n → ℝ) (S : Finset (Fin n)) :
    (cutRow S).evalReal x=1-(completeGraph n).cutMass x S := by
  have he (e : Pair n) : ((e.val.1∈S ∧ e.val.2∉S) ∨ (e.val.2∈S ∧ e.val.1∉S)) ↔
      (completeGraph n).Crosses S e := by
    simp only [LooplessGraph.Crosses,completeGraph]; tauto
  simp only [Affine.evalReal,cutRow,he,Int.cast_ite,Int.cast_neg,Int.cast_one,
    Int.cast_zero,ite_mul,neg_one_mul,zero_mul]
  have hsum : (∑ e : Pair n,if (completeGraph n).Crosses S e then -x e else 0)=
      -(completeGraph n).cutMass x S := by
    simp only [LooplessGraph.cutMass,LooplessGraph.cut,sum_filter,←sum_neg_distrib]
    apply sum_congr rfl; intro e _; split_ifs <;> simp_all
  rw [hsum]; ring

lemma violation_nonneg (x : Pair n → ℝ) : 0≤violation x := by
  simpa only [zero_row_eval] using row_le_violation x zeroRow ((mem_allRows _).2 (Or.inl rfl))

lemma degree_violation (x : Pair n → ℝ) (v : Fin n) :
    |(completeGraph n).degree x v-1|≤violation x := by
  have hp := row_le_violation x (degreeRow v true)
    ((mem_allRows _).2 (Or.inr (Or.inl ⟨v,Or.inl rfl⟩)))
  have hm := row_le_violation x (degreeRow v false)
    ((mem_allRows _).2 (Or.inr (Or.inl ⟨v,Or.inr rfl⟩)))
  rw [degree_row_eval_pos] at hp; rw [degree_row_eval_neg] at hm
  exact abs_le.mpr ⟨by linarith,hp⟩

lemma cut_violation (x : Pair n → ℝ) (S : Finset (Fin n)) (hS : Odd S.card) :
    1-violation x≤(completeGraph n).cutMass x S := by
  have hh := row_le_violation x (cutRow S)
    ((mem_allRows _).2 (Or.inr (Or.inr ⟨S,hS,rfl⟩)))
  rw [cut_row_eval] at hh; linarith

lemma violation_feasible (heven : Even n) {x : Pair n → ℝ}
    (hx : x∈(completeGraph n).polytope) : violation x=0 := by
  rw [(completeGraph n).polytope_eq_constraints (by simpa using heven)] at hx
  apply le_antisymm _ (violation_nonneg x)
  apply violation_le
  intro r hr
  rcases (mem_allRows r).1 hr with rfl|⟨v,rfl|rfl⟩|⟨S,hS,rfl⟩
  · rw [zero_row_eval]
  · rw [degree_row_eval_pos,hx.2.1]; norm_num
  · rw [degree_row_eval_neg,hx.2.1]; norm_num
  · rw [cut_row_eval]; linarith [hx.2.2 S hS]

lemma violation_repair (hn : 4≤n) (heven : Even n) (x : Pair n → ℝ)
    (hx : ∀ e,x e∈Set.Icc (0:ℝ) 1) : ∃ y∈(completeGraph n).polytope,
      ∀ e,|y e-x e|≤(2+10*(n:ℝ)^2)*violation x :=
  feasibility_repair hn heven hx (violation_nonneg x) (degree_violation x) (cut_violation x)

lemma row_difference (r : Affine n) (x z : Pair n → ℝ) :
    r.evalReal z=r.evalReal x+∑ e,(r.coeff e:ℝ)*(z e-x e) := by
  simp only [Affine.evalReal,mul_sub,sum_sub_distrib]; ring

lemma row_coeff_bound (r : Affine n) (hr : r∈allRows n) (e : Pair n) : |(r.coeff e:ℝ)|≤1 := by
  rcases (mem_allRows r).1 hr with rfl|⟨v,rfl|rfl⟩|⟨S,_,rfl⟩
  · simp [zeroRow]
  · simp only [degreeRow,↓reduceIte]; split_ifs <;> norm_num
  · simp only [degreeRow,Bool.false_eq_true,↓reduceIte]; split_ifs <;> norm_num
  · simp only [cutRow]; split_ifs <;> norm_num

lemma active_row_subgradient (x : Pair n → ℝ) (r : Affine n)
    (hr : r∈allRows n) (ha : r.evalReal x=violation x) (z : Pair n → ℝ) :
    violation x+∑ e,(r.coeff e:ℝ)*(z e-x e)≤violation z := by
  rw [←ha,←row_difference]
  exact row_le_violation z r hr

lemma eval_cast (a : Affine n) (x : Pair n → ℚ) :
    a.evalReal (fun e => (x e:ℝ))=(a.eval x:ℝ) := by
  simp [Affine.eval,Affine.evalReal]

lemma capacities_symm (a : Table n ℤ) (i j : Fin n) : capacities a i j=capacities a j i := by
  unfold capacities
  rcases lt_trichotomy i j with h|h|h
  · simp [h,not_lt_of_ge h.le]
  · subst j; rfl
  · simp [h,not_lt_of_ge h.le]

lemma capacities_pair (a : Table n ℤ) (e : Pair n) :
    capacities a e.val.1 e.val.2=(entry a e).toNat := by
  simp [capacities,e.property,entry]

lemma cut_coordinates (D : ℕ) (a : Table n ℤ) (ha : ∀ e,0≤entry a e)
    (S : Finset (Fin n)) :
    (completeGraph n).cutMass (fun e => (coordinates D a e:ℝ)) S=
      (UnitFlow.cutCapacity (capacities a) S:ℝ)/(D:ℝ) := by
  have hx : (fun e => (coordinates D a e:ℝ))=
      (fun e : Pair n => (capacities a e.val.1 e.val.2:ℝ)/(D:ℝ)) := by
    funext e
    simp only [coordinates,Rat.cast_div,Rat.cast_intCast,Rat.cast_natCast,capacities_pair]
    have he : ((entry a e).toNat:ℝ)=((entry a e:ℤ):ℝ) := by exact_mod_cast Int.toNat_of_nonneg (ha e)
    rw [he]
  rw [hx,cut_from_symm (fun i j => (capacities a i j:ℝ)/(D:ℝ)) (fun i j => by rw [capacities_symm a i j])]
  simp only [UnitFlow.cutCapacity,Nat.cast_sum,sum_div]

lemma activeRows_nonempty (a : Table n ℤ) : activeRows a≠[] := by simp [activeRows]

lemma activeRow_mem_argmax (D : ℕ) (a : Table n ℤ) :
    activeRow D a∈(activeRows a).argmax (fun r => r.eval (coordinates D a)) := by
  unfold activeRow
  cases he : (activeRows a).argmax (fun r => r.eval (coordinates D a)) with
  | none => exact (activeRows_nonempty a (List.argmax_eq_none.mp he)).elim
  | some r => simp

lemma mem_activeRows (a : Table n ℤ) (r : Affine n) : r∈activeRows a ↔
    r=zeroRow ∨ (∃ v,r=degreeRow v true ∨ r=degreeRow v false) ∨
      r=cutRow (OddMincut.oddCut (capacities a) univ) := by
  simp only [activeRows,List.mem_append,List.mem_cons,List.mem_flatMap,List.mem_finRange,
    true_and]
  aesop

lemma activeRow_correct (hn : 2≤n) (heven : Even n) {D : ℕ} (hD : 0<D)
    (a : Table n ℤ) (ha : ∀ e,0≤entry a e) :
    activeRow D a∈allRows n ∧
      (activeRow D a).evalReal (fun e => (coordinates D a e:ℝ))=
        violation (fun e => (coordinates D a e:ℝ)) := by
  let S₀ := OddMincut.oddCut (capacities a) univ
  have hh := OddMincut.oddCut_correct (capacities a) (capacities_symm a) univ
    (by simpa using heven) (by simpa using hn)
  have hodd : Odd S₀.card := by simpa [OddCutParity.OddSide] using hh.1
  have hmin (S : Finset (Fin n)) (hS : Odd S.card) :
      UnitFlow.cutCapacity (capacities a) S₀≤UnitFlow.cutCapacity (capacities a) S :=
    hh.2 S (by simpa [OddCutParity.OddSide] using hS)
  have hsub : ∀ r∈activeRows a,r∈allRows n := by
    intro r hr
    rcases (mem_activeRows a r).1 hr with h|h|h
    · exact (mem_allRows r).2 (Or.inl h)
    · exact (mem_allRows r).2 (Or.inr (Or.inl h))
    · exact (mem_allRows r).2 (Or.inr (Or.inr ⟨S₀,hodd,h⟩))
  have ham := List.argmax_mem (activeRow_mem_argmax D a)
  refine ⟨hsub _ ham,le_antisymm (row_le_violation _ _ (hsub _ ham)) ?_⟩
  apply violation_le
  intro r hr
  have hdom (r' : Affine n) (hr' : r'∈activeRows a) :
      r'.evalReal (fun e => (coordinates D a e:ℝ))≤
        (activeRow D a).evalReal (fun e => (coordinates D a e:ℝ)) := by
    simp only [eval_cast]
    exact_mod_cast List.le_of_mem_argmax hr' (activeRow_mem_argmax D a)
  rcases (mem_allRows r).1 hr with h|h|⟨S,hS,rfl⟩
  · exact hdom r ((mem_activeRows a r).2 (Or.inl h))
  · exact hdom r ((mem_activeRows a r).2 (Or.inr (Or.inl h)))
  · apply le_trans _ (hdom (cutRow S₀) ((mem_activeRows a _).2 (Or.inr (Or.inr rfl))))
    rw [cut_row_eval,cut_row_eval,cut_coordinates D a ha,cut_coordinates D a ha]
    have hd : (0:ℝ)≤D := (Nat.cast_pos.mpr hD).le
    have hle : (UnitFlow.cutCapacity (capacities a) S₀:ℝ)≤
        UnitFlow.cutCapacity (capacities a) S := by exact_mod_cast hmin S hS
    linarith [div_le_div_of_nonneg_right hle hd]

end
end BinaryMatching.Algorithm
end

end OAI