lean/OAI/Computability/MinUncut/Encoding/UniformEncoding.lean

import Mathlib
import OAI.Computability.MinUncut.Search.RawRationalArithmetic
import OAI.Computability.MinUncut.PCP.Occurrences

namespace OAI

section
namespace MinUncut.Preprocess
open MinUncutGames.Foundations.Hastad.SourceOccurrences
open scoped BigOperators

structure UEncoding (P : Type) [Primcodable P] (A : P → Type) where
  enc : ∀p, Encoding (A p)
  computableSize : Computable (fun p=>(enc p).size)

namespace UEncoding
variable {P : Type} [Primcodable P] {A B C Γ : P → Type}

def prod (a : UEncoding P A) (b : UEncoding P B) : UEncoding P (fun p=>A p × B p) where
  enc p := (a.enc p).prod (b.enc p)
  computableSize := ca_mul a.computableSize b.computableSize

def function (a : UEncoding P A) (b : UEncoding P B) : UEncoding P (fun p=>A p → B p) where
  enc p := (a.enc p).function (b.enc p)
  computableSize := ca_pow b.computableSize a.computableSize

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

lemma map_id (a : UEncoding P A) : a.Map a (fun _ x=>x) :=
  ⟨Prod.snd,Computable.snd,by intros; rfl⟩

lemma map_comp {a : UEncoding P A} {b : UEncoding P B} {c : UEncoding P C}
    {f : ∀p,A p → B p} {g : ∀p,B p → C p} (hf : a.Map b f) (hg : b.Map c g) :
    a.Map c (fun p x=>g p (f p x)) := by
  obtain ⟨f',hf',hf⟩:=hf
  obtain ⟨g',hg',hg⟩:=hg
  exact ⟨fun q=>g' (q.1,f' q),hg'.comp (Computable.fst.pair hf'),by intro p x; dsimp only; rw [hf,hg]⟩

lemma prod_code {Left Right : Type} (a : Encoding Left) (b : Encoding Right)
    (x : Left) (y : Right) :
    ((a.prod b).code (x,y)).val=(a.code x).val*b.size+(b.code y).val := by
  change (b.code y).val+b.size*(a.code x).val=_
  ac_rfl

lemma map_pair {a : UEncoding P A} {b : UEncoding P B} {c : UEncoding P C}
    {f : ∀p,A p → B p} {g : ∀p,A p → C p} (hf : a.Map b f) (hg : a.Map c g) :
    a.Map (b.prod c) (fun p x=>(f p x,g p x)) := by
  obtain ⟨f',hf',hf⟩:=hf
  obtain ⟨g',hg',hg⟩:=hg
  refine ⟨fun q=>f' q*(c.enc q.1).size+g' q,?_,?_⟩
  · exact ca_add (ca_mul hf' (c.computableSize.comp Computable.fst)) hg'
  · intro p x
    dsimp only
    rw [hf,hg]
    exact (prod_code _ _ _ _).symm

lemma map_fst (a : UEncoding P A) (b : UEncoding P B) :
    (a.prod b).Map a (fun _ x=>x.1) := by
  refine ⟨fun q=>q.2/(b.enc q.1).size,ca_div Computable.snd (b.computableSize.comp Computable.fst),?_⟩
  intro p ⟨x,y⟩
  change (((b.enc p).code y).val+(b.enc p).size*((a.enc p).code x).val)/(b.enc p).size=_
  rw [Nat.add_mul_div_left _ _ (Nat.zero_lt_of_lt ((b.enc p).code y).isLt),
    Nat.div_eq_of_lt ((b.enc p).code y).isLt,Nat.zero_add]

lemma map_snd (a : UEncoding P A) (b : UEncoding P B) :
    (a.prod b).Map b (fun _ x=>x.2) := by
  refine ⟨fun q=>q.2%(b.enc q.1).size,ca_mod Computable.snd (b.computableSize.comp Computable.fst),?_⟩
  intro p ⟨x,y⟩
  change (((b.enc p).code y).val+(b.enc p).size*((a.enc p).code x).val)%(b.enc p).size=_
  rw [Nat.add_mul_mod_self_left,Nat.mod_eq_of_lt ((b.enc p).code y).isLt]

lemma function_digit {X Y : Type} (a : Encoding X) (b : Encoding Y) (f : X → Y) (x : X) :
    (((a.function b).code f).val/(b.size^(a.code x).val))%b.size=(b.code (f x)).val := by
  have hh:=congrArg Fin.val (congrFun (finFunctionFinEquiv.symm_apply_apply
    (fun i=>b.code (f (a.code.symm i)))) (a.code x))
  change (((a.function b).code f).val/(b.size^(a.code x).val))%b.size=
    (b.code (f (a.code.symm (a.code x)))).val at hh
  simpa only [Equiv.symm_apply_apply] using hh

lemma map_apply {g : UEncoding P Γ} {a : UEncoding P A} {b : UEncoding P B}
    {f : ∀p,Γ p → A p → B p} {x : ∀p,Γ p → A p}
    (hf : g.Map (a.function b) f) (hx : g.Map a x) :
    g.Map b (fun p s=>f p s (x p s)) := by
  obtain ⟨f',hf',hf⟩:=hf
  obtain ⟨x',hx',hx⟩:=hx
  refine ⟨fun q=>(f' q/(b.enc q.1).size^(x' q))%(b.enc q.1).size,?_,?_⟩
  · exact ca_mod (ca_div hf' (ca_pow (b.computableSize.comp Computable.fst) hx'))
      (b.computableSize.comp Computable.fst)
  · intro p s
    dsimp only
    rw [hf,hx]
    exact function_digit _ _ _ _

lemma function_number {X Y : Type} (a : Encoding X) (b : Encoding Y) (f : X → Y) :
    ((a.function b).code f).val=
      ∑i : Fin a.size,(b.code (f (a.code.symm i))).val*b.size^i.val := rfl

lemma finRange_values (n : ℕ) : (List.finRange n).map Fin.val=List.range n := by
  apply List.ext_getElem
  · simp
  · intro i hi hj
    simp

lemma map_lambda {g : UEncoding P Γ} {a : UEncoding P A} {b : UEncoding P B}
    {f : ∀p,Γ p × A p → B p} (hf : (g.prod a).Map b f) :
    g.Map (a.function b) (fun p s x=>f p (s,x)) := by
  obtain ⟨f',hf',hf⟩:=hf
  let raw : (P × ℕ) → ℕ → ℕ := fun q i=>f' (q.1,q.2*(a.enc q.1).size+i)*(b.enc q.1).size^i
  have hr : Computable₂ raw := by
    unfold raw
    exact ca_mul (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)))
      (ca_pow (b.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 [function, function_number,←List.sum_ofFn,List.ofFn_eq_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) =
      ((b.enc p).code (f p (s, (a.enc p).code.symm i))).val :=
    hf p (s, (a.enc p).code.symm i)
  rw [prod_code,Equiv.apply_symm_apply] at hh
  dsimp only [Function.comp_def,raw]
  rw [hh]

end UEncoding
end MinUncut.Preprocess

end

end OAI