import Mathlib
import OAI.Combinatorics.MatchingCount.Sampling.TreeUnitSampler
import OAI.Combinatorics.MatchingCount.Sampling.TreeFastUnit

namespace OAI

namespace MatchingFPRAS.ExecutableUnit
open TreeTyped ExecutableDP Polynomial

def fastSelected (x : Context×Bits) : ℕ×ℕ := fastDraw (x.1,x.2.getD (x.1.1.1.length-1) [])
def fastSelectedRealizer : Realizer fastSelected := by
  let n : Realizer (fun x : Context×Bits=>x.1.1.1.length-1) := composition (composition first.fst.fst listLength) predecessor
  exact (composition (pair first (composition (pair second n) (getDFast []))) fastDrawRealizer).congr (fun _=>rfl)
lemma polynomial_fastSelected : PolynomialTime fastSelectedRealizer := by
  unfold fastSelectedRealizer
  dsimp only
  apply polynomial_congr
  apply polynomial_composition _ polynomial_fastDraw
  have := polynomial_getDFast ([] : List Bool)
  have := polynomial_predecessor
  dsimp only [Realizer.fst,Realizer.snd]
  tree_poly

def nextContextFast : Realizer nextContext :=
  (pair (pair (composition (pair first.fst.fst second.fst) residualFast) first.fst.snd) first.snd).congr (fun _=>rfl)
lemma polynomial_nextContextFast : PolynomialTime nextContextFast := by
  unfold nextContextFast
  apply polynomial_congr
  have := polynomial_residualFast
  dsimp only [Realizer.fst,Realizer.snd]
  tree_poly

def fastStep (x : State) : State :=
  if 2≤x.1.1.1.length then
    let c:=fastSelected (x.1,x.2.1)
    (nextContext (x.1,c),(x.2.1,(x.1.1.1.length-2,c)::x.2.2))
  else x
def fastStepRealizer : Realizer fastStep := by
  let n : Realizer (fun x : State=>x.1.1.1.length) := composition first.fst.fst listLength
  let c : Realizer (fun x : State=>fastSelected (x.1,x.2.1)) := (composition (f:=fun x : State=>(x.1,x.2.1)) (pair first second.fst) fastSelectedRealizer).congr (fun _=>rfl)
  let ctx := composition (pair first c) nextContextFast
  let k := composition (pair n (constant 2)) subtract
  let fs := composition (pair (pair k c) second.snd) listCons
  let r := pair ctx (pair second.fst fs)
  exact (choose (composition (composition (pair n (constant 2)) less) boolNot) r identity).congr (by
    intro x; simp [fastStep,Nat.succ_le_iff])
lemma polynomial_fastStep : PolynomialTime fastStepRealizer := by
  unfold fastStepRealizer
  dsimp only
  apply polynomial_congr
  have := polynomial_fastSelected
  have := polynomial_nextContextFast
  dsimp only [Realizer.fst,Realizer.snd]
  tree_poly

lemma chooseBits_le_length (x : List TreeFraction.Fraction×List Bool) : ExecutableChoice.chooseBits x≤x.1.length := by
  exact TreeTyped.listMin_le_default _ _
lemma fastDraw_bounds (x : Context×List Bool) :
    (fastDraw x).1≤x.1.1.1.length*x.1.1.2.length ∧ (fastDraw x).2≤x.1.1.1.length*x.1.1.2.length := by
  have h:=chooseBits_le_length (fastProbabilities x.1,x.2)
  simp only [fastProbabilities,List.length_map,List.length_range] at h
  exact ⟨(Nat.div_le_self _ _).trans h,(Nat.mod_le _ _).trans h⟩
lemma fastSelected_bounds (x : Context×Bits) :
    (fastSelected x).1≤x.1.1.1.length*x.1.1.2.length ∧ (fastSelected x).2≤x.1.1.1.length*x.1.1.2.length :=
  fastDraw_bounds _
lemma residual_length (bs : Bags) (b : ℕ) : (residual (bs,b)).length=bs.length-2 := by
  simp [residual]
lemma residual_mem {bs : Bags} {b : ℕ} {a : Bag} (ha : a∈residual (bs,b)) : a∈bs := by
  simp only [residual,List.mem_map,List.mem_range] at ha
  obtain ⟨i,hi,rfl⟩:=ha
  have hj : skip (i,b)<bs.length := by simp only [skip]; split_ifs <;> omega
  rw [List.getD_eq_getElem _ _ hj]
  exact List.getElem_mem _

def DescentInvariant (a : Context×Bits) (k : ℕ) (z : State) : Prop :=
  z.1.1.1.length≤a.1.1.1.length ∧
  (∀ b∈z.1.1.1,b∈a.1.1.1) ∧ z.1.1.2=a.1.1.2 ∧ z.1.2=a.1.2 ∧ z.2.1=a.2 ∧
  z.2.2.length+k≤a.1.1.1.length ∧
  ∀ f∈z.2.2,f.1≤a.1.1.1.length ∧ f.2.1≤a.1.1.1.length*a.1.1.2.length ∧ f.2.2≤a.1.1.1.length*a.1.1.2.length
lemma descent_init (a : Context×Bits) : DescentInvariant a a.1.1.1.length (a.1,(a.2,[])) := by
  simp only [DescentInvariant,List.length_nil,Nat.zero_add,List.not_mem_nil,IsEmpty.forall_iff,le_refl,implies_true,true_and,and_true]
  exact fun b h=>h
