import Mathlib
import OAI.Combinatorics.MatchingCount.Machines.TreeClippedRun
import OAI.Combinatorics.MatchingCount.Complexity.TreeChoiceCosts
import OAI.Combinatorics.MatchingCount.Sampling.TreeUnitDraw

namespace OAI

namespace MatchingFPRAS.ExecutableUnit
open TreeTyped ExecutableDP Polynomial

def skipFast : Realizer skip := skipRealizer
lemma polynomial_skipFast : PolynomialTime skipFast := by
  unfold skipFast skipRealizer
  apply polynomial_congr
  exact polynomial_choose polynomial_less polynomial_first
    (polynomial_composition polynomial_first polynomial_successor)

def residualFast : Realizer residual := by
  let p : Realizer (fun x : (Bags×ℕ)×ℕ=>(x.1.1,skip (x.2,x.1.2))) :=
    pair first.fst (composition (pair second first.snd) skipFast)
  let n : Realizer (fun x : Bags×ℕ=>x.1.length-2) := composition (pair (composition first listLength) (constant 2)) subtract
  exact (composition (pair identity (composition n range))
    (mapWith (composition p (getDFast ([] : Bag))))).congr (fun _=>rfl)
lemma polynomial_residualFast : PolynomialTime residualFast := by
  unfold residualFast Realizer.fst Realizer.snd
  dsimp only
  apply polynomial_congr
  apply polynomial_composition
  · apply polynomial_pair polynomial_identity
    apply polynomial_boundedRange (by tree_poly) X
    intro x
    simpa only [Polynomial.eval_X] using (Nat.sub_le x.1.length 2).trans ((list_length_le_weight x.1).trans (weight_fst x))
  · apply polynomial_mapWith
    apply polynomial_composition _ (polynomial_getDFast [])
    have := polynomial_skipFast
    tree_poly

def validFast : Realizer valid := by
  let bs : Realizer (fun x : Context×(ℕ×ℕ)=>x.1.1.1) := first.fst.fst
  let b : Realizer (fun x : Context×(ℕ×ℕ)=>x.2.1) := second.fst
  let c : Realizer (fun x : Context×(ℕ×ℕ)=>x.2.2) := second.snd
  let a := composition (composition bs listLength) predecessor
  let ba := composition (pair bs a) (getDFast ([] : Bag))
  let bb := composition (pair bs b) (getDFast ([] : Bag))
  let p := composition (composition (pair b a) natEqual) boolNot
  let q := composition (pair ba c) membership
  let r := composition (pair bb c) membership
  exact (composition (pair (composition (pair p q) boolAnd) r) boolAnd).congr (by intro x; simp [valid])
lemma polynomial_validFast : PolynomialTime validFast := by
  unfold validFast Realizer.fst Realizer.snd
  dsimp only
  apply polynomial_congr
  have := polynomial_predecessor
  have := polynomial_getDFast ([] : Bag)
  have := polynomial_membership
  tree_poly

def fastBranch (x : Context×ℕ) : ℕ := cappedCount ((residual (x.1.1.1,x.2),x.1.1.2),x.1.2)
def fastBranchRealizer : Realizer fastBranch :=
  (composition (pair (pair (composition (pair first.fst.fst second) residualFast) first.fst.snd)
    first.snd) cappedCountRealizer).congr (fun _=>rfl)
lemma polynomial_fastBranch : PolynomialTime fastBranchRealizer := by
  unfold fastBranchRealizer Realizer.fst Realizer.snd
  apply polynomial_congr
  apply polynomial_composition _ polynomial_cappedCount
  have := polynomial_residualFast
  tree_poly

def fastEdgeCount (x : Context×(ℕ×ℕ)) : ℕ := if valid x then fastBranch (x.1,x.2.1) else 0
def fastEdgeCountRealizer : Realizer fastEdgeCount :=
  (choose validFast (composition (pair first second.fst) fastBranchRealizer) (constant 0)).congr (fun _=>rfl)
