File size: 6,275 Bytes
0dd3af4 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 | 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
|