import Mathlib
import OAI.Computability.MinUncut.Estimates.UniformBoolean

namespace OAI

section
namespace MinUncut.Preprocess
open MinUncutGames.Foundations.Hastad.SourceOccurrences
namespace UEncoding
variable {P : Type} [Primcodable P] {A B Γ : P → Type}

lemma Map.ofEq {a : UEncoding P A} {b : UEncoding P B}
    {f g : ∀p,A p → B p} (hf : a.Map b f) (h : ∀p x,f p x=g p x) : a.Map b g := by
  obtain ⟨f',hr,hf⟩:=hf
  exact ⟨f',hr,by intro p x; rw [hf,h]⟩

lemma map_true (a : UEncoding P A) : a.Map bool (fun _ _=>true) :=
  map_const (Computable.const 1)
lemma map_false (a : UEncoding P A) : a.Map bool (fun _ _=>false) :=
  map_const (Computable.const 0)

lemma map_forall {g : UEncoding P Γ} {a : UEncoding P A}
    {f : ∀p,Γ p × A p → Bool} [∀p s,Decidable (∀x,f p (s,x)=true)]
    (hf : (g.prod a).Map bool f) :
    g.Map bool (fun p s=>decide (∀x,f p (s,x)=true)) := by
  classical
  have hh := map_bool_eq (map_lambda hf) (map_lambda (map_true (g.prod a)))
  apply hh.ofEq
  intro p s
  apply decide_eq_decide.mpr
  exact ⟨fun h x=>congrFun h x,fun h=>funext h⟩

lemma map_exists {g : UEncoding P Γ} {a : UEncoding P A}
    {f : ∀p,Γ p × A p → Bool} [∀p s,Decidable (∃x,f p (s,x)=true)]
    (hf : (g.prod a).Map bool f) :
    g.Map bool (fun p s=>decide (∃x,f p (s,x)=true)) := by
  classical
  have hh := map_not (map_forall (map_not hf))
  apply hh.ofEq
  intro p s
  rw [←decide_not]
  apply decide_eq_decide.mpr
  simp

def Value (a : UEncoding P A) (f : ∀p,A p → ℕ) : Prop :=
  ∃g : P × ℕ → ℕ, Computable g ∧ ∀p x,g (p,((a.enc p).code x).val)=f p x

lemma value_code (a : UEncoding P A) : a.Value (fun p x=>((a.enc p).code x).val) :=
  ⟨Prod.snd,Computable.snd,by intros; rfl⟩
lemma value_const (a : UEncoding P A) {f : P → ℕ} (hf : Computable f) :
    a.Value (fun p _=>f p) := ⟨_,hf.comp Computable.fst,by intros; rfl⟩
lemma Value.comp {a : UEncoding P A} {b : UEncoding P B}
    {f : ∀p,A p → B p} {g : ∀p,B p → ℕ} (hg : b.Value g) (hf : a.Map b f) :
    a.Value (fun p x=>g p (f p x)) := by
  obtain ⟨f',hrf,hf⟩:=hf
  obtain ⟨g',hrg,hg⟩:=hg
  exact ⟨fun q=>g' (q.1,f' q),hrg.comp (Computable.fst.pair hrf),
    by intro p x; dsimp only; rw [hf,hg]⟩
lemma Value.map {a : UEncoding P A} {f : ∀p,A p → ℕ} (hf : a.Value f)
    {g : ℕ → ℕ} (hg : Computable g) : a.Value (fun p x=>g (f p x)) := by
  obtain ⟨f',hrf,hf⟩:=hf
  exact ⟨_,hg.comp hrf,by intro p x; dsimp only; rw [hf]⟩
lemma Value.map₂ {a : UEncoding P A} {f g : ∀p,A p → ℕ}
    (hf : a.Value f) (hg : a.Value g) {op : ℕ → ℕ → ℕ} (hop : Computable₂ op) :
    a.Value (fun p x=>op (f p x) (g p x)) := by
  obtain ⟨f',hrf,hf⟩:=hf
  obtain ⟨g',hrg,hg⟩:=hg
  exact ⟨_,hop.comp hrf hrg,by intro p x; dsimp only; rw [hf,hg]⟩

lemma value_sum {g : UEncoding P Γ} {a : UEncoding P A}
    {f : ∀p,Γ p × A p → ℕ} (hf : (g.prod a).Value f) :
    g.Value (fun p s=>((a.enc p).enumerate.map (fun x=>f p (s,x))).sum) := by
  obtain ⟨f',hf',hf⟩:=hf
  let raw : (P × ℕ) → ℕ → ℕ := fun q i=>f' (q.1,q.2*(a.enc q.1).size+i)
  have hr : Computable₂ raw := by
    unfold raw
    exact hf'.comp ((Computable.fst.comp Computable.fst).pair
      (ca_add (ca_mul (Computable.snd.comp Computable.fst)
        (a.computableSize.comp (Computable.fst.comp Computable.fst))) Computable.snd))
  refine ⟨fun q=>((List.range (a.enc q.1).size).map (raw q)).sum,
    c_boundedSum hr (a.computableSize.comp Computable.fst),?_⟩
  intro p s
  dsimp only
  rw [Encoding.enumerate,List.ofFn_eq_map,List.map_map]
  rw [←finRange_values ((a.enc p).size),List.map_map]
  apply congrArg List.sum
  apply List.map_congr_left
  intro i hi
  have hh : f' (p, (((g.enc p).prod (a.enc p)).code (s, (a.enc p).code.symm i)).val) =
      f p (s, (a.enc p).code.symm i) :=
    hf p (s, (a.enc p).code.symm i)
  rw [prod_code,Equiv.apply_symm_apply] at hh
  exact hh

end UEncoding
end MinUncut.Preprocess

end

end OAI