lemma polynomial_fastEdgeCount : PolynomialTime fastEdgeCountRealizer := by
  unfold fastEdgeCountRealizer
  apply polynomial_congr
  exact polynomial_choose polynomial_validFast
    (polynomial_composition (polynomial_pair polynomial_first (polynomial_fst polynomial_second)) polynomial_fastBranch)
    (polynomial_constant 0)

def fastProbability (x : Context×ℕ) : TreeFraction.Fraction :=
  (fastEdgeCount (x.1,decodeIndex (x.2,x.1.1.2.length)),cappedCount x.1)
def fastProbabilityRealizer : Realizer fastProbability := by
  let m : Realizer (fun x : Context×ℕ=>x.1.1.2.length) := composition first.fst.snd listLength
  let bc := composition (pair second m) decodeIndexRealizer
  exact (pair (composition (pair first bc) fastEdgeCountRealizer)
    (composition first cappedCountRealizer)).congr (fun _=>rfl)
lemma polynomial_fastProbability : PolynomialTime fastProbabilityRealizer := by
  unfold fastProbabilityRealizer
  dsimp only
  apply polynomial_congr
  apply polynomial_pair _ (polynomial_composition polynomial_first polynomial_cappedCount)
  apply polynomial_composition _ polynomial_fastEdgeCount
  apply polynomial_pair polynomial_first
  apply polynomial_composition _ polynomial_division
  exact polynomial_pair polynomial_second
    (polynomial_composition (polynomial_snd (polynomial_fst polynomial_first)) polynomial_listLength)

def fastProbabilities (x : Context) : List TreeFraction.Fraction :=
  (List.range (x.1.1.length*x.1.2.length)).map (fun i=>fastProbability (x,i))
def fastProbabilitiesRealizer : Realizer fastProbabilities := by
  let n : Realizer (fun x : Context=>x.1.1.length) := composition first.fst listLength
  let m : Realizer (fun x : Context=>x.1.2.length) := composition first.snd listLength
  exact (composition (pair identity (composition (composition (pair n m) multiply) range))
    (mapWith fastProbabilityRealizer)).congr (fun _=>rfl)
lemma polynomial_fastProbabilities : PolynomialTime fastProbabilitiesRealizer := by
  unfold fastProbabilitiesRealizer Realizer.fst Realizer.snd
  dsimp only
  apply polynomial_congr
  apply polynomial_composition _ (polynomial_mapWith polynomial_fastProbability)
  apply polynomial_pair polynomial_identity
  apply polynomial_boundedRange (by tree_poly) (X^2)
  intro x
  simp only [Function.comp_apply,Polynomial.eval_pow,Polynomial.eval_X]
  simpa only [pow_two] using Nat.mul_le_mul ((list_length_le_weight x.1.1).trans ((weight_fst x.1).trans (weight_fst x)))
      ((list_length_le_weight x.1.2).trans ((weight_snd x.1).trans (weight_fst x)))

def fastDraw (x : Context×List Bool) : ℕ×ℕ :=
  decodeIndex (ExecutableChoice.chooseBits (fastProbabilities x.1,x.2),x.1.1.2.length)
def fastDrawRealizer : Realizer fastDraw :=
  (composition (pair (composition (pair (composition first fastProbabilitiesRealizer) second)
      ExecutableChoice.chooseBitsFast) (composition first.fst.snd listLength)) decodeIndexRealizer).congr (fun _=>rfl)
lemma polynomial_fastDraw : PolynomialTime fastDrawRealizer := by
  unfold fastDrawRealizer decodeIndexRealizer
  apply polynomial_congr
  apply polynomial_composition _ polynomial_division
  apply polynomial_pair _ (polynomial_composition (polynomial_snd (polynomial_fst polynomial_first)) polynomial_listLength)
  exact polynomial_composition (polynomial_pair
    (polynomial_composition polynomial_first polynomial_fastProbabilities) polynomial_second) ExecutableChoice.polynomial_chooseBitsFast
end MatchingFPRAS.ExecutableUnit

end OAI