import OAI.Analysis.FourierLLogL.Paths.Chief
/-! # The uniform output path -/

open Function Set Filter
open scoped Topology BigOperators ComplexConjugate
noncomputable section

namespace OAI

namespace FourierLLogL.Dyadic.Procedure.Paths
open Law Node Real Period Compress.Params Thermal Fund Scene Fork Road Event Journal Wire Pulse Thread Capture Chart Snapshot
variable {M j J : ℕ} {s q : Scene M} {f : Grid M → ℝ}
open scoped Classical


namespace Run.Streak
open Beam

def wave (e : Streak M) (t : Tide) : Path M → Tide
| [] => t
| b::l => wave e (e.rightNow b.post t).next l
lemma wave_combine (e : Streak M) (t : Tide) (l r : Path M) :
    e.wave t (l++r)=e.wave (e.wave t l) r := by
  induction l generalizing t with
  | nil => rfl
  | cons b l ih => exact ih _

lemma wave_bling (e : Streak M) (t : Tide) (l r : Path M) :
    e.sumbling (e.wave t l) r ≤ e.sumbling t (l++r) := by
  induction l generalizing t with
  | nil => exact le_rfl
  | cons b l ih =>
    change _ ≤ sumbling e t (b::(l++r))
    rw [sumbling]
    apply le_trans (ih _)
    apply le_add_of_nonneg_left
    split; linarith [(bling_share e (b::(l++r))).1]
    exact le_rfl

lemma holds_tail (e : Streak M) (p r : Path M) (n : ℝ) (hp : e.wave none p=some n) :
    ∃ v w : Path M, p=v++w ∧ (∀ b∈w,e.outer b.post) ∧
      fullFax w=n ∧ e.bling (w++r) ≤ e.sumbling none (p++r) := by
  induction p using List.reverseRecOn generalizing n r with
  | nil => cases hp
  | append_singleton p b ih =>
    rw [wave_combine] at hp
    let t := e.wave none p; let k := e.rightNow b.post t
    let a := b.post
    change k.next=some n at hp
    have hx : e.sumbling t ([b]++r) ≤ e.sumbling none ((p++[b])++r) := by
      rw [List.append_assoc]
      exact wave_bling e none p _
    have HH (ha : k.alpha ∨ k.tick) (h : fax a=n) (hF : outer e a) :
        ∃ v w : Path M,p++[b]=v++w ∧ (∀ z∈w,e.outer z.post) ∧
          fullFax w=n ∧ e.bling (w++r) ≤ e.sumbling none ((p++[b])++r) := by
      refine ⟨p,[b],rfl,by simpa using hF,?_,?_⟩
      · change fax a+0=_; simpa only [add_zero] using h
      · apply le_trans _ hx; change bling _ _ ≤ sumbling e t (b::r); rw [sumbling,ite_eq_left ha]
        apply le_add_of_nonneg_right; linarith [sumbling_one e (rightNow e b.post t).next r]
    cases ht : t with
    | none =>
      by_cases hV : innerV e b.post
      · have hi : k=going true false (fax b.post) := by unfold k; rw [ht]; exact ite_eq_left hV
        rw [hi] at hp
        exact HH (by rw [hi]; exact Or.inl rfl) (Option.some.inj hp) (inner_outer e _ hV)
      · have hi : k=idle := by unfold k; rw [ht]; exact ite_eq_right hV
        rw [hi] at hp; cases hp
    | some x =>
      by_cases hV : outer e b.post
      · by_cases hz : 1 ≤ x
        · have hi : k=going false true (fax b.post) := by simp only [k,ht,rightNow,hV,hz, ↓reduceIte]
          rw [hi] at hp
          exact HH (by rw [hi]; exact Or.inr rfl) (Option.some.inj hp) hV
        have hi : k=going false false (x+fax b.post) := by simp only [k,ht,rightNow,hV,hz, ↓reduceIte]
        rw [hi] at hp
        obtain ⟨v,w,hw,h1,h2,h3⟩ := ih (b::r) x ht
        refine ⟨v,w++[b],by rw [hw,List.append_assoc],?_,?_,?_⟩
        · intro z hz; simp only [List.mem_append,List.mem_singleton] at hz
          exact hz.elim (fun hh => h1 z hh) (fun h => h ▸ hV)
        · unfold fullFax; rw [subtotal_app]
          change fullFax w+(fax b.post+0)=n
          rw [h2,add_zero]; exact Option.some.inj hp
        simp only [List.append_assoc, List.singleton_append]
        exact h3
      · have hi : k=idle := by unfold k; rw [ht]; exact ite_eq_right hV
        rw [hi] at hp; cases hp

