import Mathlib
import OAI.Computability.MinUncut.Estimates.TemplateExpressions

namespace OAI

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

def equationEquiv (X : Type) : Equation X ≃ X × X × X × Bool where
  toFun e := (e.first,e.second,e.third,e.rhs)
  invFun x := ⟨x.1,x.2.1,x.2.2.1,x.2.2.2⟩
  left_inv _ := rfl
  right_inv _ := rfl

def equation (a : UEncoding P A) : UEncoding P (fun p=>Equation (A p)) :=
  (a.prod (a.prod (a.prod bool))).ofEquiv (fun p=>equationEquiv (A p))

lemma map_equation {g : UEncoding P Γ} {a : UEncoding P A}
    {f h j : ∀p,Γ p → A p} {b : ∀p,Γ p → Bool}
    (hf : g.Map a f) (hh : g.Map a h) (hj : g.Map a j) (hb : g.Map bool b) :
    g.Map a.equation (fun p x=>⟨f p x,h p x,j p x,b p x⟩) :=
  map_comp (map_pair hf (map_pair hh (map_pair hj hb)))
    (map_from (a.prod (a.prod (a.prod bool))) (fun p=>equationEquiv (A p)))

lemma map_thirdQuery {g : UEncoding P Γ} {a : UEncoding P A} {b : UEncoding P B}
    {π : ∀p,Γ p → B p → A p} {f : ∀p,Γ p → A p → Bool}
    {h μ : ∀p,Γ p → B p → Bool}
    (hπ : g.Map (b.function a) π) (hf : g.Map (a.function bool) f)
    (hh : g.Map (b.function bool) h) (hμ : g.Map (b.function bool) μ) :
    g.Map (b.function bool) (fun p x=>thirdQuery (π p x) (f p x) (h p x) (μ p x)) := by
  exact map_lambda (map_xor (map_apply hh.first (map_snd g b))
    (map_xor (map_apply hf.first (map_apply hπ.first (map_snd g b)))
      (map_apply hμ.first (map_snd g b))))

lemma map_padded {g : UEncoding P Γ} {a : UEncoding P A}
    {v f : ∀p,Γ p → A p → Bool} {i : ∀p,Γ p → A p}
    (hv : g.Map (a.function bool) v) (hf : g.Map (a.function bool) f) (hi : g.Map a i) :
    g.Map (a.function bool) (fun p x j=>if v p x j then representative (i p x) (f p x) j else false) :=
  map_lambda (map_cond (map_apply hv.first (map_snd g a))
    (map_apply (map_representative hf hi).first (map_snd g a)) (map_false _))

lemma map_value_zero {g : UEncoding P Γ} {n : P → ℕ} {hn : Computable n}
    {f : ∀p,Γ p → Fin (n p)} (hf : g.Map (fin n hn) f) :
    g.Map bool (fun p x=>decide ((f p x).val=0)) := by
  obtain ⟨f',hf',hf⟩:=hf
  refine ⟨fun q=>(decide (f' q=0)).toNat,
    (Primrec.dom_bool Bool.toNat).to_comp.comp
      (Primrec.eq.decide.to_comp.comp hf' (Computable.const 0)),?_⟩
  intro p x
  dsimp only
  rw [hf]
  change _=(Encoding.bool.code _).val
  rw [bool_code]
  rfl
end MinUncut.Preprocess.UEncoding

end

end OAI