lean/OAI/Computability/RationalHitting/MatrixComputation.lean

import OAI.Computability.RationalHitting.LiftComputation

namespace OAI

namespace RationalHitting.StackLanguage
open Function
variable {A : Type} [Coding A]

 def flattenStep (a : List (List A)×List A) : List (List A)×List A :=
  (a.1.tail,a.2++a.1.headD [])

 lemma flattenStep_code_le (a : List (List A)×List A) :
    (code (flattenStep a)).length≤(code a).length := by
  rcases a with ⟨l,r⟩
  cases l with
  | nil => simp [flattenStep]
  | cons x l =>
    simp only [flattenStep,List.tail_cons,List.headD_cons,prod_code_length]
    change 2*(listCode code l).length+1+(listCode code (r++x)).length≤
      2*(listCode code (x::l)).length+1+(listCode code r).length
    simp only [listCode_cons,listCode_append,List.length_append,codeWord_length]
    change _≤2*(2*(listCode code x).length+1+(listCode code l).length)+1+(listCode code r).length
    omega

 lemma flattenStep_iterate_code (a : List (List A)×List A) (k : ℕ) :
    (code (flattenStep^[k] a)).length≤(code a).length := by
  induction k with
  | zero => rfl
  | succ k ih => rw [iterate_succ_apply'];exact (flattenStep_code_le _).trans ih

 lemma flattenStep_iterate {A : Type} [Coding A] (l : List (List A)) (r : List A) :
    flattenStep^[l.length] (l,r)=([],r++l.flatten) := by
  induction l generalizing r with
  | nil => simp
  | cons x l ih =>
    rw [List.length_cons,iterate_succ_apply]
    simp [flattenStep,ih,List.append_assoc]

namespace Poly
@[fun_prop] theorem listFlatten : Poly (List.flatten : List (List A) → List A) := by
  have hs : Poly (flattenStep (A:=A)) := by
    unfold flattenStep
    fun_prop
  have ht := hs.iterate TimeBound.variable (by
    intro n a i hi
    have hh := flattenStep_iterate_code a i
    simp only [TimeBound.eval_variable,pairCode_length,unaryCode_length]
    omega)
  have ho := (show Poly (Prod.snd : List (List A)×List A → List A) from snd).comp
    (ht.comp (show Poly (fun a : List (List A) => (Unary.mk a.length,(a,([] : List A)))) by fun_prop))
  exact ho.of_eq (by intro a;simp [flattenStep_iterate])

theorem listFlatMap {B C : Type} [Coding B] [Coding C] [Inhabited B]
    {f : C×B → List A} (hf : Poly f) :
    Poly (fun a : C×List B => a.2.flatMap (fun b => f (a.1,b))) := by
  exact (listFlatten.comp hf.listMap).of_eq (by intro a;rw [List.flatMap_def])
end Poly
end RationalHitting.StackLanguage


namespace RationalHitting.StackLanguage
open Function

instance : Inhabited BitWord := ⟨⟨[]⟩⟩

def concatStep (a : List BitWord×BitWord) : List BitWord×BitWord :=
  (a.1.tail,⟨a.2.val++(a.1.headD ⟨[]⟩).val⟩)

lemma concatStep_code_le (a : List BitWord×BitWord) :
    (code (concatStep a)).length≤(code a).length := by
  rcases a with ⟨l,⟨r⟩⟩
  cases l with
  | nil => simp [concatStep]
  | cons x l =>
    simp only [concatStep,List.tail_cons,List.headD_cons,prod_code_length]
    change 2*(listCode code l).length+1+(r++x.val).length≤
      2*(listCode code (x::l)).length+1+r.length
    simp only [listCode_cons,List.length_append,codeWord_length]
    change _≤2*(2*x.val.length+1+(listCode code l).length)+1+r.length
    omega

lemma concatStep_iterate_code (a : List BitWord×BitWord) (k : ℕ) :
    (code (concatStep^[k] a)).length≤(code a).length := by
  induction k with
  | zero => rfl
  | succ k ih => rw [iterate_succ_apply'];exact (concatStep_code_le _).trans ih

lemma concatStep_iterate (l : List BitWord) (r : List Bool) :
    concatStep^[l.length] (l,⟨r⟩)=([],⟨r++l.flatMap BitWord.val⟩) := by
  induction l generalizing r with
  | nil => simp
  | cons x l ih =>
    rw [List.length_cons,iterate_succ_apply]
    simp [concatStep,ih,List.append_assoc]

namespace Procedure

def encodeWord : Procedure _root_.id _root_.id StackLanguage.encodedWord where
  Registers := Fin 4
  finite := inferInstance
  decEq := inferInstance
  input := 0
  output := 1
  program := StackLanguage.encodeWord
  bound := 15*TimeBound.variable
  correct a := by
    refine ⟨11*a.length+7,by simp;omega,?_⟩
    have hh := eval_encodeWord (single (0:Fin 4) a) (by simp [single]) (by simp [single])
    have hout : update (update (single (0:Fin 4) a) 0 []) 1
        (encodedWord ((single (0:Fin 4) a) 0)++(single (0:Fin 4) a) 1)=
        single 1 (encodedWord a) := by
      funext j;fin_cases j <;> simp [single]
    rw [hout] at hh
    simpa [single] using hh
  size a := by simp [encodedWord];omega
end Procedure

namespace Poly
@[fun_prop] theorem wordConcat : Poly (fun l : List BitWord => BitWord.mk (l.flatMap BitWord.val)) := by
  have hs : Poly concatStep := by
    have hh : Poly (fun a : List BitWord×BitWord => (a.2,a.1.headD ⟨[]⟩)) := by fun_prop
    exact (listTail.comp fst).pair (wordAppend.comp hh)
  have ht := hs.iterate TimeBound.variable (by
    intro n a i hi
    have hh := concatStep_iterate_code a i
    simp only [TimeBound.eval_variable,pairCode_length,unaryCode_length]
    omega)
  have ho := (show Poly (Prod.snd : List BitWord×BitWord → BitWord) from snd).comp
    (ht.comp (show Poly (fun a : List BitWord => (Unary.mk a.length,(a,(⟨[]⟩ : BitWord)))) by fun_prop))
  exact ho.of_eq (by intro a;simp [concatStep_iterate])

@[fun_prop] theorem encodeNat : Poly (fun a : ℕ => BitWord.mk (RationalHitting.encodeNat a)) := by
  exact (show Feasible _root_.id _root_.id StackLanguage.encodedWord from ⟨Procedure.encodeWord⟩).recode
    _ _ _ Nat.bits (by intro a;rfl) (by intro a;exact encodedWord_bits a)

@[fun_prop] theorem encodeUnary : Poly (fun a : Unary => BitWord.mk (RationalHitting.encodeNat a.val)) :=
  encodeNat.comp unaryToNat
end Poly
end RationalHitting.StackLanguage


namespace RationalHitting.StackLanguage
namespace Runtime

abbrev GridPoint := Unary×Unary×Unary

def gridFn (x : GridPoint) : Fin 3 → ℕ := ![x.1.val,x.2.1.val,x.2.2.val]

def matrix (p : Params) (x : GridPoint) (a : Unary) : DenseSquare :=
  ⟨p.m*p.q,fun i j => entry p.m p.N p.q a.val x.1.val x.2.1.val x.2.2.val i.val j.val⟩

@[fun_prop] theorem matrix_poly : Poly (fun a : Params×GridPoint×Unary => matrix a.1 a.2.1 a.2.2) := by
  have hn : Poly (fun a : Params×GridPoint×Unary => a.1.2.2.1*a.1.2.2.2.1) := by fun_prop
  have he : Poly (fun a : (Params×GridPoint×Unary)×(Unary×Unary) =>
      ((a.1.1.2.2.1,a.1.1.2.1,a.1.1.2.2.2.1),
      (a.1.2.2.toInt,a.1.2.1.1.toInt,a.1.2.1.2.1.toInt,a.1.2.1.2.2.toInt),a.2)) := by fun_prop
  exact Poly.denseBuild hn (entry_poly.comp he)

lemma matrix_eq (n s : ℕ) (x : GridPoint) (a : Fin (n+1)) :
    matrix (Params.of n s) x ⟨a.val⟩ = DenseSquare.of
      (Generator.U n (Parameters.N n s) (Parameters.exponent n s) (gridFn x) a) := by
  apply congrArg (fun A => (⟨Generator.D (Parameters.exponent n s),A⟩ : DenseSquare))
  funext i j
  exact entry_eq n _ _ (gridFn x) a i j

def cramer (A B : DenseSquare) (i j : ℕ) : DenseSquare :=
  ⟨A.dim,fun r c => if c.val=i then B.get r.val j else A.val r c⟩

@[fun_prop] theorem cramer_poly : Poly (fun a : (DenseSquare×DenseSquare)×(Unary×Unary) =>
    cramer a.1.1 a.1.2 a.2.1.val a.2.2.val) := by
  have hn : Poly (fun a : (DenseSquare×DenseSquare)×(Unary×Unary) => Unary.mk a.1.1.dim) :=
    Poly.denseDim.comp (by fun_prop)
  have hc : Poly (fun a : ((DenseSquare×DenseSquare)×(Unary×Unary))×(Unary×Unary) =>
    Unary.eqb a.2.2 a.1.2.1) := by fun_prop
  have hv : Poly (fun a : ((DenseSquare×DenseSquare)×(Unary×Unary))×(Unary×Unary) =>
    a.1.1.2.get a.2.1.val a.1.2.2.val) := Poly.denseGet.comp (show Poly (fun a : ((DenseSquare×DenseSquare)×(Unary×Unary))×(Unary×Unary) =>
      (a.1.1.2,(a.2.1,a.1.2.2))) by fun_prop)
  have hw : Poly (fun a : ((DenseSquare×DenseSquare)×(Unary×Unary))×(Unary×Unary) =>
    a.1.1.1.get a.2.1.val a.2.2.val) := Poly.denseGet.comp (show Poly (fun a : ((DenseSquare×DenseSquare)×(Unary×Unary))×(Unary×Unary) =>
      (a.1.1.1,(a.2.1,a.2.2))) by fun_prop)
  exact (Poly.denseBuild hn (hc.cond hv hw)).of_eq (by
    intro a
    apply congrArg (fun A => (⟨a.1.1.dim,A⟩ : DenseSquare))
    funext i j
    simp [Unary.eqb])

lemma cramer_of {d : ℕ} (A B : Matrix (Fin d) (Fin d) ℤ) (i j : Fin d) :
    cramer (DenseSquare.of A) (DenseSquare.of B) i.val j.val=
      DenseSquare.of (A.updateCol i (fun r => B r j)) := by
  unfold cramer DenseSquare.of
  congr 1
  funext r c
  simp [DenseSquare.get,Matrix.updateCol_apply,Fin.ext_iff]

end Runtime
end RationalHitting.StackLanguage


namespace RationalHitting.StackLanguage.Runtime

lemma cramer_det_of {d : ℕ} (A B : Matrix (Fin d) (Fin d) ℤ) (i j : Fin d) :
    (cramer (DenseSquare.of A) (DenseSquare.of B) i.val j.val).val.det=
      (A.updateCol i (fun r => B r j)).det := by
  unfold cramer DenseSquare.of
  apply congrArg Matrix.det
  funext r c
  simp [DenseSquare.get,Matrix.updateCol_apply,Fin.ext_iff]

lemma cramer_encode_of {d : ℕ} (A B : Matrix (Fin d) (Fin d) ℤ) (den : ℤ) (i j : Fin d) :
    encodeRat (Rat.divInt (cramer (DenseSquare.of A) (DenseSquare.of B) i.val j.val).val.det den)=
      encodeRat (Rat.divInt (A.updateCol i (fun r => B r j)).det den) :=
  congrArg (fun z => encodeRat (Rat.divInt z den)) (cramer_det_of A B i j)

end RationalHitting.StackLanguage.Runtime

end OAI