import Mathlib
import OAI.Combinatorics.MatchingCount.Machines.OnlineFold
import OAI.Combinatorics.MatchingCount.Machines.OnlineFrame

namespace OAI

namespace MatchingFPRAS.OnlineTree
open PhysicalStream TreeTyped

variable {A B C : Type} [Codec A] [Codec B] [Codec C]

def traverseM (f : A → Experiment B) : List A → Experiment (List B)
  | [] => .done []
  | a::as => (f a).bind (fun b=>(traverseM f as).map (List.cons b))
def collectStep (f : A → Experiment B) (x : A×List B) : Experiment (List B) :=
  (f x.1).map (fun b=>b::x.2)
noncomputable def collectStepRealizer {f : A → Experiment B} (F : Realizer f) :
    Realizer (collectStep f) :=
  (composition (pair (composition (deterministic TreeTyped.first) F)
    (deterministic TreeTyped.second)) (deterministic TreeTyped.listCons)).congr (by
      intro x h; simp only [Experiment.mean_bind,Experiment.mean_map,Experiment.mean,collectStep])
omit [Codec A] [Codec B] in
lemma mean_fold_collect (f : A → Experiment B) (as : List A) (bs : List B) (h : List B → ℚ) :
    (foldM (collectStep f) as bs).mean h=(traverseM f as).mean (fun cs=>h (cs.reverse++bs)) := by
  induction as generalizing bs with
  | nil => simp only [foldM,traverseM,Experiment.mean,List.reverse_nil,List.nil_append]
  | cons a as ih =>
    simp only [foldM,traverseM,collectStep,Experiment.mean_bind,Experiment.mean_map,ih]
    congr 1; funext b
    congr 1; funext cs
    simp only [List.reverse_cons,List.append_assoc,List.singleton_append]
noncomputable def traverse {f : A → Experiment B} (F : Realizer f) : Realizer (traverseM f) :=
  (composition (composition (deterministic (TreeTyped.pair TreeTyped.identity (TreeTyped.constant ([] : List B))))
    (fold (collectStepRealizer F))) (deterministic TreeTyped.reverse)).congr (by
      intro as h
      simp only [Experiment.mean_bind,Experiment.mean]
      rw [mean_fold_collect]
      simp only [List.append_nil,List.reverse_reverse,id_eq])
omit [Codec A] [Codec B] in
lemma all_traverse (f : A → Experiment B) (as : List A) (P : B → Prop)
    (hf : ∀ a∈as,(f a).All P) : (traverseM f as).All (fun bs=>∀ b∈bs,P b) := by
  induction as with
  | nil => simp [traverseM,Experiment.All]
  | cons a as ih =>
    rw [traverseM,Experiment.all_bind]
    exact (hf a (by simp)).mono (fun b hb=>by
      rw [Experiment.all_map]
      exact (ih (fun a ha=>hf a (by simp [ha]))).mono (fun bs hbs=>by
        intro c hc
        rcases List.mem_cons.mp hc with rfl|hc
        · exact hb
        · exact hbs c hc))
omit [Codec A] [Codec B] in
lemma all_traverse_length (f : A → Experiment B) (as : List A) :
    (traverseM f as).All (fun bs=>bs.length=as.length) := by
  induction as with
  | nil => rfl
  | cons a as ih =>
    rw [traverseM,Experiment.all_bind]
    exact (Experiment.all_true (f a)).mono (fun b _=>by
      rw [Experiment.all_map]
      exact ih.mono (fun bs hb=>by simpa only [List.length_cons] using congrArg Nat.succ hb))
end MatchingFPRAS.OnlineTree

end OAI