lean/OAI/Combinatorics/MatchingCount/Machines/TreeBottleneck.lean

import Mathlib
import OAI.Combinatorics.MatchingCount.Complexity.TreeChoiceCosts

namespace OAI

namespace MatchingFPRAS.TreeFraction
open TreeTyped

def maximum (x : Fraction×Fraction) : Fraction := if less x then x.2 else x.1
def minimum (x : Fraction×Fraction) : Fraction := if less x then x.1 else x.2
def maximumRealizer : Realizer maximum := (choose lessRealizer second first).congr (fun _=>rfl)
def minimumRealizer : Realizer minimum := (choose lessRealizer first second).congr (fun _=>rfl)
lemma polynomial_maximum : PolynomialTime maximumRealizer := by
  exact polynomial_congr _ (polynomial_choose polynomial_less polynomial_second polynomial_first)
lemma polynomial_minimum : PolynomialTime minimumRealizer := by
  exact polynomial_congr _ (polynomial_choose polynomial_less polynomial_first polynomial_second)
lemma maximum_eq (x y : Fraction) : maximum (x,y)=x ∨ maximum (x,y)=y := by
  unfold maximum; split_ifs <;> simp
lemma minimum_eq (x y : Fraction) : minimum (x,y)=x ∨ minimum (x,y)=y := by
  unfold minimum; split_ifs <;> simp
lemma maximum_repr {x y : ℚ} (hx : 0≤x) (hy : 0≤y) :
    maximum (repr x,repr y)=repr (max x y) := by
  unfold maximum
  rw [less_val _ _ x.pos y.pos,val_repr hx,val_repr hy]
  simp only [decide_eq_true_eq]
  split_ifs with h
  · rw [max_eq_right (le_of_lt h)]
  · rw [max_eq_left (le_of_not_gt h)]
lemma minimum_repr {x y : ℚ} (hx : 0≤x) (hy : 0≤y) :
    minimum (repr x,repr y)=repr (min x y) := by
  unfold minimum
  rw [less_val _ _ x.pos y.pos,val_repr hx,val_repr hy]
  simp only [decide_eq_true_eq]
  split_ifs with h
  · rw [min_eq_left (le_of_lt h)]
  · rw [min_eq_right (le_of_not_gt h)]
lemma maximum_weight (x y : Fraction) : weight (maximum (x,y))≤ max (weight x) (weight y) := by
  rcases maximum_eq x y with h|h <;> rw [h]
  · exact le_max_left _ _
  · exact le_max_right _ _
lemma minimum_weight (x y : Fraction) : weight (minimum (x,y))≤ max (weight x) (weight y) := by
  rcases minimum_eq x y with h|h <;> rw [h]
  · exact le_max_left _ _
  · exact le_max_right _ _
lemma maximum_fold_weight (xs : List Fraction) (z : Fraction) (B : ℕ)
    (hz : weight z≤B) (hx : ∀ x∈xs,weight x≤B) :
    weight (xs.foldl (fun z x=>maximum (x,z)) z)≤B := by
  induction xs generalizing z with
  | nil => exact hz
  | cons x xs ih =>
    apply ih _ ((maximum_weight x z).trans (max_le (hx x (by simp)) hz))
    intro x hx'; exact hx x (by simp [hx'])
lemma polynomial_maximumFold : PolynomialTime (fold maximumRealizer) := by
  apply polynomial_fold polynomial_maximum Polynomial.X
  intro xs z pre post he
  simp only [Polynomial.eval_X]
  apply maximum_fold_weight pre z _ (weight_snd (xs,z))
  intro x hx
  exact (weight_mem hx).trans ((weight_prefix he).trans (weight_fst (xs,z)))
end MatchingFPRAS.TreeFraction

namespace MatchingFPRAS.ExecutableBottleneck
open TreeTyped TreeFraction Polynomial

abbrev Matrix := List (List Fraction)
def one : Fraction := (1,1)
def cell (x : Matrix×(ℕ×ℕ)) : Fraction := (x.1.getD x.2.1 []).getD x.2.2 one
def cellRealizer : Realizer cell := composition
  (pair (composition (pair first second.fst) (getDFast [])) second.snd) (getDFast one)
