| import OAI.Combinatorics.EditApproximation.Binary.BinaryGatheredValues |
| import OAI.Combinatorics.EditApproximation.Binary.BinaryLoopSpace |
| import OAI.Combinatorics.EditApproximation.Definitions |
|
|
|
|
| namespace OAI |
|
|
| /-! Stored key/value words and the actual linear lookup call tree. Reads |
| return pointers to retained words; only comparison scratch is fresh. -/ |
|
|
| namespace EditApproximation.BinaryFraction |
|
|
| def storedCells (word : BinaryFraction) : ℕ := |
| word.numerator.bits.length + word.denominator.length + 1 |
|
|
| def bufferCells {κ : Type*} (code : κ → ℕ) (keys : List κ) (values : List BinaryFraction) : ℕ := |
| (keys.map fun key => Nat.size (code key) + 1).sum + |
| (values.map fun value => storedCells value + 1).sum |
|
|
| theorem storedCells_le_width (word : BinaryFraction) : storedCells word ≤ 2 * word.width + 1 := by |
| have hn : word.numerator.bits.length ≤ word.width := le_max_left _ _ |
| have hd : word.denominator.length ≤ word.width := le_max_right _ _ |
| unfold storedCells |
| omega |
|
|
| theorem bufferCells_le {κ : Type*} (code : κ → ℕ) (keys : List κ) (values : List BinaryFraction) |
| (B : ℕ) (hk : ∀ key ∈ keys, Nat.size (code key) ≤ B) |
| (hv : ∀ value ∈ values, value.width ≤ B) : |
| bufferCells code keys values ≤ keys.length * (B + 1) + values.length * (2 * B + 2) := by |
| have hkeys := sum_map_le_length_mul keys (fun key => Nat.size (code key) + 1) (B + 1) |
| (fun key hkey => Nat.add_le_add_right (hk key hkey) 1) |
| have hvalues := sum_map_le_length_mul values (fun value => storedCells value + 1) (2 * B + 2) |
| (fun value hvalue => by have h := storedCells_le_width value; have hb := hv value hvalue; omega) |
| unfold bufferCells |
| omega |
|
|
| theorem bufferCells_le_fourthPower {κ : Type*} (code : κ → ℕ) |
| (keys : List κ) (values : List BinaryFraction) (B X : ℕ) |
| (hX : 4 ≤ X) (hk : ∀ key ∈ keys, Nat.size (code key) ≤ B) |
| (hv : ∀ value ∈ values, value.width ≤ B) |
| (hkeys : keys.length ≤ X) (hvalues : values.length ≤ X) (hB : B ≤ X) : |
| bufferCells code keys values ≤ X ^ 4 := by |
| have h := bufferCells_le code keys values B hk hv |
| have h1 := Nat.mul_le_mul hkeys (Nat.add_le_add_right hB 1) |
| have h2 := Nat.mul_le_mul hvalues (show 2 * B + 2 ≤ 2 * X + 2 by omega) |
| have hsmall : keys.length * (B + 1) + values.length * (2 * B + 2) ≤ 4 * X ^ 2 := by |
| nlinarith only [hX, h1, h2] |
| have hsq : 4 ≤ X ^ 2 := by nlinarith only [hX] |
| exact h.trans (hsmall.trans (by |
| calc |
| 4 * X ^ 2 ≤ X ^ 2 * X ^ 2 := Nat.mul_le_mul_right _ hsq |
| _ = X ^ 4 := by ring)) |
|
|
|
|
|
|
| def gatheredLookupInvocations {κ : Type*} (equal : κ → κ → Bool × ℕ) |
| (invocations : κ → κ → ℕ) : List κ → List BinaryFraction → κ → ℕ |
| | key :: keys, _value :: values, query => |
| invocations query key + if (equal query key).1 then 1 |
| else gatheredLookupInvocations equal invocations keys values query + 1 |
| | _, _, _ => 1 |
|
|
| theorem gatheredLookupAllocation_le_work {κ : Type*} (equal : κ → κ → Bool × ℕ) |
| (allocation : κ → κ → ℕ) (keys : List κ) (values : List BinaryFraction) (query : κ) |
| (h : ∀ key ∈ keys, allocation query key ≤ (equal query key).2) : |
| gatheredLookupAllocation equal allocation keys values query ≤ |
| (gatheredWordLookupWithWork equal keys values query).2 := by |
| induction keys generalizing values with |
| | nil => exact Nat.zero_le 1 |
| | cons key keys ih => |
| cases values with |
| | nil => exact Nat.zero_le 1 |
| | cons value values => |
| have hc := h key List.mem_cons_self |
| have ht := ih values (fun k hk => h k (List.mem_cons_of_mem _ hk)) |
| unfold gatheredLookupAllocation gatheredWordLookupWithWork |
| dsimp only |
| split_ifs <;> dsimp only |
| · exact Nat.add_le_add hc (Nat.zero_le 1) |
| · exact (Nat.add_le_add hc ht).trans (Nat.le_succ _) |
|
|
| theorem gatheredLookupInvocations_le_work {κ : Type*} (equal : κ → κ → Bool × ℕ) |
| (invocations : κ → κ → ℕ) (keys : List κ) (values : List BinaryFraction) (query : κ) |
| (h : ∀ key ∈ keys, invocations query key ≤ (equal query key).2) : |
| gatheredLookupInvocations equal invocations keys values query ≤ |
| (gatheredWordLookupWithWork equal keys values query).2 := by |
| induction keys generalizing values with |
| | nil => rfl |
| | cons key keys ih => |
| cases values with |
| | nil => rfl |
| | cons value values => |
| have hc := h key List.mem_cons_self |
| have ht := ih values (fun k hk => h k (List.mem_cons_of_mem _ hk)) |
| unfold gatheredLookupInvocations gatheredWordLookupWithWork |
| dsimp only |
| split_ifs <;> dsimp only <;> omega |
|
|
| end EditApproximation.BinaryFraction |
|
|
| end OAI |
|
|
