lean/OAI/ModelTheory/Choiceless/Matrix.lean

import OAI.ModelTheory.Choiceless.TableMachine

namespace OAI

namespace CPTSeparation.MatrixProgram

section

open Bounded TableMachine CounterLang

structure Control where
 active : Bool
 member : Bool
 test : Bool
 acc : Scalar
 deriving DecidableEq, Fintype

abbrev Prog := Bounded.Program Control

local infixr:60 " ;; " => Bounded.Program.seq

def ctrl (b : Bool) : Control := ⟨b,false,false,0⟩

def memberCode : Prog :=
 .cell .Cf .a .a (fun c b => {c with member := b}) ;;
 .cell .VB .t .a (fun c b => {c with member := c.member && b})

def coefficientStep : Prog :=
 .cell .Ed .x .x (fun c b => {c with test := b}) ;;
 .cell .I .a .x (fun c b => {c with test := c.test && b}) ;;
 .cell (.Z 1) .y .x (fun c b => {c with acc := c.acc + if c.test && b then 1 else 0}) ;;
 .cell (.Z 2) .y .x (fun c b => {c with acc := c.acc + if c.test && b then 2 else 0}) ;;
 .load (fun c => {c with test := false})

def coefficientCode : Prog :=
 .load (fun c => {c with acc := 0}) ;; .loop .x coefficientStep

def incidentStepX : Prog :=
 .cell .Ed .x .x (fun c b => {c with test := b}) ;;
 .cell .I .a .x (fun c b => {c with test := c.test && b}) ;;
 .cell .EB .y .x (fun c b => {c with test := c.test && b}) ;;
 .load (fun c => {c with active := c.active || (c.member && c.test),test := false})

def incidentStepA : Prog :=
 memberCode ;; .loop .x incidentStepX ;; .load (fun c => {c with member := false})

def incidentCode : Prog := .load (fun _ => ctrl false) ;; .loop .a incidentStepA

def normColumn : Prog := memberCode ;;
 .emit (fun c => some (if c.active && c.member then 1 else 0)) ;;
 .load (fun c => {c with member := false})

def lambdaColumn : Prog := memberCode ;; coefficientCode ;;
 .emit (fun c => some (if c.active && c.member then -c.acc else 0)) ;;
 .load (fun c => {c with member := false,acc := 0})

def muColumn : Prog :=
 .equal .z .y (fun c b => {c with test := b}) ;;
 .emit (fun c => some (if c.active && c.test then 1 else 0)) ;;
 .load (fun c => {c with test := false})

def normRowCode : Prog :=
 .cell .Cf .t .t (fun _ b => ctrl b) ;;
 .loop .a normColumn ;;
 .loop .z (.emit (fun _ => some 0)) ;;
 .emit (fun c => some (if c.active then 1 else 0)) ;;
 .emit (fun _ => none) ;;
 .load (fun _ => ctrl false)

def consRowCode : Prog :=
 incidentCode ;;
 .cell .Cf .t .t (fun c b => {c with active := c.active && b}) ;;
 .cell .Ed .y .y (fun c b => {c with active := c.active && b}) ;;
 .loop .a lambdaColumn ;;
 .loop .z muColumn ;;
 .emit (fun _ => some 0) ;;
 .emit (fun _ => none) ;;
 .load (fun _ => ctrl false)

def program : Prog :=
 .load (fun _ => ctrl false) ;;
 .loop .t normRowCode ;;
 .loop .t (.loop .y consRowCode)

lemma program_wf : program.WF ∅ := by
 simp [program,normRowCode,consRowCode,normColumn,lambdaColumn,muColumn,
   memberCode,coefficientCode,coefficientStep,incidentCode,incidentStepA,incidentStepX,
   Bounded.Program.WF]

def member (rel : Relation) (t a : ℕ) : Bool := rel .Cf a a && rel .VB t a

def contribution (rel : Relation) (y a x : ℕ) : Scalar :=
 if rel .Ed x x && rel .I a x then
   (if rel (.Z 1) y x then 1 else 0)+(if rel (.Z 2) y x then 2 else 0) else 0

def coefficient (N : ℕ) (rel : Relation) (y a : ℕ) : Scalar :=
 ((List.range N).map (contribution rel y a)).sum

def edgeTest (rel : Relation) (y a x : ℕ) : Bool :=
 rel .Ed x x && rel .I a x && rel .EB y x

