math / data /lean /OAI /ModelTheory /Choiceless /Matrix.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
16.7 kB
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