lean/OAI/Combinatorics/IndependentSets/Reduction/FloydLoop.lean

import Mathlib
import OAI.Combinatorics.IndependentSets.PCP.BoundedIteration
import OAI.Combinatorics.IndependentSets.Reduction.StoredFloyd

namespace OAI

namespace LargeIndependentSets.StoredFloyd
open ShortestPaths
open IndependentSetsCut.CounterMachine
open IndependentSetsGames.Foundations.Complexity
open Turing

structure Input (B : ℕ) where
  n : ℕ
  matrix : Capped.Matrix B n

def Input.initial {B : ℕ} (a : Input B) : State B := ⟨a.n,0,a.matrix⟩
def Input.bits {B : ℕ} (a : Input B) : List Bool :=
  BoundedIteration.counted Input.n State.bits Input.initial a

def Input.output {B : ℕ} (a : Input B) : State B := ⟨a.n,a.n,a.matrix.allPairs⟩

lemma run_append {B n : ℕ} (a : Capped.Matrix B n) (xs ys : List (Fin n)) :
    a.run (xs++ys) = (a.run xs).run ys := by
  induction xs generalizing a with
  | nil => rfl
  | cons x xs ih => exact ih (a.pivot x)

lemma iterate_initial {B : ℕ} (a : Input B) (i : ℕ) (hi : i≤a.n) :
    State.step^[i] a.initial = ⟨a.n,i,a.matrix.run ((List.finRange a.n).take i)⟩ := by
  induction i with
  | zero => rfl
  | succ i ih =>
    have hn : i<a.n := hi
    rw [Function.iterate_succ_apply',ih hn.le]
    have hl : i<(List.finRange a.n).length := by simpa using hn
    rw [List.take_succ_eq_append_getElem hl]
    simp only [List.getElem_finRange,run_append,Capped.Matrix.run]
    simp only [State.step,dite_eq_left hn]
    congr 2

lemma iterate_output {B : ℕ} (a : Input B) : State.step^[a.n] a.initial = a.output := by
  rw [iterate_initial a a.n le_rfl]
  simp only [Input.output,Capped.Matrix.allPairs]
  rw [List.take_of_length_le (by simp)]

lemma entry_le {B n : ℕ} (a : Capped.Matrix B n) (i j : ℕ) : entry a i j≤B+1 := by
  unfold entry
  split
  · split
    · exact (a.get _ _).bound
    · omega
  · omega

lemma value_le {B : ℕ} (s : State B) (i : ℕ) : s.value i ≤ s.n+s.k+B+1 := by
  unfold State.value
  split
  · omega
  · split
    · omega
    · have := entry_le s.matrix ((i-2)/s.n) ((i-2)%s.n); omega

lemma bits_length_le {B : ℕ} (s : State B) :
    s.bits.length ≤ (2+s.n*s.n)*(s.n+s.k+B+2) := by
  rw [State.bits,UnaryTables.words_length]
  unfold UnaryTables.offset
  calc
    _ ≤ ∑ _ ∈ Finset.range (2+s.n*s.n), (s.n+s.k+B+2) := by
      apply Finset.sum_le_sum
      intro i _hi
      have := value_le s i
      omega
    _ = _ := by simp

noncomputable def lengthPolynomial (B : ℕ) : Polynomial ℕ :=
  (2+Polynomial.X*Polynomial.X)*(2*Polynomial.X+Polynomial.C (B+2))

lemma lengthPolynomial_eval (B N : ℕ) : (lengthPolynomial B).eval N = (2+N*N)*(2*N+B+2) := by
  simp [lengthPolynomial,Nat.add_assoc]

lemma intermediate_bound {B : ℕ} (a : Input B) (i : ℕ) (hi : i≤a.n) :
    (State.step^[i] a.initial).bits.length ≤ (lengthPolynomial B).eval a.bits.length := by
  rw [iterate_initial a i hi,lengthPolynomial_eval]
  have hn : a.n≤a.bits.length := BoundedIteration.count_le Input.n State.bits Input.initial a
  have hk : i≤a.bits.length := hi.trans hn
  apply (bits_length_le _).trans
  dsimp only
  gcongr; omega

noncomputable def rawCertificate (B : ℕ) :
    TM2ComputableInPolyTime Input.bits State.bits
      (fun a : Input B => State.step^[a.n] a.initial) :=
  BoundedIteration.certificate State.bits State.step Input.initial Input.n (body B)
    (lengthPolynomial B) intermediate_bound

noncomputable def certificate (B : ℕ) :
    TM2ComputableInPolyTime Input.bits State.bits (@Input.output B) where
  tm := (rawCertificate B).tm
  inputAlphabet := (rawCertificate B).inputAlphabet
  outputAlphabet := (rawCertificate B).outputAlphabet
  time := (rawCertificate B).time
  outputsFun a := by
    simpa only [iterate_output] using (rawCertificate B).outputsFun a

lemma certificate_finiteAlphabet (B : ℕ) (k : (certificate B).tm.K) :
    Finite ((certificate B).tm.Γ k) :=
  BoundedIteration.certificate_finiteAlphabet State.bits State.step Input.initial Input.n
    (body B) (lengthPolynomial B) intermediate_bound (body_finiteAlphabet B) k

lemma output_threshold (B : ℕ) {n : ℕ} (a : ShortestPaths.Matrix n) (i j : Fin n)
    (t : ℕ) (ht : t≤B) :
    ((Input.output (⟨n,Capped.Matrix.ofInteger B a⟩ : Input B)).matrix.get i j).val≤t ↔
      a.allPairs.get i j ≤ (t : ℕ∞) := Capped.Matrix.threshold_exact B a i j ht
end LargeIndependentSets.StoredFloyd
namespace LargeIndependentSets.FloydCarry
open IndependentSetsCut.CounterMachine
open ShortestPaths
open Turing
open scoped BigOperators
open IndependentSetsGames.Foundations.Complexity

structure State (B : ℕ) where
  core : StoredFloyd.State B
  payload : List ℕ

def State.value {B : ℕ} (s : State B) (w : ℕ) : ℕ :=
  if w<2+s.core.n*s.core.n then s.core.value w
  else if w=2+s.core.n*s.core.n then s.payload.length
  else s.payload[w-(3+s.core.n*s.core.n)]?.getD 0

def State.count {B : ℕ} (s : State B) := 3+s.core.n*s.core.n+s.payload.length
def State.bits {B : ℕ} (s : State B) := UnaryTables.words s.value s.count

def State.step {B : ℕ} (s : State B) : State B := ⟨s.core.step,s.payload⟩

lemma read_core {B : ℕ} (s : State B) (w : ℕ) (hw : w<2+s.core.n*s.core.n) :
    Expr.wordValue s.bits w=s.core.value w := by
  rw [State.bits,UnaryTables.wordValue_words _ _ _ (by unfold State.count; omega)]
  simp [State.value,hw]
@[simp] lemma read_n {B : ℕ} (s : State B) : Expr.wordValue s.bits 0=s.core.n := by
  rw [read_core _ _ (by omega)]; simp [StoredFloyd.State.value]
@[simp] lemma read_k {B : ℕ} (s : State B) : Expr.wordValue s.bits 1=s.core.k := by
  rw [read_core _ _ (by omega)]; simp [StoredFloyd.State.value]
@[simp] lemma read_count {B : ℕ} (s : State B) :
    Expr.wordValue s.bits (2+s.core.n*s.core.n)=s.payload.length := by
  rw [State.bits,UnaryTables.wordValue_words _ _ _ (by unfold State.count; omega)]
  simp [State.value]
lemma read_payload {B : ℕ} (s : State B) (w : ℕ) (hw : w<s.payload.length) :
    Expr.wordValue s.bits (3+s.core.n*s.core.n+w)=s.payload[w] := by
  rw [State.bits,UnaryTables.wordValue_words _ _ _ (by unfold State.count; omega)]
  simp [State.value,show ¬3+s.core.n*s.core.n+w<2+s.core.n*s.core.n by omega,
    show 3+s.core.n*s.core.n+w ≠ 2+s.core.n*s.core.n by omega,
    show 3+s.core.n*s.core.n+w-(3+s.core.n*s.core.n)=w by omega,hw]

lemma read_cell {B : ℕ} (s : State B) (i j : Fin s.core.n) :
    Expr.wordValue s.bits (2+i.val*s.core.n+j.val)=(s.core.matrix.get i j).val := by
  have hlt : i.val*s.core.n+j.val<s.core.n*s.core.n := by
    calc
      _ < (i.val+1)*s.core.n := by nlinarith [j.isLt]
      _ ≤ _ := Nat.mul_le_mul_right _ i.isLt
  rw [read_core _ _ (by omega)]
  rw [← StoredFloyd.read_cell s.core i j,StoredFloyd.State.bits,
    UnaryTables.wordValue_words _ _ _ (by omega)]

@[simp] lemma sizeExpr_eval {B : ℕ} (s : State B) (a : ℕ → ℕ) :
    StoredFloyd.sizeExpr.eval s.bits a=s.core.n := by simp [StoredFloyd.sizeExpr,Expr.eval]
@[simp] lemma pivotExpr_eval {B : ℕ} (s : State B) (a : ℕ → ℕ) :
    StoredFloyd.pivotExpr.eval s.bits a=s.core.k := by simp [StoredFloyd.pivotExpr,Expr.eval]
@[simp] lemma coreCount_eval {B : ℕ} (s : State B) (a : ℕ → ℕ) :
    StoredFloyd.countExpr.eval s.bits a=2+s.core.n*s.core.n := by simp [StoredFloyd.countExpr,Expr.eval]

def payloadCountExpr : Expr := Expr.word StoredFloyd.countExpr

def countExpr : Expr := .add (.add StoredFloyd.countExpr (.const 1)) payloadCountExpr

def valueExpr (B : ℕ) : Expr :=
  Expr.cond (Expr.lt (.arg 0) StoredFloyd.countExpr) (StoredFloyd.valueExpr B) (Expr.word (.arg 0))

lemma coreValue_eval {B : ℕ} (s : State B) (w : ℕ) (hw : w<2+s.core.n*s.core.n) :
    (StoredFloyd.valueExpr B).eval s.bits (fun _ => w)=s.core.step.value w := by
  by_cases hw0 : w=0
  · subst w; simp [StoredFloyd.valueExpr,Expr.eval,StoredFloyd.State.value,StoredFloyd.State.step]
  by_cases hw1 : w=1
  · subst w; simp [StoredFloyd.valueExpr,Expr.eval,StoredFloyd.State.value,StoredFloyd.State.step]
  have hw2 : 2 ≤ w := by omega
  have ht : w-2<s.core.n*s.core.n := by omega
  have hn : 0<s.core.n := by nlinarith
  have hi : (w-2)/s.core.n<s.core.n := (Nat.div_lt_iff_lt_mul hn).mpr ht
  have hj : (w-2)%s.core.n<s.core.n := Nat.mod_lt _ hn
  let i : Fin s.core.n := ⟨(w-2)/s.core.n,hi⟩
  let j : Fin s.core.n := ⟨(w-2)%s.core.n,hj⟩
  have hr : StoredFloyd.rowExpr.eval s.bits (fun _ => w)=i.val := by simp [StoredFloyd.rowExpr,Expr.eval,i]
  have hc : StoredFloyd.colExpr.eval s.bits (fun _ => w)=j.val := by simp [StoredFloyd.colExpr,Expr.eval,j]
  simp only [StoredFloyd.valueExpr,Expr.cond_eval,Expr.equal_eval,Expr.eval,hw0,hw1,ite_false,
    ne_eq,not_true_eq_false,
    sizeExpr_eval,pivotExpr_eval,Expr.lt_eval,StoredFloyd.minExpr_eval,StoredFloyd.cellExpr_eval,hr,hc]
  by_cases hk : s.core.k<s.core.n
  · let k : Fin s.core.n := ⟨s.core.k,hk⟩
    simp only [hk,ite_true,Nat.one_ne_zero,not_false_eq_true]
    rw [read_cell s i j,show s.core.k=k.val from rfl,read_cell s i k,read_cell s k j]
    simp [StoredFloyd.State.value,StoredFloyd.State.step,hw0,hw1,hk,
      StoredFloyd.entry,hi,hj,Capped.Matrix.pivot,Capped.Matrix.get,pivot,Capped.min_val,Capped.add_val,i,j,k]
  · simp only [hk,ite_false,not_true_eq_false,read_cell]
    simp [StoredFloyd.State.value,StoredFloyd.State.step,hw0,hw1,hk,StoredFloyd.entry,hi,hj,i,j]

@[simp] lemma payloadCount_eval {B : ℕ} (s : State B) (a : ℕ → ℕ) :
    payloadCountExpr.eval s.bits a=s.payload.length := by simp [payloadCountExpr,Expr.word_eval]
@[simp] lemma countExpr_eval {B : ℕ} (s : State B) (a : ℕ → ℕ) :
    countExpr.eval s.bits a=s.count := by simp [countExpr,Expr.eval,State.count]; omega

lemma valueExpr_eval {B : ℕ} (s : State B) (w : ℕ) (hw : w<s.count) :
    (valueExpr B).eval s.bits (fun _ => w)=s.step.value w := by
  simp only [valueExpr,Expr.cond_eval,Expr.lt_eval,Expr.eval,coreCount_eval]
  by_cases hc : w<2+s.core.n*s.core.n
  · simp [hc,coreValue_eval s w hc,State.value,State.step,StoredFloyd.State.step]
  · simp only [hc,ite_false,ne_eq,not_true_eq_false,Expr.word_eval,Expr.eval]
    rw [State.bits,UnaryTables.wordValue_words _ _ _ hw]
    simp only [State.value,State.step,StoredFloyd.State.step,hc,ite_false]
    rfl

lemma body_spec {B : ℕ} (s : State B) :
    UnaryTables.words (fun w => (valueExpr B).eval s.bits (fun _ => w))
      (countExpr.eval s.bits (fun _ => 0))=s.step.bits := by
  rw [countExpr_eval]
  exact UnaryTables.words_congr (valueExpr_eval s)

noncomputable def body (B : ℕ) : TM2ComputableInPolyTime State.bits State.bits (@State.step B) :=
  UnaryTables.encodedComputer _ _ _ countExpr (valueExpr B) body_spec
lemma body_finiteAlphabet (B : ℕ) : MachineFiniteAlphabet.FiniteAlphabet (body B).tm :=
  UnaryTables.encodedComputer_finiteAlphabet _ _ _ _ _ _

structure Input (B : ℕ) where
  core : StoredFloyd.Input B
  payload : List ℕ

def Input.initial {B : ℕ} (a : Input B) : State B := ⟨a.core.initial,a.payload⟩
def Input.count {B : ℕ} (a : Input B) := a.core.n
def Input.bits {B : ℕ} (a : Input B) : List Bool :=
  BoundedIteration.counted Input.count State.bits Input.initial a

def Input.output {B : ℕ} (a : Input B) : State B := ⟨a.core.output,a.payload⟩

lemma iterate_pair {B : ℕ} (s : State B) (i : ℕ) :
    State.step^[i] s=⟨StoredFloyd.State.step^[i] s.core,s.payload⟩ := by
  induction i with
  | zero => rfl
  | succ i ih => rw [Function.iterate_succ_apply',ih,Function.iterate_succ_apply']; rfl

lemma iterate_output {B : ℕ} (a : Input B) : State.step^[a.count] a.initial=a.output := by
  rw [iterate_pair]
  dsimp only [Input.initial,Input.count,Input.output]
  rw [StoredFloyd.iterate_output]

lemma wordValue_le_length (s : List Bool) (w : ℕ) : Expr.wordValue s w ≤ s.length := by
  unfold Expr.wordValue
  calc
    _ ≤ ∑ _ ∈ Finset.range s.length, (1:ℕ) := by
      apply Finset.sum_le_sum
      intro i _hi
      unfold Expr.bitValue
      split <;> split <;> simp
    _ = _ := by simp

lemma initial_length_le {B : ℕ} (a : Input B) : a.initial.bits.length≤a.bits.length := by
  simp [Input.bits,BoundedIteration.counted]

lemma payload_length_le {B : ℕ} (a : Input B) : a.payload.length≤a.bits.length := by
  change a.initial.payload.length ≤ a.bits.length
  rw [← read_count a.initial]
  exact (wordValue_le_length _ _).trans (initial_length_le a)

lemma payload_value_le {B : ℕ} (a : Input B) (w : ℕ) :
    a.payload[w]?.getD 0≤a.bits.length := by
  by_cases hw : w<a.payload.length
  · rw [List.getElem?_eq_getElem hw,Option.getD_some]
    change a.initial.payload[w] ≤ a.bits.length
    rw [← read_payload a.initial w hw]
    exact (wordValue_le_length _ _).trans (initial_length_le a)
  · simp [List.getElem?_eq_none (by omega : a.payload.length≤w)]

lemma bits_length_le {B : ℕ} (s : State B) (N : ℕ)
    (hn : s.core.n≤N) (hk : s.core.k≤N) (hc : s.payload.length≤N)
    (hp : ∀ w : ℕ, s.payload[w]?.getD 0≤N) :
    s.bits.length≤(3+N*N+N)*(2*N+B+2) := by
  rw [State.bits,UnaryTables.words_length]
  unfold UnaryTables.offset
  calc
    _ ≤ ∑ _ ∈ Finset.range s.count, (2*N+B+2) := by
      apply Finset.sum_le_sum
      intro w _hw
      have hv : s.value w≤2*N+B+1 := by
        unfold State.value
        split
        · have := StoredFloyd.value_le s.core w; omega
        · split
          · omega
          · have := hp (w-(3+s.core.n*s.core.n)); omega
      omega
    _ = s.count*(2*N+B+2) := by simp
    _ ≤ _ := by unfold State.count; gcongr

noncomputable def lengthPolynomial (B : ℕ) : Polynomial ℕ :=
  (3+Polynomial.X*Polynomial.X+Polynomial.X)*(2*Polynomial.X+Polynomial.C (B+2))

lemma lengthPolynomial_eval (B N : ℕ) :
    (lengthPolynomial B).eval N=(3+N*N+N)*(2*N+B+2) := by
  simp [lengthPolynomial,Nat.add_assoc]

lemma intermediate_bound {B : ℕ} (a : Input B) (i : ℕ) (hi : i≤a.count) :
    (State.step^[i] a.initial).bits.length≤(lengthPolynomial B).eval a.bits.length := by
  have hn : a.core.n≤a.bits.length :=
    BoundedIteration.count_le Input.count State.bits Input.initial a
  rw [iterate_pair]
  dsimp only [Input.initial]
  rw [StoredFloyd.iterate_initial a.core i hi,lengthPolynomial_eval]
  apply bits_length_le
  · exact hn
  · exact hi.trans hn
  · exact payload_length_le a
  · exact payload_value_le a

noncomputable def rawCertificate (B : ℕ) :
    TM2ComputableInPolyTime Input.bits State.bits
      (fun a : Input B => State.step^[a.count] a.initial) :=
  BoundedIteration.certificate State.bits State.step Input.initial Input.count (body B)
    (lengthPolynomial B) intermediate_bound

noncomputable def certificate (B : ℕ) :
    TM2ComputableInPolyTime Input.bits State.bits (@Input.output B) where
  tm := (rawCertificate B).tm
  inputAlphabet := (rawCertificate B).inputAlphabet
  outputAlphabet := (rawCertificate B).outputAlphabet
  time := (rawCertificate B).time
  outputsFun a := by simpa only [iterate_output] using (rawCertificate B).outputsFun a

lemma certificate_finiteAlphabet (B : ℕ) (k : (certificate B).tm.K) :
    Finite ((certificate B).tm.Γ k) :=
  BoundedIteration.certificate_finiteAlphabet State.bits State.step Input.initial Input.count
    (body B) (lengthPolynomial B) intermediate_bound (body_finiteAlphabet B) k

end LargeIndependentSets.FloydCarry

end OAI