def incident (N : ℕ) (rel : Relation) (t y : ℕ) : Bool :=
 (List.range N).any fun a => member rel t a && (List.range N).any (edgeTest rel y a)

def normChunk (N : ℕ) (rel : Relation) (t : ℕ) : List Letter :=
 (List.range N).map (fun a => some (if rel .Cf t t && member rel t a then 1 else 0)) ++
 List.replicate N (some 0) ++ [some (if rel .Cf t t then 1 else 0),none]

def consActive (N : ℕ) (rel : Relation) (t y : ℕ) : Bool :=
 (incident N rel t y && rel .Cf t t) && rel .Ed y y

def consChunk (N : ℕ) (rel : Relation) (t y : ℕ) : List Letter :=
 (List.range N).map (fun a => some (if consActive N rel t y && member rel t a then -coefficient N rel y a else 0)) ++
 (List.range N).map (fun z => some (if consActive N rel t y && (z==y) then 1 else 0)) ++ [some 0,none]

def matrix (N : ℕ) (rel : Relation) : List Letter :=
 (List.range N).flatMap (normChunk N rel) ++
 (List.range N).flatMap (fun t => (List.range N).flatMap (consChunk N rel t))

end

section

open Bounded TableMachine CounterLang

lemma interp_seq {V} (a b : Bounded.Program V) (N : ℕ) (rel : Relation) (e) (s) :
 (Bounded.Program.seq a b).interpret N rel e s = b.interpret N rel e (a.interpret N rel e s) := rfl

lemma interp_load {V} (f : V → V) (N : ℕ) (rel : Relation) (e) (s) :
 (Bounded.Program.load f).interpret N rel e s = (f s.1,s.2) := rfl

lemma interp_cell {V} (r i j) (f : V → Bool → V) (N : ℕ) (rel : Relation) (e) (s) :
 (Bounded.Program.cell r i j f).interpret N rel e s = (f s.1 (rel r (e i) (e j)),s.2) := rfl

lemma interp_emit {V} (f : V → Letter) (N : ℕ) (rel : Relation) (e) (s) :
 (Bounded.Program.emit f).interpret N rel e s = (s.1,f s.1::s.2) := rfl

lemma memberCode_spec (N : ℕ) (rel : Relation) (e : Index → ℕ) (c : Control) (out) :
 memberCode.interpret N rel e (c,out) = ({c with member := member rel (e .t) (e .a)},out) := rfl

lemma coefficientStep_spec (N : ℕ) (rel : Relation) (e : Index → ℕ) (act mem : Bool) (acc : Scalar) (out) :
 coefficientStep.interpret N rel e (⟨act,mem,false,acc⟩,out) =
   (⟨act,mem,false,acc+contribution rel (e .y) (e .a) (e .x)⟩,out) := by
 simp only [coefficientStep,Bounded.Program.interpret,contribution]
 by_cases h : (rel .Ed (e .x) (e .x) && rel .I (e .a) (e .x)) = true <;>
   simp only [Bool.and_eq_true] at h ⊢ <;> simp [h,add_assoc]

lemma coefficient_fold_spec (N : ℕ) (rel : Relation) (e : Index → ℕ)
    (ls : List ℕ) (act mem : Bool) (acc : Scalar) (out) :
 ls.foldl (fun s k => coefficientStep.interpret N rel (Function.update e .x k) s)
    (⟨act,mem,false,acc⟩,out) =
   (⟨act,mem,false,acc+(ls.map (contribution rel (e .y) (e .a))).sum⟩,out) := by
 induction ls generalizing acc with
 | nil => simp
 | cons a ls ih =>
   rw [List.foldl_cons,coefficientStep_spec]
   simp only [Function.update_self,Function.update_of_ne (show Index.y ≠ .x by decide),
      Function.update_of_ne (show Index.a ≠ .x by decide)]
   rw [ih]
   simp [add_assoc]

lemma coefficientCode_spec (N : ℕ) (rel : Relation) (e : Index → ℕ) (act mem : Bool) (acc : Scalar) (out) :
 coefficientCode.interpret N rel e (⟨act,mem,false,acc⟩,out) =
   (⟨act,mem,false,coefficient N rel (e .y) (e .a)⟩,out) := by
 simp only [coefficientCode,Bounded.Program.interpret]
 exact (coefficient_fold_spec N rel e (List.range N) act mem 0 out).trans (by simp [coefficient])

