import Mathlib
import OAI.Combinatorics.MatchingCount.Graphs.LabelOrder
import OAI.Combinatorics.MatchingCount.Machines.TreeLabelTable
import OAI.Combinatorics.MatchingCount.Machines.TreeSlotWeight

namespace OAI

namespace MatchingFPRAS.OnlineSchedule
open TreeTyped TreeFraction Polynomial

abbrev PowerSearchInput := (Fraction×Fraction)×List Bool

def powerCandidate (x : PowerSearchInput×ℕ) : Bool :=
  !(TreeFraction.less (fuelPower (x.1.1.1,x.1.2.take x.2),x.1.1.2))
def powerCandidateRealizer : Realizer powerCandidate :=
  (composition (composition (pair
    (composition (pair first.fst.fst (composition (pair first.snd second) takeFast)) fuelPowerRealizer)
    first.fst.snd) lessRealizer) boolNot).congr (fun _=>rfl)
lemma polynomial_powerCandidate : PolynomialTime powerCandidateRealizer := by
  unfold powerCandidateRealizer; apply polynomial_congr
  exact polynomial_composition (polynomial_composition
    (polynomial_pair
      (polynomial_composition
        (polynomial_pair (polynomial_fst (polynomial_fst polynomial_first))
          (polynomial_composition (polynomial_pair (polynomial_snd polynomial_first) polynomial_second)
            polynomial_takeFast)) polynomial_fuelPower)
      (polynomial_snd (polynomial_fst polynomial_first))) TreeFraction.polynomial_less) polynomial_boolNot

def findPower (x : PowerSearchInput) : ℕ :=
  listMin ((List.range (x.2.length+1)).filter (fun i=>powerCandidate (x,i)),x.2.length)
def findPowerRealizer : Realizer findPower := by
  let B : Realizer (fun x : PowerSearchInput=>x.2.length) := composition second listLength
  let R := composition (composition B successor) range
  let F := composition (pair identity R) (filterWith powerCandidateRealizer)
  exact (composition (pair F B) listMinRealizer).congr (fun _=>rfl)
lemma polynomial_findPower : PolynomialTime findPowerRealizer := by
  unfold findPowerRealizer
  dsimp only
  apply polynomial_congr
  apply polynomial_composition _ polynomial_listMin
  apply polynomial_pair _ (polynomial_composition polynomial_second polynomial_listLength)
  apply polynomial_composition _ (polynomial_filterWithList polynomial_powerCandidate)
  apply polynomial_pair polynomial_identity
  apply polynomial_boundedRange
    (polynomial_composition (polynomial_composition polynomial_second polynomial_listLength) polynomial_successor)
    (X+1)
  intro x
  have h:=list_length_le_weight x.2
  change x.2.length+1≤(X+1).eval (weight x)
  simp only [Polynomial.eval_add,Polynomial.eval_X,Polynomial.eval_one]
  rw [weight_prod]
  omega
lemma powerCandidate_repr (a b : ℚ) (ha : 0≤a) (hb : 0≤b) (fuel : List Bool) (i : ℕ)
    (hi : i≤fuel.length) :
    powerCandidate (((repr a,repr b),fuel),i)=decide (b≤a^i) := by
  unfold powerCandidate
  rw [fuelPower_repr a ha,List.length_take,min_eq_left hi]
  rw [less_val _ _ (a^i).pos b.pos,
    val_repr (by positivity),val_repr hb]
  apply Bool.eq_iff_iff.mpr
  simp
lemma findPower_le_fuel (x : PowerSearchInput) : findPower x≤x.2.length :=
  listMin_le_default _ _
lemma findPower_le (a b : ℚ) (ha : 0≤a) (hb : 0≤b) (fuel : List Bool) (i : ℕ)
    (hi : i≤fuel.length) (hr : b ≤ a ^ i) : findPower ((repr a, repr b), fuel) ≤ i := by
  apply listMin_le
  simp only [List.mem_filter,List.mem_range,powerCandidate_repr a b ha hb fuel i hi,
    decide_eq_true_eq]
  exact ⟨by omega,hr⟩
lemma le_findPower (a b : ℚ) (ha : 0≤a) (hb : 0≤b) (fuel : List Bool) (i : ℕ)
    (hi : i≤fuel.length)
    (hmin : ∀ j,j≤fuel.length→b≤a^j→i≤j) : i≤findPower ((repr a,repr b),fuel) := by
  apply le_listMin hi
  intro j hj
  simp only [List.mem_filter,List.mem_range] at hj
  have hj' : j≤fuel.length := by omega
  rw [powerCandidate_repr a b ha hb fuel j hj',decide_eq_true_eq] at hj
  exact hmin j hj' hj.2
lemma findPower_eq (a b : ℚ) (ha : 0≤a) (hb : 0≤b) (fuel : List Bool) (T : ℕ)
    (hT : T≤fuel.length) (hr : b≤a^T) (hmin : ∀ j,b≤a^j→T≤j) :
    findPower ((repr a,repr b),fuel)=T :=
  Nat.le_antisymm (findPower_le a b ha hb fuel T hT hr)
    (le_findPower a b ha hb fuel T hT (fun j _ hj=>hmin j hj))

lemma endpoint_le_bound (N D K : ℕ) (hN : 0<N) :
    Transport.endpoint N D K hN≤Transport.tierBound N D K := by
  rw [Transport.endpoint_eq]
  exact Transport.ladderTier_le N D K hN
lemma endpoint_power_spec (N D K : ℕ) (hN : 0<N) :
    max (D:ℚ) (3*4^K)≤(Transport.rationalBase N)^(Transport.endpoint N D K hN) := by
  have h:=Transport.endpoint_reaches N D K hN
  rw [←Transport.rationalBase_cast] at h
  exact_mod_cast h
lemma endpoint_power_min (N D K : ℕ) (hN : 0<N) (t : ℕ)
    (ht : max (D:ℚ) (3*4^K)≤(Transport.rationalBase N)^t) :
    Transport.endpoint N D K hN≤t := by
  rw [Transport.endpoint_eq]
  apply Nat.find_min'
  rw [←Transport.rationalBase_cast]
  exact_mod_cast ht
lemma findPower_endpoint (N D K : ℕ) (hN : 0<N) (fuel : List Bool)
    (hf : Transport.tierBound N D K≤fuel.length) :
    findPower ((repr (Transport.rationalBase N),repr (max (D:ℚ) (3*4^K))),fuel)=
      Transport.endpoint N D K hN := by
  apply findPower_eq
  · unfold Transport.rationalBase; positivity
  · positivity
  · exact (endpoint_le_bound N D K hN).trans hf
  · exact endpoint_power_spec N D K hN
  · exact endpoint_power_min N D K hN
end MatchingFPRAS.OnlineSchedule

end OAI