import Mathlib
import OAI.Combinatorics.MatchingCount.Sampling.TreeDPCount
import OAI.Combinatorics.MatchingCount.Sampling.TreeFastDPEntry
import OAI.Combinatorics.MatchingCount.Complexity.TreePolynomialGrid

namespace OAI

namespace MatchingFPRAS.ExecutableDP
open TreeTyped Polynomial

def nVertices (o : CountInput) : ℕ := o.1.1.length
def nLabels (o : CountInput) : ℕ := o.1.2.length
def nPlan (o : CountInput) : ℕ := o.2.length
def BInitial (o : CountInput) : ℕ := nVertices o*nLabels o
def capBits (o : CountInput) : ℕ := nVertices o*nPlan o+(BInitial o)^2*nLabels o+1

def nVerticesRealizer : Realizer nVertices := composition first.fst listLength
def nLabelsRealizer : Realizer nLabels := composition first.snd listLength
def nPlanRealizer : Realizer nPlan := composition second listLength
def BInitialRealizer : Realizer BInitial := composition (pair nVerticesRealizer nLabelsRealizer) multiply
def capBitsRealizer : Realizer capBits := by
  let b:= BInitialRealizer
  let q:= composition (pair b b) multiply
  let v:= composition (pair q nLabelsRealizer) multiply
  let w:= composition (pair nVerticesRealizer nPlanRealizer) multiply
  exact (composition (composition (pair w v) add) successor).congr (by intro o; simp only [capBits,pow_two]; rfl)
lemma polynomial_nVertices : PolynomialTime nVerticesRealizer := by unfold nVerticesRealizer; exact polynomial_composition (polynomial_fst polynomial_first) polynomial_listLength
lemma polynomial_nLabels : PolynomialTime nLabelsRealizer := by unfold nLabelsRealizer; exact polynomial_composition (polynomial_snd polynomial_first) polynomial_listLength
lemma polynomial_nPlan : PolynomialTime nPlanRealizer := by unfold nPlanRealizer; exact polynomial_composition polynomial_second polynomial_listLength
lemma polynomial_BInitial : PolynomialTime BInitialRealizer :=
  polynomial_composition (polynomial_pair polynomial_nVertices polynomial_nLabels) polynomial_multiply
lemma polynomial_capBits : PolynomialTime capBitsRealizer := by
  unfold capBitsRealizer
  dsimp only
  apply polynomial_congr
  apply polynomial_composition _ polynomial_successor
  apply polynomial_composition _ polynomial_add
  have := polynomial_BInitial
  have := polynomial_nVertices
  have := polynomial_nLabels
  have := polynomial_nPlan
  tree_poly
lemma input_lengths (o : CountInput) : nVertices o≤weight o ∧ nLabels o≤weight o ∧ nPlan o≤weight o := by
  refine ⟨(list_length_le_weight _).trans ((weight_fst o.1).trans (weight_fst o)),
    (list_length_le_weight _).trans ((weight_snd o.1).trans (weight_fst o)),
    (list_length_le_weight _).trans (weight_snd o)⟩
lemma BInitial_bound (o : CountInput) : BInitial o≤(weight o)^2 := by
  obtain ⟨hn,hm,_⟩:=input_lengths o
  exact (Nat.mul_le_mul hn hm).trans_eq (pow_two _).symm
lemma capBits_bound (o : CountInput) : capBits o≤(weight o)^2+(weight o)^5+1 := by
  obtain ⟨hn,hm,hL⟩:=input_lengths o
  have hB:=BInitial_bound o
  have h1:=Nat.mul_le_mul hn hL
  have h2:=Nat.mul_le_mul (Nat.pow_le_pow_left hB 2) hm
  calc
    _ ≤ weight o*weight o+((weight o)^2)^2*weight o+1 := by unfold capBits; omega
    _ = _ := by ring

def initialEntry (x : CountInput×(ℕ×ℕ)) : ℕ := UnitRefresh.pairingCount (min x.2.2 (BInitial x.1))
def initialEntryRealizer : Realizer initialEntry :=
  composition (composition (pair second.snd (composition first BInitialRealizer)) minNat) pairingNumber