lemma descent_step (a : Context×Bits) (k : ℕ) (z : State) (hz : DescentInvariant a (k+1) z) :
    DescentInvariant a k (fastStep z) := by
  obtain ⟨hl,hb,hp,ho,ht,hf,hm⟩:=hz
  by_cases hn : 2≤z.1.1.1.length
  · rw [fastStep,ite_eq_left hn]
    have hc:=fastSelected_bounds (z.1,z.2.1)
    rw [hp] at hc
    have hmul:=Nat.mul_le_mul_right a.1.1.2.length hl
    refine ⟨?_,?_,hp,ho,ht,?_,?_⟩
    · change (residual (z.1.1.1,(fastSelected (z.1,z.2.1)).1)).length≤_
      rw [residual_length]; omega
    · intro b hb'
      exact hb b (residual_mem hb')
    · change ( _ :: z.2.2).length+k≤_
      simp only [List.length_cons]; omega
    · intro f hh
      rcases List.mem_cons.mp hh with rfl | hh
      · exact ⟨(Nat.sub_le _ _).trans hl,hc.1.trans hmul,hc.2.trans hmul⟩
      · exact hm f hh
  · rw [fastStep,ite_eq_right hn]
    exact ⟨hl,hb,hp,ho,ht,by omega,hm⟩

lemma descent_weight (a : Context×Bits) (k : ℕ) (z : State) (hz : DescentInvariant a k z) :
    weight z≤ 20*(weight a+1)^3 := by
  obtain ⟨hl,hb,hp,ho,ht,hf,hm⟩:=hz
  let S:=weight a
  have hn : a.1.1.1.length≤S := (list_length_le_weight _).trans ((weight_fst a.1.1).trans ((weight_fst a.1).trans (weight_fst a)))
  have hn' : a.1.1.2.length≤S := (list_length_le_weight _).trans ((weight_snd a.1.1).trans ((weight_fst a.1).trans (weight_fst a)))
  have hbn:weight z.1.1.1≤S*(S+1)+1 := by
    have hh:=weight_map_bound (as:=z.1.1.1) (f:=id) (N:=S) (fun b hh=>(weight_mem (hb b hh)).trans ((weight_fst a.1.1).trans ((weight_fst a.1).trans (weight_fst a))))
    simpa only [List.map_id] using hh.trans (Nat.add_le_add_right (Nat.mul_le_mul_right (S+1) (hl.trans hn)) 1)
  have hmfn:weight z.2.2≤S*(8*S*S+4*S+6)+1 := by
    have hh:=weight_map_bound (as:=z.2.2) (f:=id) (N:=8*S*S+4*S+5) (by
      intro f hh
      obtain ⟨h1,h2,h3⟩:=hm f hh
      have hm:=Nat.mul_le_mul hn hn'
      have hf1:=weight_nat_numeric f.1
      have hf2:=weight_nat_numeric f.2.1
      have hf3:=weight_nat_numeric f.2.2
      change weight f≤_
      rw [←Prod.eta f,weight_prod,←Prod.eta f.2,weight_prod]
      nlinarith)
    simp only [List.map_id] at hh
    have hlen :z.2.2.length≤S:=by omega
    have he : 8*S*S+4*S+5+1=8*S*S+4*S+6 := by omega
    rw [he] at hh
    exact hh.trans (Nat.add_le_add_right (Nat.mul_le_mul_right _ hlen) 1)
  have hpar :weight a.1.1.2≤S := (weight_snd a.1.1).trans ((weight_fst a.1).trans (weight_fst a))
  have hplan :weight a.1.2≤S := (weight_snd a.1).trans (weight_fst a)
  have hbits :weight a.2≤S := weight_snd a
  rw [←Prod.eta z,weight_prod,←Prod.eta z.1,weight_prod,←Prod.eta z.1.1,weight_prod,←Prod.eta z.2,weight_prod,hp,ho,ht]
  change _≤20*(S+1)^3
  nlinarith

def fastDescend (a : Context×Bits) : State :=
  countDown (fun y : ℕ×State=>fastStep y.2) a.1.1.1.length (a.1,(a.2,[]))
def fastDescendRealizer : Realizer fastDescend :=
  (composition (pair (composition first.fst.fst listLength) (pair first (pair second (constant ([] : List Frame)))))
    (iterateDown (composition second fastStepRealizer))).congr (fun _=>rfl)
lemma polynomial_fastDescend : PolynomialTime fastDescendRealizer := by
  unfold fastDescendRealizer
  apply polynomial_congr
  apply polynomial_boundedRepeat (by dsimp only [Realizer.fst,Realizer.snd]; tree_poly)
    (polynomial_composition polynomial_second polynomial_fastStep)
    X (20*(X+1)^3) DescentInvariant
  · intro a
    simpa only [Function.comp_apply,Polynomial.eval_X] using (list_length_le_weight a.1.1.1).trans ((weight_fst a.1.1).trans ((weight_fst a.1).trans (weight_fst a)))
  · exact descent_init
  · intro a k _hk z hz
    exact descent_step a k z hz
  · intro a k z hz
    simpa only [Polynomial.eval_mul,Polynomial.eval_ofNat,Polynomial.eval_pow,Polynomial.eval_add,Polynomial.eval_X,Polynomial.eval_one] using descent_weight a k z hz
end MatchingFPRAS.ExecutableUnit

end OAI