lemma polynomial_cell : PolynomialTime cellRealizer := by
  unfold cellRealizer
  have h₁:=polynomial_getDFast ([] : List Fraction)
  have h₂:=polynomial_getDFast one
  exact polynomial_composition (polynomial_pair (polynomial_composition
    (polynomial_pair polynomial_first (polynomial_fst polynomial_second)) h₁)
      (polynomial_snd polynomial_second)) h₂

def square {A B : Type} (n : ℕ) (a : A) (f : A×(ℕ×ℕ)→B) : List (List B) :=
  (List.range n).map fun i=>(List.range n).map fun j=>f (a,(i,j))
def squareRealizer {A B : Type} [Codec A] [Codec B] {n : A→ℕ} {f : A×(ℕ×ℕ)→B}
    (N : Realizer n) (F : Realizer f) : Realizer (fun a=>square (n a) a f) := by
  let rs:=composition N range
  let e:=composition (pair first.fst (pair first.snd second)) F
  let row:=composition (pair identity (composition first rs)) (mapWith e)
  exact composition (pair identity rs) (mapWith row)
lemma polynomial_square {A B : Type} [Codec A] [Codec B] {n : A→ℕ} {f : A×(ℕ×ℕ)→B}
    {N : Realizer n} {F : Realizer f} (hN : PolynomialTime N) (hF : PolynomialTime F)
    (p : Polynomial ℕ) (hn : ∀ a,n a≤p.eval (weight a)) : PolynomialTime (squareRealizer N F) := by
  have hR:=polynomial_boundedRange hN p hn
  unfold squareRealizer
  dsimp only
  exact polynomial_composition (polynomial_pair polynomial_identity hR)
    (polynomial_mapWith (polynomial_composition
      (polynomial_pair polynomial_identity (polynomial_composition polynomial_first hR))
      (polynomial_mapWith (polynomial_composition
        (polynomial_pair (polynomial_fst polynomial_first)
          (polynomial_pair (polynomial_snd polynomial_first) polynomial_second)) hF))))

lemma cell_weight {M : Matrix} {B : ℕ} (h₁ : weight one≤B)
    (hM : ∀ r∈M,∀ x∈r,weight x≤B) (i j : ℕ) : weight (cell (M,(i,j)))≤B := by
  unfold cell
  dsimp only
  by_cases hi : i<M.length
  · rw [List.getD_eq_getElem _ _ hi]
    by_cases hj : j<(M[i]).length
    · rw [List.getD_eq_getElem _ _ hj]
      exact hM _ (List.getElem_mem hi) _ (List.getElem_mem hj)
    · rw [List.getD_eq_default _ _ (by omega)]; exact h₁
  · rw [List.getD_eq_default M [] (by omega)]
    simpa using h₁

def via (x : (Matrix×(ℕ×ℕ))×ℕ) : Fraction :=
  minimum (cell (x.1.1,(x.1.2.1,x.2)),cell (x.1.1,(x.2,x.1.2.2)))
def viaRealizer : Realizer via := composition (pair
  (composition (pair first.fst (pair first.snd.fst second)) cellRealizer)
  (composition (pair first.fst (pair second first.snd.snd)) cellRealizer)) minimumRealizer
lemma polynomial_via : PolynomialTime viaRealizer := by
  unfold viaRealizer
  apply polynomial_composition _ TreeFraction.polynomial_minimum
  apply polynomial_pair
  · apply polynomial_composition _ polynomial_cell
    exact polynomial_pair (polynomial_fst polynomial_first)
      (polynomial_pair (polynomial_fst (polynomial_snd polynomial_first)) polynomial_second)
  · apply polynomial_composition _ polynomial_cell
    exact polynomial_pair (polynomial_fst polynomial_first)
      (polynomial_pair polynomial_second (polynomial_snd (polynomial_snd polynomial_first)))

def entry (x : Matrix×(ℕ×ℕ)) : Fraction :=
  if x.2.1=x.2.2 then one else
    ((List.range x.1.length).map fun c=>via (x,c)).foldl (fun z v=>maximum (v,z)) (cell x)
def entryRealizer : Realizer entry := by
  let vals:=composition (pair identity (composition (composition first listLength) range)) (mapWith viaRealizer)
  exact (choose (composition second natEqual) (constant one)
    (composition (pair vals cellRealizer) (fold maximumRealizer))).congr (by
      intro x; simp only [entry,Function.comp_apply,decide_eq_true_eq,id_eq])