lemma holds_inner (e : Streak M) (p l m : Path M) (h : ∀ b∈l,e.innerV b.post) (hh : l ≠ []) :
    ∃ v w : Path M, p=v++w ∧ (∀ b∈w++l,e.outer b.post) ∧ fullFax w ≤ 1 ∧
      e.bling (w++(l++m)) ≤ e.sumbling none (p++(l++m)) := by
  cases l with
  | nil => exact (hh rfl).elim
  | cons b l =>
    let r := b::l; let t := e.wave none p; let k := e.rightNow b.post t
    have hv : ∀ b ∈ r,e.outer b.post := fun b hi => inner_outer e b.post (h b hi)
    have hh' : innerV e b.post := h b List.mem_cons_self
    have ho : outer e b.post := inner_outer e _ hh'
    by_cases ha : k.alpha=true ∨ k.tick=true
    · refine ⟨p,[],(by simp),hv,(by change (0:ℝ) ≤ 1; norm_num),?_⟩
      apply le_trans _ (wave_bling e none p (r++m))
      change bling e (b::(l++m)) ≤ sumbling e t (b::(l++m)); rw [sumbling,ite_eq_left ha]
      apply le_add_of_nonneg_right; linarith [sumbling_one e (rightNow e b.post t).next (l++m)]
    · cases hx : t with
      | none =>
        apply (ha ?_).elim
        apply Or.inl; unfold k; rw [hx]
        rw [rightNow,ite_eq_left hh']; rfl
      | some x =>
        have he : x < 1 := by
          by_contra! he
          apply ha; apply Or.inr; unfold k; rw [hx]
          simp [rightNow,ho,he,going]
        obtain ⟨v,w,hq,h₁,h₂,h₃⟩ := holds_tail e p (r++m) x hx
        refine ⟨v,w,hq,?_,(h₂.le.trans he.le),h₃⟩
        intro c hc; rw [List.mem_append] at hc
        exact hc.elim (h₁ c) (hv c)

lemma possible (e : Streak M) {x : Grid M} (p l m : Path M)
    (h : Trip x s (p++(l++m))) (hp : ∀ b∈l,e.innerV b.post)
    (t : ℝ) (ht : 2*log (sumbling e none (p++(l++m))) ≤ t) :

      let L := p++(l++m); yieldW (subtotal (duties x e.u) l) ≤
      10^15*(fullFax l+(1+fullKills L+e.flagged L)/e.thick+e.thick*t) := by
  intro L
  let a := e.thick; let F := duties x e.u
  have ha : 0 < a := e.thick_rate.1
  have hi : a ≤ 1 := e.thick_rate.2.1
  have hT : 0 ≤ t := le_trans (mul_nonneg (by norm_num)
    (log_nonneg (sumbling_one e none L))) ht
  have hL : 0 ≤ fullKills L := trip_K h; have hE : 0 ≤ flagged e L := flagged_pos e h
  by_cases H : l=[]
  · rw [H,subtotal_nil,yield_zero]
    change (0:ℝ) ≤ 10^15*(0+(1+fullKills L+flagged e L)/a+a*t)
    positivity
  obtain ⟨v,w,hv,hq,hf,hB⟩ := holds_inner e p l m hp H
  have HE : L=v++((w++l)++m) := by unfold L; simp [hv]
  have H0 : Trip x s (v++((w++l)++m)) := HE ▸ h
  obtain ⟨h₁,s',hh⟩ := trip_cut H0
  obtain ⟨h₂,q,h₄⟩ := trip_cut hh
  obtain ⟨h₃,r,h₅⟩ := trip_cut h₂
  have HX : 2*log (bling e (w++(l++m))) ≤ t :=
    le_trans (mul_le_mul_of_nonneg_left (log_le_log
      (by linarith [(bling_share e (w++(l++m))).1]) hB) (by norm_num)) ht
  rw [show subtotal (duties x e.u) l=subtotal F (w++l)-subtotal F w by rw [subtotal_app]; unfold F; abel]
  apply (yield_sub _ _).trans
  apply le_trans (add_le_add
    (ribbon_bound e _ _ h₂ hq t (show 2*log (e.bling ((w++l)++m)) ≤ t from by rwa [List.append_assoc]))
    (ribbon_bound e _ _ h₃ (fun b hb => hq b (List.mem_append_left _ hb)) t HX))
  have hiP (g : Beat M → ℝ) :
      subtotal g L=subtotal g v+subtotal g (w++l)+subtotal g m := by
    rw [HE,subtotal_app,subtotal_app]; linarith
  have H₁ (p l : Path M) : fullKills (p++l)=fullKills p+fullKills l := subtotal_app _ _ _
  have H₂ (p l : Path M) : flagged e (p++l)=flagged e p+flagged e l := subtotal_app _ _ _
  have hk : fullKills w ≤ fullKills (w++l) ∧ fullKills (w++l) ≤ fullKills L := by
    have H : fullKills L=fullKills v+fullKills (w++l)+fullKills m := hiP killed
    constructor <;> linarith [trip_K h₁,trip_K h₄,trip_K h₅,H₁ w l]
  have he : flagged e w ≤ flagged e (w++l) ∧ flagged e (w++l) ≤ flagged e L := by
    have H : flagged e L=flagged e v+flagged e (w++l)+flagged e m := hiP _
    constructor <;> linarith [flagged_pos e h₁,flagged_pos e h₄,flagged_pos e h₅,H₂ w l]
  rw [show fullFax (w++l)=fullFax w+fullFax l from subtotal_app _ w l]
  have hY : 1 ≤ (e.thick)⁻¹ := (one_le_inv₀ ha).mpr hi
  unfold a at *
  simp_rw [div_eq_mul_inv]
  nlinarith [trip_fax h₅]

end Run.Streak


end FourierLLogL.Dyadic.Procedure.Paths

end OAI