lemma incidentStepX_spec (N : ℕ) (rel : Relation) (e : Index → ℕ) (act mem : Bool) (out) :
 incidentStepX.interpret N rel e (⟨act,mem,false,0⟩,out) =
   (⟨act || (mem && edgeTest rel (e .y) (e .a) (e .x)),mem,false,0⟩,out) := rfl

lemma incident_fold_x (N : ℕ) (rel : Relation) (e : Index → ℕ)
    (ls : List ℕ) (act mem : Bool) (out) :
 ls.foldl (fun s k => incidentStepX.interpret N rel (Function.update e .x k) s)
    (⟨act,mem,false,0⟩,out) =
   (⟨act || (mem && ls.any (edgeTest rel (e .y) (e .a))),mem,false,0⟩,out) := by
 induction ls generalizing act with
 | nil => simp
 | cons a ls ih =>
   rw [List.foldl_cons,incidentStepX_spec]
   simp only [Function.update_self,Function.update_of_ne (show Index.y ≠ .x by decide),
      Function.update_of_ne (show Index.a ≠ .x by decide)]
   rw [ih]
   cases act <;> cases mem <;> simp []

lemma incidentStepA_spec (N : ℕ) (rel : Relation) (e : Index → ℕ) (act : Bool) (out) :
 incidentStepA.interpret N rel e (ctrl act,out) =
   (ctrl (act || (member rel (e .t) (e .a) && (List.range N).any (edgeTest rel (e .y) (e .a)))),out) := by
 simp only [incidentStepA,interp_seq,memberCode_spec,ctrl]

 simp only [Bounded.Program.interpret]
 rw [incident_fold_x]

lemma incident_fold_a (N : ℕ) (rel : Relation) (e : Index → ℕ)
    (ls : List ℕ) (act : Bool) (out) :
 ls.foldl (fun s k => incidentStepA.interpret N rel (Function.update e .a k) s)
    (ctrl act,out) =
   (ctrl (act || ls.any (fun a => member rel (e .t) a &&
     (List.range N).any (edgeTest rel (e .y) a))),out) := by
 induction ls generalizing act with
 | nil => simp
 | cons a ls ih =>
   rw [List.foldl_cons,incidentStepA_spec]
   simp only [Function.update_self,Function.update_of_ne (show Index.y ≠ .a by decide),
      Function.update_of_ne (show Index.t ≠ .a by decide)]
   rw [ih]
   simp [Bool.or_assoc]

lemma incidentCode_spec (N : ℕ) (rel : Relation) (e : Index → ℕ) (c : Control) (out) :
 incidentCode.interpret N rel e (c,out) =
   (ctrl (incident N rel (e .t) (e .y)),out) := by
 simp only [incidentCode,Bounded.Program.interpret]
 rw [incident_fold_a]
 simp [incident]

lemma normColumn_spec (N : ℕ) (rel : Relation) (e : Index → ℕ) (act : Bool) (out) :
 normColumn.interpret N rel e (ctrl act,out) =
   (ctrl act,some (if act && member rel (e .t) (e .a) then 1 else 0)::out) := by
 simp only [normColumn,Bounded.Program.interpret,memberCode_spec]
 rfl

lemma lambdaColumn_spec (N : ℕ) (rel : Relation) (e : Index → ℕ) (act : Bool) (out) :
 lambdaColumn.interpret N rel e (ctrl act,out) =
   (ctrl act,some (if act && member rel (e .t) (e .a) then -coefficient N rel (e .y) (e .a) else 0)::out) := by
 simp only [lambdaColumn,interp_seq,memberCode_spec,ctrl]
 rw [coefficientCode_spec]
 rfl

lemma muColumn_spec (N : ℕ) (rel : Relation) (e : Index → ℕ) (act : Bool) (out) :
 muColumn.interpret N rel e (ctrl act,out) =
   (ctrl act,some (if act && (e .z == e .y) then 1 else 0)::out) := rfl

