import OAI.Combinatorics.ContingencyTables.Rooted.ForestJoinProgram
import OAI.Combinatorics.ContingencyTables.Rooted.LargeEdgeCatalogProgram

namespace OAI

/-! # Polynomial execution of the component-greedy forest loop

The immutable weighted edge catalog is scanned after every insertion.
There are at most the square of the stored vertex count many iterations;
all adjacency rows stay inside that fixed vertex range.
-/

namespace ContingencyTables.ForestGreedyProgram

open MatchingFPRAS.TreeTyped Polynomial FiniteGraphRootProgram WeightedArgmaxProgram

abbrev State := ForestEdgeChoiceProgram.Input

private def insert (z : State×Edge) : GraphCode := ForestJoinProgram.join (z.1.1,z.2.1)
private def insertRealizer : Realizer insert :=
  composition (f := fun z : State×Edge=>(z.1.1,z.2.1)) (g := ForestJoinProgram.join)
    (pair (composition first first) (composition second first)) ForestJoinProgram.joinRealizer
private lemma polynomial_insert : PolynomialTime insertRealizer :=
  polynomial_composition (polynomial_pair
    (polynomial_composition polynomial_first polynomial_first)
    (polynomial_composition polynomial_second polynomial_first)) ForestJoinProgram.polynomial_join

def update (s : State) : GraphCode :=
  (ForestEdgeChoiceProgram.choice s).elim s.1 (fun e=>insert (s,e))
def updateRealizer : Realizer update :=
  composition (f := fun s : State=>(s,ForestEdgeChoiceProgram.choice s))
    (g := fun z : State×Option Edge=>z.2.elim z.1.1 (fun e=>insert (z.1,e)))
    (pair identity ForestEdgeChoiceProgram.choiceRealizer) (optionCases first insertRealizer)
lemma polynomial_update : PolynomialTime updateRealizer :=
  polynomial_composition (polynomial_pair polynomial_identity ForestEdgeChoiceProgram.polynomial_choice)
    (polynomial_optionCases polynomial_first polynomial_insert)

def advance (z : ℕ×State) : State := (update z.2,z.2.2)
def advanceRealizer : Realizer advance :=
  pair (composition (f := fun z : ℕ×State=>z.2) (g := update) second updateRealizer)
    (composition second second)
lemma polynomial_advance : PolynomialTime advanceRealizer :=
  polynomial_pair (polynomial_composition polynomial_second polynomial_update)
    (polynomial_composition polynomial_second polynomial_second)

lemma update_length (s : State) : (update s).length=s.1.length := by
  unfold update
  cases h : ForestEdgeChoiceProgram.choice s with
  | none=>rfl
  | some e=>exact ForestJoinProgram.join_length _

lemma update_weight (s : State) :
    weight (update s)≤ max (weight s.1)
      (s.1.length*(4*s.1.length^2+2*s.1.length+2)+1) := by
  unfold update
  cases h : ForestEdgeChoiceProgram.choice s with
  | none=>exact le_max_left _ _
  | some e=>exact (ForestJoinProgram.join_weight _).trans (le_max_right _ _)

lemma fold_edges (xs : List ℕ) (s : State) :
    (xs.foldl (fun s a=>advance (a,s)) s).2=s.2 := by
  induction xs generalizing s with
  | nil=>rfl
  | cons a xs ih=>exact ih (advance (a,s))

lemma fold_length (xs : List ℕ) (s : State) :
    (xs.foldl (fun s a=>advance (a,s)) s).1.length=s.1.length := by
  induction xs generalizing s with
  | nil=>rfl
  | cons a xs ih=>
    exact (ih (advance (a,s))).trans (update_length s)

lemma fold_weight (xs : List ℕ) (s : State) :
    weight (xs.foldl (fun s a=>advance (a,s)) s).1≤ max (weight s.1)
      (s.1.length*(4*s.1.length^2+2*s.1.length+2)+1) := by
  induction xs generalizing s with
  | nil=>exact le_max_left _ _
  | cons a xs ih=>
    have h := ih (advance (a,s))
    simp only [advance,update_length] at h
    exact h.trans (max_le (update_weight s) (le_max_right _ _))

