import Mathlib
import OAI.Combinatorics.MatchingCount.Complexity.TreeNumericCosts

namespace OAI

namespace MatchingFPRAS.TreeTyped
open Polynomial

lemma nat_fold_size_bound (f : ℕ×ℕ → ℕ) (K M : ℕ)
    (hf : ∀ a b,(f (a,b)).size≤a.size+b.size+K) (as : List ℕ) (z : ℕ)
    (ha : ∀ a∈as,a.size≤M) :
    (as.foldl (fun z a=>f (a,z)) z).size≤z.size+as.length*(M+K) := by
  induction as generalizing z with
  | nil => simp
  | cons a as ih =>
    have hh:=hf a z
    have ha':=ha a (by simp)
    have ht:=ih (f (a,z)) (fun a h=>ha a (by simp [h]))
    simp only [List.foldl_cons,List.length_cons]
    nlinarith
lemma polynomial_nat_fold {f : ℕ×ℕ → ℕ} {F : Realizer f} (hF : PolynomialTime F)
    (K : ℕ) (hf : ∀ a b,(f (a,b)).size≤a.size+b.size+K) : PolynomialTime (fold F) := by
  apply polynomial_fold hF (4*X+4*X*(X+Polynomial.C K)+1)
  intro as z pre post he
  let S:=weight (as,z)
  have hp : pre.length≤S := (list_length_le_weight pre).trans ((weight_prefix he).trans (by dsimp [S]; rw [weight_prod]; omega))
  have ha : ∀ a∈pre,a.size≤S := by
    intro a ha
    exact (size_le_weight a).trans ((weight_mem (as := as) (by simp [he,ha])).trans (by dsimp [S]; rw [weight_prod]; omega))
  have hz : z.size≤S := (size_le_weight z).trans (by dsimp [S]; rw [weight_prod]; omega)
  have hb:=nat_fold_size_bound f K S hf pre z ha
  have hw:=weight_nat_le (pre.foldl (fun z a=>f (a,z)) z)
  have hm:=Nat.mul_le_mul_right (S+K) hp
  simp only [Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_ofNat,Polynomial.eval_X,Polynomial.eval_C,Polynomial.eval_one]
  change _≤4*S+4*S*(S+K)+1
  nlinarith
lemma polynomial_listSum : PolynomialTime listSum := by
  unfold listSum
  apply polynomial_congr
  exact polynomial_composition (polynomial_pair polynomial_identity (polynomial_constant 0))
    (polynomial_nat_fold polynomial_add 1 (fun a b=>(nat_size_add a b).trans (by omega)))
lemma polynomial_listProd : PolynomialTime listProd := by
  unfold listProd
  apply polynomial_congr
  exact polynomial_composition (polynomial_pair polynomial_identity (polynomial_constant 1))
    (polynomial_nat_fold polynomial_multiply 0 (fun a b=>by simpa using nat_size_mul a b))

lemma pairingStep_fold_size (as : List ℕ) (a b M : ℕ) (ha : ∀ i∈as,i.size≤M) :
    max (as.foldl (fun z i=>pairingStep (i,z)) (a,b)).1.size
      (as.foldl (fun z i=>pairingStep (i,z)) (a,b)).2.size ≤
      max a.size b.size+as.length*(M+2) := by
  induction as generalizing a b with
  | nil => simp
  | cons i as ih =>
    have hi:=ha i (by simp)
    have hsmall:=nat_size_add i 1
    have he : Nat.size 1=1:=by decide
    have hm:=nat_size_mul (i+1) a
    have hmax : max i.size 1≤M+1:=max_le (by omega) (by omega)
    have hstep : max b.size ((i+1)*a).size ≤ max a.size b.size+(M+2) := by
      rw [he] at hsmall
      have h1:=le_max_left a.size b.size
      have h2:=le_max_right a.size b.size
      exact max_le (by omega) (by omega)
    have ht:=ih b ((i+1)*a) (fun j h=>ha j (by simp [h]))
    simp only [pairingStep] at ht
    simp only [List.foldl_cons,List.length_cons,pairingStep]
    nlinarith
lemma polynomial_pairingFold : PolynomialTime (fold
    (pair (composition (second (A:=ℕ) (B:=ℕ×ℕ)) second)
      (composition (pair (composition first successor) (composition second first)) multiply))) := by
  apply polynomial_fold (polynomial_pair (polynomial_composition polynomial_second polynomial_second)
    (polynomial_composition (polynomial_pair (polynomial_composition polynomial_first polynomial_successor)
      (polynomial_composition polynomial_second polynomial_first)) polynomial_multiply)) (8*X+8*X*(X+2)+3)
  rintro as ⟨a,b⟩ pre post he
  let S:=weight (as,(a,b))
  have hp : pre.length≤S := (list_length_le_weight pre).trans ((weight_prefix he).trans (by dsimp [S]; simp only [weight_prod]; omega))
  have ha : ∀ i∈pre,i.size≤S := by
    intro i hi
    exact (size_le_weight i).trans ((weight_mem (as := as) (by simp [he,hi])).trans (by dsimp [S]; simp only [weight_prod]; omega))
  have hab : max a.size b.size≤S := by
    have hh:=size_le_weight a
    have hh':=size_le_weight b
    apply max_le <;> dsimp [S] <;> simp only [weight_prod] <;> omega
  let z:=pre.foldl (fun z i=>pairingStep (i,z)) (a,b)
  have hm:=pairingStep_fold_size pre a b S ha
  have h1:=weight_nat_le z.1
  have h2:=weight_nat_le z.2
  have h3:=le_max_left z.1.size z.2.size
  have h4:=le_max_right z.1.size z.2.size
  change max z.1.size z.2.size≤_ at hm
  have hmul:=Nat.mul_le_mul_right (S+2) hp
  change weight z≤_
  rw [←Prod.eta z,weight_prod]
  simp only [Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_ofNat,Polynomial.eval_X]
  change _≤8*S+8*S*(S+2)+3
  nlinarith
lemma pairingNumber_numeric_work : WorkBound pairingNumber id := by
  unfold pairingNumber
  apply work_congr
  apply work_then_polynomial _ polynomial_first
  apply work_then_polynomial _ polynomial_pairingFold
  exact work_pair range_numeric_work
    (work_of_polynomial (polynomial_constant (1,0)) (4*X+1) (fun n=>by simpa using weight_nat_numeric n))
    (4*X+1) (fun n=>by simpa using weight_nat_numeric n)
lemma polynomial_boundedPairingNumber {A : Type} [Codec A] {f : A → ℕ} {F : Realizer f} (hF : PolynomialTime F)
    (p : Polynomial ℕ) (hn : ∀ a,f a≤p.eval (weight a)) : PolynomialTime (composition F pairingNumber) :=
  work_composition hF pairingNumber_numeric_work p hn
end MatchingFPRAS.TreeTyped

end OAI