lemma polynomial_entry : PolynomialTime entryRealizer := by
  have hR : PolynomialTime (composition (composition (first (A:=Matrix) (B:=ℕ×ℕ)) listLength) range) := by
    apply polynomial_boundedRange (by tree_poly) X
    intro x; simpa using (list_length_le_weight x.1).trans (weight_fst x)
  unfold entryRealizer
  dsimp only
  apply polynomial_congr
  apply polynomial_choose (polynomial_composition polynomial_second polynomial_natEqual) (polynomial_constant one)
  apply polynomial_composition _ polynomial_maximumFold
  apply polynomial_pair _ polynomial_cell
  exact polynomial_composition (polynomial_pair polynomial_identity hR) (polynomial_mapWith polynomial_via)

def advance (M : Matrix) : Matrix := square M.length M entry
def advanceRealizer : Realizer advance := squareRealizer listLength entryRealizer
lemma polynomial_advance : PolynomialTime advanceRealizer := by
  exact polynomial_square polynomial_listLength polynomial_entry X (fun a=>by simpa using list_length_le_weight a)
lemma advance_length (M : Matrix) : (advance M).length=M.length := by
  simp [advance,square]
lemma entry_weight {M : Matrix} {B : ℕ} (h₁ : weight one≤B)
    (hM : ∀ r∈M,∀ x∈r,weight x≤B) (i j : ℕ) : weight (entry (M,(i,j)))≤B := by
  unfold entry
  dsimp only
  split_ifs
  · exact h₁
  · apply maximum_fold_weight _ _ _ (cell_weight h₁ hM i j)
    intro x hx
    obtain ⟨c,hc,rfl⟩:=List.mem_map.mp hx
    exact (minimum_weight _ _).trans (max_le (cell_weight h₁ hM i c) (cell_weight h₁ hM c j))
lemma advance_entries {M : Matrix} {B : ℕ} (h₁ : weight one≤B)
    (hM : ∀ r∈M,∀ x∈r,weight x≤B) : ∀ r∈advance M,∀ x∈r,weight x≤B := by
  intro r hr x hx
  obtain ⟨i,hi,rfl⟩:=List.mem_map.mp hr
  obtain ⟨j,hj,rfl⟩:=List.mem_map.mp hx
  exact entry_weight h₁ hM i j
lemma advance_weight {M : Matrix} {B : ℕ} (h₁ : weight one≤B)
    (hM : ∀ r∈M,∀ x∈r,weight x≤B) : weight (advance M)≤1+M.length*(2+M.length*(B+1)) := by
  unfold advance square
  have h:=weight_map_bound (as:=List.range M.length)
    (N:=1+M.length*(B+1)) (f:=fun i=>(List.range M.length).map fun j=>entry (M,(i,j))) (by
      intro i _
      simpa [List.length_range,Nat.add_comm] using weight_map_bound (as:=List.range M.length)
        (f:=fun j=>entry (M,(i,j))) (fun j _=>entry_weight h₁ hM i j))
  simp only [List.length_range] at h
  exact h.trans_eq (by ring)

def seedEntry (x : Matrix×(ℕ×ℕ)) : Fraction := if x.2.1=x.2.2 then one
  else maximum (one,cell (x.1,(min x.2.1 x.2.2,max x.2.1 x.2.2)))
def seedEntryRealizer : Realizer seedEntry := by
  let inds : Realizer (fun x : Matrix×(ℕ×ℕ)=>if x.2.1<x.2.2 then x.2 else (x.2.2,x.2.1)) := (choose (composition second TreeTyped.less) second (pair second.snd second.fst)).congr (by intro x; simp only [Function.comp_apply,decide_eq_true_eq])
  exact (choose (composition second natEqual) (constant one)
    (composition (pair (constant one) (composition (pair first inds) cellRealizer)) maximumRealizer)).congr (by
      intro x
      simp only [seedEntry,Function.comp_apply,decide_eq_true_eq]
      split_ifs with h h'
      · rfl
      · rw [min_eq_left (le_of_lt h'),max_eq_right (le_of_lt h')]
      · rw [min_eq_right (le_of_not_gt h'),max_eq_left (le_of_not_gt h')])
