File size: 6,288 Bytes
ae00908 | 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 | import OAI.Algebra.FormulaHitting.Program
namespace OAI
namespace NCHitting
open BitModel
private theorem length_flatMap_uniform {α β : Type*} (xs : List α) (f : α → List β)
(k : ℕ) (h : ∀ x ∈ xs, (f x).length = k) :
(xs.flatMap f).length = xs.length * k := by
induction xs with
| nil => simp
| cons x xs ih =>
have hx := h x (by simp)
have hxs : ∀ y ∈ xs, (f y).length = k := by
intro y hy
exact h y (by simp [hy])
simp only [List.flatMap_cons, List.length_append, List.length_cons]
rw [hx, ih hxs, Nat.add_mul]
omega
private theorem getElem?_flatMap_uniform {α β : Type*} (xs : List α) (f : α → List β)
(k : ℕ) (h : ∀ x ∈ xs, (f x).length = k) (i j : ℕ) (hj : j < k) :
(xs.flatMap f)[i * k + j]? = xs[i]?.bind (fun x => (f x)[j]?) := by
induction xs generalizing i with
| nil => simp
| cons x xs ih =>
have hx := h x (by simp)
have hxs : ∀ y ∈ xs, (f y).length = k := by
intro y hy
exact h y (by simp [hy])
cases i with
| zero =>
simp only [Nat.zero_mul, Nat.zero_add, List.flatMap_cons,
List.getElem?_cons_zero, Option.bind_some]
exact List.getElem?_append_left (by omega)
| succ i =>
have hlarge : (f x).length ≤ (i + 1) * k + j := by
rw [hx, Nat.add_mul]
omega
have hindex : (i + 1) * k + j - (f x).length = i * k + j := by
rw [hx, Nat.add_mul]
omega
simp only [List.flatMap_cons, List.getElem?_cons_succ]
rw [List.getElem?_append_right hlarge, hindex]
exact ih hxs i
private theorem rows_length (d i : ℕ) :
((List.range d).flatMap fun r => (List.range d).map fun q => encodedEntry i r q).length = d * d := by
apply (length_flatMap_uniform (List.range d) _ d ?_).trans
· simp
· intro r hr
simp
theorem generate_output_length (n s : ℕ) :
(generate n s).output.length = n * dimension n s * dimension n s := by
rw [generate_output]
by_cases h : n = 1 ∧ s = 1
· rcases h with ⟨rfl, rfl⟩
simp [encodedOutput, dimension]
· simp only [encodedOutput, ite_eq_right h, dimension]
have hl := length_flatMap_uniform (List.range n)
(fun i => (List.range (2 * n * s ^ 2)).flatMap fun r =>
(List.range (2 * n * s ^ 2)).map fun q => encodedEntry i r q)
((2 * n * s ^ 2) * (2 * n * s ^ 2)) (fun i _ => rows_length _ i)
simp [Nat.mul_assoc] at hl ⊢
theorem encodedEntry_numerator_le (i r q : ℕ) : (encodedEntry i r q).numerator ≤ 1 := by
unfold encodedEntry
split_ifs <;> simp
theorem encodedEntry_denominator_size_le {n d i r q : ℕ} (hi : i < n) (hr : r < d) :
(encodedEntry i r q).denominator.size ≤ entryBitBound n d := by
unfold encodedEntry
split_ifs with h
· exact denominator_size_le (q := q) (Nat.succ_le_of_lt hi) hr
· simp only [Nat.size_one]
unfold entryBitBound
omega
theorem generate_entry_bounds {n s : ℕ} (entry : RationalCode)
(hentry : entry ∈ (generate n s).output) :
0 < entry.denominator ∧ entry.numerator ≤ 1 ∧
entry.denominator.size ≤ entryBitBound n (dimension n s) ∧
entry.bits ≤ 4 + entryBitBound n (dimension n s) := by
rw [generate_output] at hentry
by_cases h : n = 1 ∧ s = 1
· rcases h with ⟨rfl, rfl⟩
simp only [encodedOutput, and_self, ite_true, List.mem_singleton] at hentry
subst entry
norm_num [dimension, entryBitBound, RationalCode.bits, width]
· simp only [encodedOutput, ite_eq_right h, List.mem_flatMap, List.mem_map, List.mem_range] at hentry
obtain ⟨i, hi, r, hr, q, hq, rfl⟩ := hentry
have hd : dimension n s = 2 * n * s ^ 2 := by simp [dimension, h]
rw [hd]
exact ⟨encodedEntry_denominator_pos i r q, encodedEntry_numerator_le i r q,
encodedEntry_denominator_size_le hi hr, encodedEntry_bits_le hi hr⟩
private theorem flattened_entry {n d i r q : ℕ} (hi : i < n) (hr : r < d) (hq : q < d) :
((List.range n).flatMap fun i => (List.range d).flatMap fun r =>
(List.range d).map fun q => encodedEntry i r q)[i * d * d + r * d + q]? =
some (encodedEntry i r q) := by
have hj : r * d + q < d * d := by
calc
r * d + q < r * d + d := Nat.add_lt_add_left hq _
_ = (r + 1) * d := by rw [Nat.add_mul]; omega
_ ≤ d * d := Nat.mul_le_mul_right d (by omega)
have hout := getElem?_flatMap_uniform (List.range n)
(fun i => (List.range d).flatMap fun r => (List.range d).map fun q => encodedEntry i r q)
(d * d) (fun i _ => rows_length d i) i (r * d + q) hj
rw [List.getElem?_range hi] at hout
simp only [Option.bind_some] at hout
have hin := getElem?_flatMap_uniform (List.range d)
(fun r => (List.range d).map fun q => encodedEntry i r q)
d (by intro r _; simp) r q hq
rw [List.getElem?_range hr] at hin
simp only [Option.bind_some] at hin
rw [List.getElem?_map, List.getElem?_range hq] at hin
simp only [Option.map_some] at hin
simpa only [Nat.mul_assoc, Nat.add_assoc] using hout.trans hin
theorem generate_entry_code {n s i r q : ℕ} (hi : i < n)
(hr : r < dimension n s) (hq : q < dimension n s) :
(generate n s).output[i * dimension n s * dimension n s + r * dimension n s + q]? =
some (if n = 1 ∧ s = 1 then ⟨false, 1, 1⟩ else encodedEntry i r q) := by
rw [generate_output]
by_cases h : n = 1 ∧ s = 1
· rcases h with ⟨rfl, rfl⟩
have hi0 : i = 0 := by omega
have hr0 : r = 0 := by simpa [dimension] using hr
have hq0 : q = 0 := by simpa [dimension] using hq
subst i
subst r
subst q
simp [encodedOutput, dimension]
· have hd : dimension n s = 2 * n * s ^ 2 := by simp [dimension, h]
rw [hd] at hr hq ⊢
simp only [encodedOutput, ite_eq_right h]
exact flattened_entry hi hr hq
theorem generate_entry_decode (n s : ℕ) (i : Fin n) (r q : Fin (dimension n s)) :
decode (((generate n s).output[i.val * dimension n s * dimension n s +
r.val * dimension n s + q.val]?).getD ⟨false, 0, 1⟩) = generator n s i r q := by
rw [generate_entry_code i.isLt r.isLt q.isLt]
simp only [Option.getD_some]
by_cases h : n = 1 ∧ s = 1
· simp [h, generator, decode]
· simp only [generator, ite_eq_right h]
exact decode_encodedEntry i.val r.val q.val
end NCHitting
end OAI
|