| import Mathlib |
| import OAI.GroupTheory.SimpleOvergroups.VariableCode |
|
|
| namespace OAI |
|
|
|
|
| namespace SimpleFInftyOvergroups.ContextualEncoding |
|
|
| namespace PaddedCode |
| section Syntax |
| variable {A : Type*} [Encodable A] |
|
|
| def body (cost : A → ℕ) (a : A) : List (Fin 4) := |
| List.replicate (Encodable.encode a) 0 ++ 1 :: List.replicate (10 * cost a) 0 |
|
|
| def code (cost : A → ℕ) : DelimiterCode A (Fin 4) where |
| start := 2 |
| stop := 3 |
| distinct := by decide |
| body := body cost |
| start_avoids := by intro a; simp [body] |
| stop_avoids := by intro a; simp [body] |
| injective := by |
| intro a b he |
| have hi (a : A) : (body cost a).idxOf 1 = Encodable.encode a := by |
| rw [body, List.idxOf_append_of_notMem (by simp)] |
| simp |
| apply Encodable.encode_injective |
| simpa only [hi] using congrArg (List.idxOf 1) he |
|
|
| @[simp] theorem block_length (cost : A → ℕ) (a : A) : |
| ((code cost).block a).length = Encodable.encode a + 10 * cost a + 3 := by |
| simp [DelimiterCode.block_length, code, body] |
| omega |
|
|
| theorem descriptor_le_length (cost : A → ℕ) (a : A) : |
| Encodable.encode a ≤ ((code cost).block a).length := by |
| rw [block_length]; omega |
|
|
| theorem cost_padding (cost : A → ℕ) (a : A) : |
| 10 * cost a + 2 ≤ ((code cost).block a).length := by |
| rw [block_length]; omega |
|
|
| def symbols (n : ℕ) : List A := (List.range (n + 1)).filterMap (Encodable.decode (α := A)) |
|
|
| theorem mem_symbols_of_encode_le {a : A} {n : ℕ} (ha : Encodable.encode a ≤ n) : |
| a ∈ symbols n := by |
| apply List.mem_filterMap.mpr |
| exact ⟨Encodable.encode a, List.mem_range.mpr (by omega), Encodable.encodek a⟩ |
|
|
| def wordsOver (xs : List A) : ℕ → List (List A) |
| | 0 => [[]] |
| | n + 1 => [] :: xs.flatMap (fun a => (wordsOver xs n).map (a :: ·)) |
|
|
| omit [Encodable A] in |
| @[simp] theorem mem_wordsOver [Encodable A] (xs : List A) (n : ℕ) (w : List A) : |
| w ∈ wordsOver xs n ↔ w.length ≤ n ∧ ∀ a ∈ w, a ∈ xs := by |
| induction n generalizing w with |
| | zero => |
| cases w <;> simp [wordsOver] |
| | succ n ih => |
| cases w with |
| | nil => simp [wordsOver] |
| | cons a w => |
| rw [wordsOver, List.mem_cons] |
| constructor |
| · rintro (he | h) |
| · cases he |
| · obtain ⟨b, hb, h⟩ := List.mem_flatMap.mp h |
| obtain ⟨v, hv, he⟩ := List.mem_map.mp h |
| obtain ⟨rfl, rfl⟩ := List.cons.inj he |
| obtain ⟨hlen, hs⟩ := (ih v).mp hv |
| exact ⟨by simpa using Nat.succ_le_succ hlen, |
| by simpa [List.mem_cons] using And.intro hb hs⟩ |
| · rintro ⟨hlen, hs⟩ |
| right |
| refine List.mem_flatMap.mpr ⟨a, hs a List.mem_cons_self, |
| List.mem_map.mpr ⟨w, ?_, rfl⟩⟩ |
| exact (ih w).mpr ⟨by simpa using hlen, |
| fun b hb => hs b (List.mem_cons_of_mem _ hb)⟩ |
|
|
| omit [Encodable A] in |
| theorem block_length_le_encode [Encodable A] (C : DelimiterCode A (Fin 4)) {a : A} {w : List A} |
| (ha : a ∈ w) : (C.block a).length ≤ (C.encode w).length := by |
| induction w with |
| | nil => simp at ha |
| | cons b w ih => |
| simp only [DelimiterCode.encode_cons, List.length_append] |
| rcases List.mem_cons.mp ha with rfl | ha |
| · omega |
| · have := ih ha; omega |
|
|
| def words (cost : A → ℕ) (n : ℕ) : List (List A) := |
| (wordsOver (symbols n) n).filter fun w => ((code cost).encode w).length ≤ n |
|
|
| @[simp] theorem mem_words (cost : A → ℕ) (n : ℕ) (w : List A) : |
| w ∈ words cost n ↔ ((code cost).encode w).length ≤ n := by |
| simp only [words, List.mem_filter, decide_eq_true_eq] |
| refine ⟨And.right, fun hw => ⟨?_, hw⟩⟩ |
| apply (mem_wordsOver _ _ _).mpr |
| refine ⟨?_, ?_⟩ |
| · have := (code cost).length_le_encode w |
| omega |
| · intro a ha |
| exact mem_symbols_of_encode_le |
| ((descriptor_le_length cost a).trans ((block_length_le_encode _ ha).trans hw)) |
|
|
| theorem word_cost_bound (cost : A → ℕ) {n : ℕ} {w : List A} |
| (hw : w ∈ words cost n) : DelimiterCode.cost cost w ≤ n / 10 := |
| (code cost).cost_le_quota cost (cost_padding cost) ((mem_words _ _ _).mp hw) |
|
|
| end Syntax |
|
|
| variable {A : Type*} [Primcodable A] |
|
|
| private theorem primrec_replicate (b : Fin 4) : Primrec (fun n => List.replicate n b) := |
| (Primrec.nat_rec₁ [] (Primrec.list_cons.comp (Primrec.const b) Primrec.snd).to₂).of_eq |
| (by intro n; induction n <;> simp_all [List.replicate_succ]) |
|
|
| theorem primrec_block (cost : A → ℕ) (hc : Primrec cost) : |
| Primrec (code cost).block := by |
| exact Primrec.list_cons.comp (Primrec.const 2) |
| (Primrec.list_append.comp |
| (Primrec.list_append.comp |
| ((primrec_replicate 0).comp Primrec.encode) |
| (Primrec.list_cons.comp (Primrec.const 1) |
| ((primrec_replicate 0).comp |
| (Primrec.nat_mul.comp (Primrec.const 10) hc)))) |
| (Primrec.const [3])) |
|
|
| theorem primrec_encode (cost : A → ℕ) (hc : Primrec cost) : |
| Primrec (code cost).encode := |
| Primrec.list_flatMap Primrec.id ((primrec_block cost hc).comp Primrec.snd).to₂ |
|
|
| theorem primrec_symbols : Primrec (@symbols A _) := |
| Primrec.listFilterMap (Primrec.list_range.comp Primrec.succ) |
| (Primrec.decode.comp Primrec.snd).to₂ |
|
|
| theorem primrec_wordsOver : Primrec₂ (@wordsOver A) := by |
| exact (Primrec.nat_rec (Primrec.const [[]]) |
| (Primrec.list_cons.comp (Primrec.const []) |
| (Primrec.list_flatMap Primrec.fst |
| (Primrec.list_map (Primrec.snd.comp (Primrec.snd.comp Primrec.fst)) |
| (Primrec.list_cons.comp (Primrec.snd.comp Primrec.fst) Primrec.snd).to₂).to₂)).to₂).of_eq |
| fun ls n => by induction n <;> simp_all [wordsOver] |
|
|
| theorem primrec_words (cost : A → ℕ) (hc : Primrec cost) : Primrec (words cost) := by |
| have hfilter : Primrec (fun n => (wordsOver (symbols n) n).filterMap |
| (fun w => if ((code cost).encode w).length ≤ n then some w else none)) := |
| Primrec.listFilterMap (primrec_wordsOver.comp primrec_symbols Primrec.id) |
| (Primrec.ite (Primrec.nat_le.comp |
| (Primrec.list_length.comp ((primrec_encode cost hc).comp Primrec.snd)) |
| Primrec.fst) (Primrec.option_some.comp Primrec.snd) (Primrec.const none)).to₂ |
| apply hfilter.of_eq |
| intro n |
| simp only [words, ← List.filterMap_eq_filter, Option.guard, decide_eq_true_eq] |
|
|
| end PaddedCode |
| end SimpleFInftyOvergroups.ContextualEncoding |
|
|
| end OAI |
|
|