lemma normRowCode_spec (N : ℕ) (rel : Relation) (e : Index → ℕ) (c : Control) (out) :
 normRowCode.interpret N rel e (c,out) =
   (ctrl false,(normChunk N rel (e .t)).reverse++out) := by
 have ha := loop_emits N rel normColumn .a e (ctrl (rel .Cf (e .t) (e .t)))
   (fun a => [some (if rel .Cf (e .t) (e .t) && member rel (e .t) a then 1 else 0)])
   (by intro k hk o; simpa [Function.update] using normColumn_spec N rel (Function.update e .a k) (rel .Cf (e .t) (e .t)) o) out
 have hz (o) := loop_emits N rel (.emit (fun _ : Control => some 0)) .z e (ctrl (rel .Cf (e .t) (e .t)))
   (fun _ => [some 0]) (by intro k hk z; rfl) o
 simp only [normRowCode,interp_seq,interp_cell]
 rw [ha,hz]
 simp [interp_emit,interp_load,normChunk,List.reverse_append,List.append_assoc,← List.map_eq_flatMap,ctrl]

lemma consRowCode_spec (N : ℕ) (rel : Relation) (e : Index → ℕ) (c : Control) (out) :
 consRowCode.interpret N rel e (c,out) =
   (ctrl false,(consChunk N rel (e .t) (e .y)).reverse++out) := by
 let act := consActive N rel (e .t) (e .y)
 have ha (o) := loop_emits N rel lambdaColumn .a e (ctrl act)
   (fun a => [some (if act && member rel (e .t) a then -coefficient N rel (e .y) a else 0)])
   (by intro k hk z; simpa [Function.update] using lambdaColumn_spec N rel (Function.update e .a k) act z) o
 have hz (o) := loop_emits N rel muColumn .z e (ctrl act)
   (fun z => [some (if act && (z==e .y) then 1 else 0)])
   (by intro k hk z; simpa [Function.update] using muColumn_spec N rel (Function.update e .z k) act z) o
 simp only [consRowCode,interp_seq,incidentCode_spec,interp_cell,ctrl]
 dsimp [ctrl,act,consActive] at ha hz
 rw [ha,hz]
 simp [interp_emit,interp_load,consChunk,consActive,List.reverse_append,List.append_assoc,← List.map_eq_flatMap]

lemma program_spec (N : ℕ) (rel : Relation) (e : Index → ℕ) (c : Control) (out) :
 program.interpret N rel e (c,out) = (ctrl false,(matrix N rel).reverse++out) := by
 have hn := loop_emits N rel normRowCode .t e (ctrl false) (normChunk N rel)
   (by intro k hk o; simpa [Function.update] using normRowCode_spec N rel (Function.update e .t k) (ctrl false) o) out
 have hc (o) := loop_emits N rel (.loop .y consRowCode) .t e (ctrl false)
   (fun t => (List.range N).flatMap (consChunk N rel t))
   (by
     intro t ht o
     apply loop_emits
     intro y hy z
     simpa [Function.update] using consRowCode_spec N rel
       (Function.update (Function.update e .t t) .y y) (ctrl false) z) o
 simp only [program,interp_seq,interp_load]
 rw [hn,hc]
 simp [matrix,List.reverse_append,List.append_assoc]

end

open Bounded TableMachine

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

lemma range_map_eq {α} (N : ℕ) (f : ℕ → α) :
 (List.range N).map f = List.ofFn (fun i : Fin N => f i) := by
 rw [range_eq_finRange_map,List.map_map, List.ofFn_eq_map]
 rfl

lemma range_flatMap_eq {α} (N : ℕ) (f : ℕ → List α) :
 (List.range N).flatMap f = (List.finRange N).flatMap (fun i : Fin N => f i) := by
 rw [range_eq_finRange_map,List.flatMap_map]

lemma ofFn_addCases {α : Type} {m n : ℕ} (f : Fin m → α) (g : Fin n → α) :
 List.ofFn (Fin.addCases f g) = List.ofFn f ++ List.ofFn g := by
 have he : Fin.addCases f g = Fin.append f g := by
   funext i
   refine Fin.addCases (fun j => ?_) (fun j => ?_) i <;> simp
 rw [he,List.ofFn_fin_append]

lemma sum_scalar_three (f : Scalar → Scalar) : (∑ δ, f δ) = f 0+f 1+f 2 := by
 have h : (Finset.univ : Finset Scalar) = {0,1,2} := by decide
 change Finset.sum Finset.univ f = _
 rw [h]
 rw [Finset.sum_insert (by decide : (0:Scalar) ∉ ({1,2} : Finset Scalar)),
   Finset.sum_insert (by decide : (1:Scalar) ∉ ({2} : Finset Scalar)),Finset.sum_singleton]
 ring