lemma polynomial_loop : PolynomialTime (fold advanceRealizer) := by
  apply polynomial_fold polynomial_advance (30*(X+1)^3)
  intro xs s pre post he
  let S := weight (xs,s)
  let out := pre.foldl (fun s a=>advance (a,s)) s
  have hs : weight s≤S := weight_snd (xs,s)
  have hg : weight s.1≤S := (weight_fst s).trans hs
  have hec : weight s.2≤S := (weight_snd s).trans hs
  have hn : s.1.length≤S := (list_length_le_weight s.1).trans hg
  have hb : s.1.length*(4*s.1.length^2+2*s.1.length+2)+1≤4*S^3+2*S^2+2*S+1 := by
    have hpow := Nat.pow_le_pow_left hn 2
    have hmul := Nat.mul_le_mul hn (show 4*s.1.length^2+2*s.1.length+2≤4*S^2+2*S+2 by omega)
    nlinarith
  have ho : weight out.1≤4*S^3+2*S^2+3*S+1 :=
    (fold_weight pre s).trans (max_le (by omega) (by omega))
  have heq : out.2=s.2 := fold_edges pre s
  have hw : weight out=1+weight out.1+weight out.2 := by
    change weight (out.1,out.2)=_
    exact weight_prod _ _
  simp only [eval_mul,eval_ofNat,eval_add,eval_pow,eval_X,eval_one]
  change weight out≤30*(S+1)^3
  rw [hw,heq]
  nlinarith

def slots (s : State) : List ℕ := List.range (s.1.length*s.1.length)
def slotsRealizer : Realizer slots :=
  composition (f := fun s : State=>s.1.length*s.1.length) (g := List.range)
    (composition (f := fun s : State=>(s.1.length,s.1.length))
      (g := fun z : ℕ×ℕ=>z.1*z.2)
      (pair (composition first listLength) (composition first listLength)) multiply) range
lemma polynomial_slots : PolynomialTime slotsRealizer := by
  apply polynomial_boundedRange
    (polynomial_composition (polynomial_pair
      (polynomial_composition polynomial_first polynomial_listLength)
      (polynomial_composition polynomial_first polynomial_listLength)) polynomial_multiply) (X^2)
  intro s
  have h : s.1.length≤weight s := (list_length_le_weight s.1).trans (weight_fst s)
  simpa only [Function.comp_apply,eval_pow,eval_mul,eval_X,pow_two] using Nat.mul_self_le_mul_self h

def execute (s : State) : State := (slots s).foldl (fun s a=>advance (a,s)) s
def executeRealizer : Realizer execute :=
  composition (f := fun s : State=>(slots s,s))
    (g := fun z : List ℕ×State=>z.1.foldl (fun s a=>advance (a,s)) z.2)
    (pair slotsRealizer identity) (fold advanceRealizer)
lemma polynomial_execute : PolynomialTime executeRealizer :=
  polynomial_composition (polynomial_pair polynomial_slots polynomial_identity) polynomial_loop

def emptyGraph (z : LargeEdgeCatalogProgram.Input) : GraphCode :=
  (List.range (LargeEdgeCatalogProgram.vertexCount z)).map (fun _=>[])
def emptyGraphRealizer : Realizer emptyGraph :=
  composition (composition LargeEdgeCatalogProgram.vertexCountRealizer range) (map (constant []))
lemma polynomial_emptyGraph : PolynomialTime emptyGraphRealizer := by
  apply polynomial_composition
  · apply polynomial_boundedRange LargeEdgeCatalogProgram.polynomial_vertexCount (2*X)
    intro z
    have hr : z.1.1.1.length≤weight z := (list_length_le_weight z.1.1.1).trans
      ((weight_fst z.1.1).trans ((weight_fst z.1).trans (weight_fst z)))
    have hc : z.1.1.2.length≤weight z := (list_length_le_weight z.1.1.2).trans
      ((weight_snd z.1.1).trans ((weight_fst z.1).trans (weight_fst z)))
    simp only [LargeEdgeCatalogProgram.vertexCount,eval_mul,eval_ofNat,eval_X]
    omega
  · exact polynomial_map (polynomial_constant [])

def prepare (z : LargeEdgeCatalogProgram.Input) : State :=
  (emptyGraph z,LargeEdgeCatalogProgram.catalog z)
def prepareRealizer : Realizer prepare :=
  pair emptyGraphRealizer LargeEdgeCatalogProgram.catalogRealizer
lemma polynomial_prepare : PolynomialTime prepareRealizer :=
  polynomial_pair polynomial_emptyGraph LargeEdgeCatalogProgram.polynomial_catalog

def forest (z : LargeEdgeCatalogProgram.Input) : GraphCode := (execute (prepare z)).1
def forestRealizer : Realizer forest :=
  composition (composition (f:=prepare) (g:=execute) prepareRealizer executeRealizer) first
lemma polynomial_forest : PolynomialTime forestRealizer :=
  polynomial_composition (polynomial_composition polynomial_prepare polynomial_execute) polynomial_first

end ContingencyTables.ForestGreedyProgram

end OAI