lemma polynomial_seedEntry : PolynomialTime seedEntryRealizer := by
  unfold seedEntryRealizer
  dsimp only
  apply polynomial_congr
  apply polynomial_choose (polynomial_composition polynomial_second polynomial_natEqual)
    (polynomial_constant one)
  apply polynomial_composition _ TreeFraction.polynomial_maximum
  apply polynomial_pair (polynomial_constant one)
  apply polynomial_composition _ polynomial_cell
  apply polynomial_pair polynomial_first
  apply polynomial_congr
  exact polynomial_choose (polynomial_composition polynomial_second TreeTyped.polynomial_less)
    polynomial_second (polynomial_pair (polynomial_snd polynomial_second)
      (polynomial_fst polynomial_second))

def seed (M : Matrix) : Matrix := square M.length M seedEntry
def seedRealizer : Realizer seed := squareRealizer listLength seedEntryRealizer
lemma polynomial_seed : PolynomialTime seedRealizer :=
  polynomial_square polynomial_listLength polynomial_seedEntry X (fun a=>by simpa using list_length_le_weight a)

def close (M : Matrix) : Matrix := M.foldl (fun z _=>advance z) (seed M)
def closeRealizer : Realizer close := composition (pair identity seedRealizer)
  (fold (composition second advanceRealizer))
lemma fold_advance_invariant (ls : List (List Fraction)) (M : Matrix) (B : ℕ)
    (h₁ : weight one≤B) (hM : ∀ r∈M,∀ x∈r,weight x≤B) :
    let R:=ls.foldl (fun z _=>advance z) M
    R.length=M.length ∧ (∀ r∈R,∀ x∈r,weight x≤B) ∧
      weight R≤weight M+1+M.length*(2+M.length*(B+1)) := by
  have hInv : ∀ (ls : List (List Fraction)) (M : Matrix),
      (∀ r∈M,∀ x∈r,weight x≤B) →
      (ls.foldl (fun z _=>advance z) M).length=M.length ∧
        (∀ r∈ls.foldl (fun z _=>advance z) M,∀ x∈r,weight x≤B) := by
    intro ls
    induction ls with
    | nil => intro M hm; exact ⟨rfl,hm⟩
    | cons r ls ih =>
      intro M hm
      obtain ⟨hl,hR⟩:=ih (advance M) (advance_entries h₁ hm)
      exact ⟨hl.trans (advance_length M),hR⟩
  refine ⟨(hInv ls M hM).1,(hInv ls M hM).2,?_⟩
  cases ls using List.reverseRecOn with
  | nil => simpa only [List.foldl_nil,Nat.add_assoc] using (Nat.le_add_right (weight M) (1+M.length*(2+M.length*(B+1))))
  | append_singleton ls r ih =>
    rw [List.foldl_append]
    dsimp only [List.foldl]
    have hw:=advance_weight h₁ (hInv ls M hM).2
    rw [(hInv ls M hM).1] at hw
    omega

lemma polynomial_closeFold : PolynomialTime (fold (composition (second (A:=List Fraction)) advanceRealizer)) := by
  apply polynomial_fold (polynomial_composition polynomial_second polynomial_advance)
    (X+1+X*(2+X*(X+C (weight one)+1)))
  intro ls M pre _ _
  let S:=weight (ls,M)
  have hM : weight M≤S := weight_snd (ls,M)
  have hn : M.length≤S := (list_length_le_weight M).trans hM
  have hi:=fold_advance_invariant pre M (S+weight one) (by omega) (by
    intro r hr x hx
    exact ((weight_mem hx).trans ((weight_mem hr).trans hM)).trans (Nat.le_add_right _ _))
  have hb := hi.2.2
  simp only [Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_X,Polynomial.eval_one,
    Polynomial.eval_ofNat,Polynomial.eval_C]
  change weight (pre.foldl (fun z _=>advance z) M)≤S+1+S*(2+S*(S+weight one+1))
  have hp:=Nat.mul_le_mul hn (Nat.add_le_add_left (Nat.mul_le_mul_right (S+weight one+1) hn) 2)
  omega
lemma polynomial_close : PolynomialTime closeRealizer :=
  polynomial_composition (polynomial_pair polynomial_identity polynomial_seed) polynomial_closeFold

end MatchingFPRAS.ExecutableBottleneck

end OAI