variable {N : ℕ} (S : OrderedQuery.Data N) (rel : Relation)

variable (reads : ∀ (r : Symbol) (a b : Fin N), rel r a b = S.rel r a b)

include reads

lemma contribution_eq (y a x : Fin N) :
 contribution rel y a x = if S.rel .Ed x x ∧ S.rel .I a x then
   ∑ δ : Scalar, if S.rel (.Z δ) y x then δ else 0 else 0 := by
 simp only [contribution,reads,Bool.and_eq_true,sum_scalar_three]
 simp

lemma coefficient_eq_ordered (y a : Fin N) : coefficient N rel y a = OrderedQuery.coefficient S y a := by
 rw [coefficient,range_map_eq]
 simp only [contribution_eq S rel reads,List.sum_ofFn,OrderedQuery.coefficient]

lemma incident_eq_ordered (t y : Fin N) : incident N rel t y = OrderedQuery.incident S t y := by
 simp only [incident,range_eq_finRange_map,List.any_map,Function.comp_def,member,edgeTest,
   reads,OrderedQuery.incident]

lemma normChunk_eq (t : Fin N) : normChunk N rel t =
 (SerialGaussian.Row.encode (OrderedQuery.normalizationRow S t)).coeff.map some ++
   [some (OrderedQuery.normalizationRow S t).rhs,none] := by
 have hr : ∀ (a : Fin N), member rel t a = (S.rel .Cf a a && S.rel .VB t a) := by
   intro a; simp [member,reads]
 simp only [normChunk,reads,range_map_eq,SerialGaussian.Row.encode,OrderedQuery.normalizationRow]
 by_cases ht : S.rel .Cf t t = true
 · simp only [ht,ite_true,Bool.true_and,hr]
   simp [ofFn_addCases,List.map_ofFn,List.map_append,Function.comp_def]
 · have hf : S.rel .Cf t t = false := Bool.eq_false_iff.mpr ht
   simp [hf,]

lemma consActive_eq (t y : Fin N) : consActive N rel t y =
 (S.rel .Cf t t && S.rel .Ed y y && OrderedQuery.incident S t y) := by
 rw [consActive,incident_eq_ordered S rel reads,reads,reads]
 cases S.rel .Cf t t <;> cases S.rel .Ed y y <;> cases OrderedQuery.incident S t y <;> rfl

lemma consChunk_eq (t y : Fin N) : consChunk N rel t y =
 (SerialGaussian.Row.encode (OrderedQuery.consistencyRow S t y)).coeff.map some ++
   [some (OrderedQuery.consistencyRow S t y).rhs,none] := by
 have hr : ∀ (a : Fin N), member rel t a = (S.rel .Cf a a && S.rel .VB t a) := by
   intro a; simp [member,reads]
 simp only [consChunk,consActive_eq S rel reads,range_map_eq,
   SerialGaussian.Row.encode,OrderedQuery.consistencyRow]
 by_cases ht : (S.rel .Cf t t && S.rel .Ed y y && OrderedQuery.incident S t y) = true
 · simp only [ht,ite_true,Bool.true_and,hr,coefficient_eq_ordered S rel reads]
   simp [ofFn_addCases,List.map_append,List.map_ofFn,Function.comp_def,beq_iff_eq,Fin.val_inj]
 · have hf : (S.rel .Cf t t && S.rel .Ed y y && OrderedQuery.incident S t y) = false := Bool.eq_false_iff.mpr ht
   simp [hf,]

lemma matrix_eq_payload : matrix N rel = SerialGaussian.payload (SerialGaussian.queryRows S) := by
 simp only [matrix,range_flatMap_eq,normChunk_eq S rel reads,consChunk_eq S rel reads,
   SerialGaussian.queryRows,OrderedQuery.rows,SerialGaussian.payload,List.map_append,
   List.flatMap_append,List.flatMap_map,List.map_flatMap,List.flatMap_assoc]
 rfl

omit reads in
lemma matrix_input {N : ℕ} (S : OrderedQuery.Data N) :
 matrix N (readTable N (tableInput S)) = SerialGaussian.payload (SerialGaussian.queryRows S) :=
 matrix_eq_payload S _ (readTable_input S)

end CPTSeparation.MatrixProgram

end OAI