| import OAI.Computability.RationalHitting.MatrixComputation |
|
|
| namespace OAI |
|
|
| namespace RationalHitting.StackLanguage |
|
|
| lemma range_flatMap_to_finRange {A : Type} (n : ℕ) (f : ℕ → List A) : |
| (List.range n).flatMap f=(List.finRange n).flatMap (fun i => f i.val) := by |
| rw [←finRange_map_val,List.flatMap_map] |
|
|
| namespace Poly |
| variable {A B : Type} [Coding A] [Coding B] |
|
|
| theorem tabulateUp {n : A → ℕ} {f : A×Unary → B} |
| (hn : Poly (fun a => Unary.mk (n a))) (hf : Poly f) : |
| Poly (fun a => (List.range (n a)).map (fun i => f (a,⟨i⟩))) := |
| hf.tabulate.comp (hn.pair (show Poly (fun a : A => a) from id)) |
|
|
| theorem flatMapUp {n : A → ℕ} {f : A×Unary → List B} |
| (hn : Poly (fun a => Unary.mk (n a))) (hf : Poly f) : |
| Poly (fun a => (List.range (n a)).flatMap (fun i => f (a,⟨i⟩))) := |
| (listFlatten.comp (tabulateUp hn hf)).of_eq (by intro a;rw [List.flatMap_def]) |
|
|
| theorem wordRange {n : A → ℕ} {f : A×Unary → BitWord} |
| (hn : Poly (fun a => Unary.mk (n a))) (hf : Poly f) : |
| Poly (fun a => BitWord.mk ((List.range (n a)).flatMap (fun i => (f (a,⟨i⟩)).val))) := |
| (wordConcat.comp (tabulateUp hn hf)).of_eq (by intro a;simp [List.flatMap_map]) |
| end Poly |
| end RationalHitting.StackLanguage |
|
|
|
|
| namespace RationalHitting.StackLanguage |
| namespace Runtime |
|
|
| abbrev MatrixWordArgs := (DenseSquare×DenseSquare)×ℤ |
|
|
| def matrixWord (A B : DenseSquare) (den : ℤ) : BitWord := |
| ⟨(List.range A.dim).flatMap fun i => |
| (List.range A.dim).flatMap fun j => |
| encodeRat (Rat.divInt (cramer A B i j).val.det den)⟩ |
|
|
| @[fun_prop] theorem matrixWord_poly : Poly (fun a : MatrixWordArgs => matrixWord a.1.1 a.1.2 a.2) := by |
| have hc : Poly (fun a : (MatrixWordArgs×Unary)×Unary => |
| cramer a.1.1.1.1 a.1.1.1.2 a.1.2.val a.2.val) := |
| cramer_poly.comp (show Poly (fun a : (MatrixWordArgs×Unary)×Unary => |
| (a.1.1.1,(a.1.2,a.2))) by fun_prop) |
| have hv := Poly.rationalEncode.comp ((Poly.denseDet.comp hc).pair |
| (show Poly (fun a : (MatrixWordArgs×Unary)×Unary => a.1.1.2) by fun_prop)) |
| have hr := Poly.wordRange (Poly.denseDim.comp (show Poly (fun a : MatrixWordArgs×Unary => a.1.1.1) by fun_prop)) hv |
| exact Poly.wordRange (Poly.denseDim.comp (show Poly (fun a : MatrixWordArgs => a.1.1) by fun_prop)) hr |
|
|
| lemma matrixWord_of {d : ℕ} (A B : Matrix (Fin d) (Fin d) ℤ) (den : ℤ) : |
| (matrixWord (DenseSquare.of A) (DenseSquare.of B) den).val= |
| (List.finRange d).flatMap (fun i => (List.finRange d).flatMap (fun j => |
| encodeRat (Rat.divInt (A.updateCol i (fun r => B r j)).det den))) := by |
| unfold matrixWord |
| change (List.range d).flatMap _ = _ |
| rw [range_flatMap_to_finRange] |
| apply List.flatMap_congr |
| intro i hi |
| rw [range_flatMap_to_finRange] |
| apply List.flatMap_congr |
| intro j hj |
| change Fin d at j |
| exact cramer_encode_of A B den i j |
|
|
| abbrev TupleWordArgs := (Params×GridPoint)×DenseSquare×ℤ |
|
|
| def tupleWord (p : Params) (x : GridPoint) (A : DenseSquare) (den : ℤ) : BitWord := |
| ⟨(List.range p.n).flatMap fun i => (matrixWord A (matrix p x ⟨i+1⟩) den).val⟩ |
|
|
| @[fun_prop] theorem tupleWord_poly : Poly (fun a : TupleWordArgs => tupleWord a.1.1 a.1.2 a.2.1 a.2.2) := by |
| have hm : Poly (fun a : TupleWordArgs×Unary => matrix a.1.1.1 a.1.1.2 (a.2+1)) := by fun_prop |
| have hv := matrixWord_poly.comp |
| (((show Poly (fun a : TupleWordArgs×Unary => a.1.2.1) by fun_prop).pair hm).pair |
| (show Poly (fun a : TupleWordArgs×Unary => a.1.2.2) by fun_prop)) |
| exact Poly.wordRange (show Poly (fun a : TupleWordArgs => a.1.1.1) by fun_prop) hv |
|
|
| lemma tupleWord_eq (n s : ℕ) (x : GridPoint) (den : ℤ) : |
| (tupleWord (Params.of n s) x |
| (matrix (Params.of n s) x 0) den).val = |
| encodeTuple (ExecutableGenerator.tuple (ExecutableGenerator.normalized |
| (ExecutableGenerator.inputTables n (Parameters.N n s) (Parameters.exponent n s) (gridFn x)) den)) := by |
| unfold tupleWord encodeTuple |
| change (List.range n).flatMap _ = _ |
| rw [range_flatMap_to_finRange] |
| apply List.flatMap_congr |
| intro a ha |
| let U := Generator.U n (Parameters.N n s) (Parameters.exponent n s) (gridFn x) |
| have hzero : matrix (Params.of n s) x 0=DenseSquare.of (U 0) := matrix_eq n s x 0 |
| have hsucc : matrix (Params.of n s) x ⟨a.val+1⟩=DenseSquare.of (U a.succ) := matrix_eq n s x a.succ |
| trans (matrixWord (DenseSquare.of (U 0)) (DenseSquare.of (U a.succ)) den).val |
| · exact congrArg₂ (fun A B => (matrixWord A B den).val) hzero hsucc |
| rw [matrixWord_of] |
| apply List.flatMap_congr |
| intro i hi |
| apply List.flatMap_congr |
| intro j hj |
| congr 1 |
| rw [ExecutableGenerator.tuple_normalized,ExecutableGenerator.normalizedEntry, |
| DeterminantAlgorithm.determinant_eq,DeterminantAlgorithm.denote_tabulate, |
| ExecutableGenerator.inputTables_denote,ExecutableGenerator.inputTables_denote] |
|
|
| end Runtime |
| end RationalHitting.StackLanguage |
|
|
|
|
| namespace RationalHitting.StackLanguage |
| namespace Runtime |
|
|
| def point (p : Params) (x : GridPoint) : List BitWord := |
| let A := matrix p x 0 |
| let den := A.val.det |
| if den=0 then [] else [tupleWord p x A den] |
|
|
| @[fun_prop] theorem point_poly : Poly (fun a : Params×GridPoint => point a.1 a.2) := by |
| have hf : Poly (fun a : TupleWordArgs => |
| if a.2.2=0 then ([] : List BitWord) else [tupleWord a.1.1 a.1.2 a.2.1 a.2.2]) := by |
| apply Poly.ite |
| · exact Poly.intZero.comp (show Poly (fun a : TupleWordArgs => a.2.2) by fun_prop) |
| · exact Poly.const [] |
| · exact Poly.listSingleton.comp tupleWord_poly |
| have hm : Poly (fun a : Params×GridPoint => matrix a.1 a.2 0) := by fun_prop |
| exact hf.comp ((show Poly (fun a : Params×GridPoint => a) from Poly.id).pair |
| (hm.pair (Poly.denseDet.comp hm))) |
|
|
| lemma matrix_det_eq (n s : ℕ) (x : GridPoint) (a : Fin (n+1)) : |
| (matrix (Params.of n s) x ⟨a.val⟩).val.det= |
| (Generator.U n (Parameters.N n s) (Parameters.exponent n s) (gridFn x) a).det := by |
| apply congrArg Matrix.det |
| funext i j |
| exact entry_eq n _ _ (gridFn x) a i j |
|
|
| lemma point_eq (n s : ℕ) (x : GridPoint) : |
| point (Params.of n s) x= |
| ((ExecutableGenerator.atPoint n (Parameters.N n s) (Parameters.exponent n s) (gridFn x)).toList.map |
| (fun X => BitWord.mk (encodeTuple X))) := by |
| unfold point ExecutableGenerator.atPoint |
| simp only [DeterminantAlgorithm.determinant_eq,ExecutableGenerator.inputTables_denote] |
| have hd : (matrix (Params.of n s) x 0).val.det= |
| (Generator.U n (Parameters.N n s) (Parameters.exponent n s) (gridFn x) 0).det := |
| matrix_det_eq n s x 0 |
| rw [hd] |
| split_ifs with hz |
| · rfl |
| · simp only [Option.toList_some,List.map_cons,List.map_nil,List.cons.injEq, and_true] |
| apply congrArg BitWord.mk |
| exact tupleWord_eq n s x _ |
|
|
| end Runtime |
| end RationalHitting.StackLanguage |
|
|
|
|
| namespace RationalHitting.StackLanguage |
|
|
| lemma map_filterMap_toList {A B C : Type} (l : List A) (f : A → Option B) (g : B → C) : |
| (l.filterMap f).map g=l.flatMap (fun a => (f a).toList.map g) := by |
| induction l with |
| | nil => rfl |
| | cons a l ih => cases h : f a <;> simp [h,ih] |
|
|
| namespace Runtime |
|
|
| def words (p : Params) : List BitWord := |
| (List.range p.H).flatMap fun t => (List.range p.H).flatMap fun q => |
| (List.range p.H).flatMap fun r => point p (⟨t+1⟩,⟨q+1⟩,⟨r+1⟩) |
|
|
| @[fun_prop] theorem words_poly : Poly words := by |
| have hp : Poly (fun a : ((Params×Unary)×Unary)×Unary => |
| point a.1.1.1 (a.1.1.2+1,a.1.2+1,a.2+1)) := by fun_prop |
| have h1 := Poly.flatMapUp (show Poly (fun a : (Params×Unary)×Unary => a.1.1.2.2.2.2) by fun_prop) hp |
| have h2 := Poly.flatMapUp (show Poly (fun a : Params×Unary => a.1.2.2.2.2) by fun_prop) h1 |
| exact Poly.flatMapUp (show Poly (fun a : Params => a.2.2.2.2) by fun_prop) h2 |
|
|
| lemma gridFn_fin {H : ℕ} (t p r : Fin H) : |
| gridFn (⟨t.val+1⟩,⟨p.val+1⟩,⟨r.val+1⟩)=fun i => (![t,p,r] i).val+1 := by |
| funext i;fin_cases i <;> rfl |
|
|
| lemma words_eq (n s : ℕ) : words (Params.of n s)= |
| (ExecutableGenerator.list n s).tuples.map (fun X => BitWord.mk (encodeTuple X)) := by |
| unfold words |
| rw [show (Params.of n s).H=Parameters.H n s from rfl] |
| simp only [ExecutableGenerator.list,ExecutableGenerator.output] |
| rw [map_filterMap_toList] |
| simp only [Generator.grid,List.flatMap_assoc,List.flatMap_map] |
| rw [range_flatMap_to_finRange] |
| apply List.flatMap_congr |
| intro t ht |
| rw [range_flatMap_to_finRange] |
| apply List.flatMap_congr |
| intro p hp |
| rw [range_flatMap_to_finRange] |
| apply List.flatMap_congr |
| intro r hr |
| rw [point_eq,gridFn_fin] |
|
|
| end Runtime |
| end RationalHitting.StackLanguage |
|
|
| end OAI |
|
|
