math / data /lean /OAI /Computability /DepthThree /LanguageInputBlockLists.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
6.65 kB
import OAI.Computability.DepthThree.LanguageParser
import Mathlib.Data.List.OfFn
import Mathlib.Data.List.GetD
import Mathlib.Tactic.DeriveFintype
namespace OAI
namespace DepthThreeLowerBound
inductive InputBlockKind where
| data
| hash
| polynomial
| coefficients
deriving DecidableEq
instance : Fintype InputBlockKind where
elems := {.data, .hash, .polynomial, .coefficients}
complete := by
intro kind
cases kind <;> simp
def inputBlockOffset (n : ℕ) : InputBlockKind → ℕ
| .data => 0
| .hash => hashOffset (dataDimension n)
| .polynomial => polynomialOffset (dataDimension n)
| .coefficients => coefficientsOffset (dataDimension n)
def inputBlockLength (n : ℕ) : InputBlockKind → ℕ
| .data => dataDimension n
| .hash => hashBlockLength (dataDimension n)
| .polynomial => hashDimension (dataDimension n)
| .coefficients => independenceOrder (dataDimension n) * hashDimension (dataDimension n)
def inputBlockData (w : List Bool) (kind : InputBlockKind) : List Bool :=
(w.drop (inputBlockOffset w.length kind)).take (inputBlockLength w.length kind)
theorem inputBlock_end_le {w : List Bool} (h : InputFits w) (kind : InputBlockKind) :
inputBlockOffset w.length kind + inputBlockLength w.length kind ≤ w.length := by
cases kind with
| data =>
simpa only [inputBlockOffset, inputBlockLength, Nat.zero_add, dataDimension] using
Nat.div_le_self w.length 5
| hash =>
change polynomialOffset (dataDimension w.length) ≤ w.length
exact (polynomialOffset_le_coefficientsOffset _).trans
((coefficientsOffset_le_blockLen _).trans h.2.2)
| polynomial =>
change coefficientsOffset (dataDimension w.length) ≤ w.length
exact (coefficientsOffset_le_blockLen _).trans h.2.2
| coefficients =>
exact h.2.2
theorem inputBlock_offset_le {w : List Bool} (h : InputFits w) (kind : InputBlockKind) :
inputBlockOffset w.length kind ≤ w.length := by
have hb := inputBlock_end_le h kind
omega
theorem inputBlock_prefix_length {w : List Bool} (h : InputFits w)
(kind : InputBlockKind) :
(w.take (inputBlockOffset w.length kind)).length = inputBlockOffset w.length kind :=
List.length_take_of_le (inputBlock_offset_le h kind)
theorem inputBlockData_length {w : List Bool} (h : InputFits w) (kind : InputBlockKind) :
(inputBlockData w kind).length = inputBlockLength w.length kind := by
unfold inputBlockData
rw [List.length_take, List.length_drop]
apply Nat.min_eq_left
have hb := inputBlock_end_le h kind
omega
theorem inputBlock_reconstruct (w : List Bool) (kind : InputBlockKind) :
w = w.take (inputBlockOffset w.length kind) ++ inputBlockData w kind ++
w.drop (inputBlockOffset w.length kind + inputBlockLength w.length kind) := by
calc
w = w.take (inputBlockOffset w.length kind) ++
w.drop (inputBlockOffset w.length kind) :=
(List.take_append_drop _ _).symm
_ = w.take (inputBlockOffset w.length kind) ++
((w.drop (inputBlockOffset w.length kind)).take (inputBlockLength w.length kind) ++
(w.drop (inputBlockOffset w.length kind)).drop (inputBlockLength w.length kind)) :=
congrArg (fun tail => w.take (inputBlockOffset w.length kind) ++ tail)
(List.take_append_drop _ _).symm
_ = _ := by simp only [inputBlockData, List.drop_drop, List.append_assoc]
theorem inputBlockData_getD (w : List Bool) (kind : InputBlockKind) {i : ℕ}
(hi : i < inputBlockLength w.length kind) :
(inputBlockData w kind).getD i false =
w.getD (inputBlockOffset w.length kind + i) false := by
simp only [inputBlockData, List.getD_eq_getElem?_getD,
List.getElem?_take_of_lt hi, List.getElem?_drop]
theorem inputBlockData_data_nat (w : List Bool) {i : ℕ}
(hi : i < dataDimension w.length) :
(inputBlockData w .data).getD i false = (decodeInput w).data ⟨i, hi⟩ := by
simpa only [inputBlockOffset, Nat.zero_add, decodeInput] using
inputBlockData_getD w .data hi
theorem inputBlockData_data (w : List Bool) (i : Fin (dataDimension w.length)) :
(inputBlockData w .data).getD i.val false = (decodeInput w).data i :=
inputBlockData_data_nat w i.isLt
theorem inputBlockData_hash_nat (w : List Bool) {i : ℕ}
(hi : i < hashBlockLength (dataDimension w.length)) :
(inputBlockData w .hash).getD i false = (decodeInput w).hashSeed ⟨i, hi⟩ := by
simpa only [inputBlockOffset, decodeInput] using inputBlockData_getD w .hash hi
theorem inputBlockData_hash (w : List Bool)
(i : Fin (hashBlockLength (dataDimension w.length))) :
(inputBlockData w .hash).getD i.val false = (decodeInput w).hashSeed i :=
inputBlockData_hash_nat w i.isLt
theorem inputBlockData_polynomial_nat (w : List Bool) {i : ℕ}
(hi : i < hashDimension (dataDimension w.length)) :
(inputBlockData w .polynomial).getD i false = (decodeInput w).polynomial ⟨i, hi⟩ := by
simpa only [inputBlockOffset, decodeInput] using inputBlockData_getD w .polynomial hi
theorem inputBlockData_polynomial (w : List Bool)
(i : Fin (hashDimension (dataDimension w.length))) :
(inputBlockData w .polynomial).getD i.val false = (decodeInput w).polynomial i :=
inputBlockData_polynomial_nat w i.isLt
theorem inputBlock_coefficient_index_lt {n j i : ℕ}
(hj : j < independenceOrder (dataDimension n))
(hi : i < hashDimension (dataDimension n)) :
j * hashDimension (dataDimension n) + i < inputBlockLength n .coefficients := by
have hmul := Nat.mul_le_mul_right (hashDimension (dataDimension n))
(Nat.succ_le_of_lt hj)
simp only [Nat.succ_mul] at hmul
change j * hashDimension (dataDimension n) + i <
independenceOrder (dataDimension n) * hashDimension (dataDimension n)
omega
theorem inputBlockData_coefficients_nat (w : List Bool) {j i : ℕ}
(hj : j < independenceOrder (dataDimension w.length))
(hi : i < hashDimension (dataDimension w.length)) :
(inputBlockData w .coefficients).getD
(j * hashDimension (dataDimension w.length) + i) false =
(decodeInput w).coefficients ⟨j, hj⟩ ⟨i, hi⟩ := by
simpa only [inputBlockOffset, decodeInput, coefficientOffset, Nat.add_assoc] using
inputBlockData_getD w .coefficients (inputBlock_coefficient_index_lt hj hi)
theorem inputBlockData_coefficients (w : List Bool)
(j : Fin (independenceOrder (dataDimension w.length)))
(i : Fin (hashDimension (dataDimension w.length))) :
(inputBlockData w .coefficients).getD
(j.val * hashDimension (dataDimension w.length) + i.val) false =
(decodeInput w).coefficients j i :=
inputBlockData_coefficients_nat w j.isLt i.isLt
end DepthThreeLowerBound
end OAI