lemma polynomial_initialEntry : PolynomialTime initialEntryRealizer := by
  unfold initialEntryRealizer
  refine polynomial_boundedPairingNumber ?_ (X^2) ?_
  · apply polynomial_composition _ polynomial_minNat
    apply polynomial_pair (polynomial_snd polynomial_second) (polynomial_composition polynomial_first polynomial_BInitial)
  · intro x
    simp only [Polynomial.eval_pow,Polynomial.eval_X]
    exact (min_le_right _ _).trans ((BInitial_bound x.1).trans (Nat.pow_le_pow_left (weight_fst x) 2))
def initialFast : Realizer (fun o : CountInput=>initial (nLabels o,BInitial o)) :=
  (grid nLabelsRealizer BInitialRealizer initialEntryRealizer).congr (by
    intro o
    unfold tabulate initial initialEntry
    apply List.map_congr_left
    intro a _row_mem
    apply List.map_congr_left
    intro r hr
    have hh : r≤BInitial o := by have :=List.mem_range.mp hr; dsimp only at this; omega
    simp only [Nat.min_eq_left hh])
lemma polynomial_initialFast : PolynomialTime initialFast := by
  unfold initialFast
  apply polynomial_congr
  exact polynomial_grid polynomial_nLabels polynomial_BInitial polynomial_initialEntry X (X^2)
    (fun o=>by simpa using (input_lengths o).2.1) (fun o=>by simpa using BInitial_bound o)

abbrev UpdateInput := (CountInput×RawCtx)×ℕ
def updateRows (x : UpdateInput) := nLabels x.1.1
def updateColumns (x : UpdateInput) := nVertices x.1.1*min x.2 (nPlan x.1.1)
def updateRowsRealizer : Realizer updateRows := composition first.fst nLabelsRealizer
def updateColumnsRealizer : Realizer updateColumns :=
  composition (pair (composition first.fst nVerticesRealizer)
    (composition (pair second (composition first.fst nPlanRealizer)) minNat)) multiply
lemma polynomial_updateRows : PolynomialTime updateRowsRealizer :=
  polynomial_composition (polynomial_fst polynomial_first) polynomial_nLabels
lemma polynomial_updateColumns : PolynomialTime updateColumnsRealizer := by
  unfold updateColumnsRealizer
  exact polynomial_composition (polynomial_pair
    (polynomial_composition (polynomial_fst polynomial_first) polynomial_nVertices)
    (polynomial_composition (polynomial_pair polynomial_second
      (polynomial_composition (polynomial_fst polynomial_first) polynomial_nPlan)) polynomial_minNat)) polynomial_multiply
lemma update_dimensions (x : UpdateInput) : updateRows x≤weight x ∧ updateColumns x≤(weight x)^2 := by
  have hwo:weight x.1.1≤weight x := (weight_fst x.1).trans (weight_fst x)
  obtain ⟨hn,hm,hL⟩:=input_lengths x.1.1
  refine ⟨hm.trans hwo,?_⟩
  exact (Nat.mul_le_mul (hn.trans hwo) ((min_le_right _ _).trans (hL.trans hwo))).trans_eq (pow_two _).symm

def cappedEntry (x : UpdateInput×(ℕ×ℕ)) : ℕ := clip (capBits x.1.1.1,rawEntry (x.1.1.2,x.2))
def cappedEntryRealizer : Realizer cappedEntry :=
  (composition (pair (composition first.fst.fst capBitsRealizer)
    (composition (pair first.fst.snd second) rawEntryRealizer)) clipRealizer).congr (fun _=>rfl)
lemma polynomial_cappedEntry : PolynomialTime cappedEntryRealizer := by
  unfold cappedEntryRealizer Realizer.fst Realizer.snd
  apply polynomial_congr
  apply polynomial_composition _ polynomial_clip
  apply polynomial_pair
  · apply polynomial_composition _ polynomial_capBits
    tree_poly
  · apply polynomial_composition _ polynomial_rawEntry
    tree_poly

def cappedUpdate (x : UpdateInput) : Table := tabulate cappedEntry (x,(updateRows x,updateColumns x))
def cappedUpdateRealizer : Realizer cappedUpdate := grid updateRowsRealizer updateColumnsRealizer cappedEntryRealizer
lemma polynomial_cappedUpdate : PolynomialTime cappedUpdateRealizer :=
  polynomial_grid polynomial_updateRows polynomial_updateColumns polynomial_cappedEntry X (X^2)
    (fun x=>by simpa using (update_dimensions x).1) (fun x=>by simpa using (update_dimensions x).2)

end MatchingFPRAS.ExecutableDP

end OAI