File size: 5,856 Bytes
e63eb7f | 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 | import OAI.Combinatorics.EditApproximation.Binary.BinaryGroupActionReads
import OAI.Combinatorics.EditApproximation.Binary.BinaryUnskippedReads
import OAI.Combinatorics.EditApproximation.Binary.BinaryPreparedCellGroup
import OAI.Combinatorics.EditApproximation.Definitions
namespace OAI
/-! Reader-aware whole-cell construction. Every eligibility test reads its
initial word, and every accepted band and selected action uses the counted
reader kernels. -/
namespace EditApproximation
theorem filterMapWithWork_extra {α β : Type*} (read plain : α → Option β × ℕ)
(extra : α → ℕ) (xs : List α)
(hv : ∀ x ∈ xs, (read x).1 = (plain x).1)
(hc : ∀ x ∈ xs, (read x).2 ≤ (plain x).2 + extra x) :
(filterMapWithWork read xs).1 = (filterMapWithWork plain xs).1 ∧
(filterMapWithWork read xs).2 ≤ (filterMapWithWork plain xs).2 + (xs.map extra).sum := by
induction xs with
| nil => exact ⟨rfl, by simp only [filterMapWithWork, List.map_nil, List.sum_nil,
Nat.add_zero, le_refl]⟩
| cons x xs ih =>
have hx := hv x List.mem_cons_self
have hcx := hc x List.mem_cons_self
have ht := ih (fun y hy => hv y (List.mem_cons_of_mem _ hy))
(fun y hy => hc y (List.mem_cons_of_mem _ hy))
simp only [filterMapWithWork, hx, ht.1, List.map_cons, List.sum_cons]
cases (plain x).1 with
| none => exact ⟨trivial, by omega⟩
| some value => exact ⟨trivial, by omega⟩
namespace BinaryFraction
theorem cellCentersReadWithWork_eq_cost {n : ℕ} (P F b : ℕ) (a theta : BinaryFraction)
(initial : TargetInterval n → BinaryFraction × ℕ) (cell : ℕ × ℕ)
(R : ℕ) (hr : ∀ r, (initial r).2 ≤ R) :
(cellCentersReadWithWork P F b a theta initial cell).1 =
(cellCentersWithWork P F b a theta (fun r => (initial r).1) cell).1 ∧
(cellCentersReadWithWork P F b a theta initial cell).2 ≤
(cellCentersWithWork P F b a theta (fun r => (initial r).1) cell).2 * (R + 1) := by
have hs := filterWithWork_add_read
(fun r => centerEligibilityWithWork b F a (initial r).1) (fun r => (initial r).2)
(cellStatesWithWork n (bitWordValue (seedGridSpacingWithWork b P).1)
(canonicalMulWithWork theta (nat b)).1 cell).1 R (fun r _ => hr r)
unfold cellCentersReadWithWork cellCentersWithWork
dsimp only
have he : (fun r => let word := initial r; let tested := centerEligibilityWithWork b F a word.1;
(tested.1, word.2 + tested.2)) =
(fun r => ((centerEligibilityWithWork b F a (initial r).1).1,
(centerEligibilityWithWork b F a (initial r).1).2 + (initial r).2)) := by
funext r
simp only [Nat.add_comm]
rw [he, hs.1]
exact ⟨rfl, by nlinarith only [hs.2]⟩
section Cell
variable {α : Type*} (source target : List α) {M : ℕ}
(parent : TargetInterval source.length) (b P F exponent Q : ℕ) (hb : 0 < b) (hP : 0 < P)
(tau a : BinaryFraction)
(parentInitial : TargetInterval target.length → BinaryFraction × ℕ)
(child initial current : Fin M → TargetInterval target.length → BinaryFraction × ℕ)
(R C : ℕ) (hr : ∀ i q, (child i q).2 ≤ R) (hi : ∀ i q, (initial i q).2 ≤ C)
(raw : List BinaryFraction) (hraw : raw.map value = groupDyadicScales M b (nat F).value)
(draw : ∀ t : Fin (groupDyadicScales M b (nat F).value).length,
Fin (groupSampleCount M Q b (groupDyadicScaleAt M b (nat F).value t)) → Fin M)
def preparedCellGroupReadWithWork (cell : ℕ × ℕ) :
Option (BinaryBellmanAction (TargetInterval target.length)
(Fin M × TargetInterval target.length) M) × ℕ :=
let centers := cellCentersReadWithWork P F b a (inversePowerTwo exponent) parentInitial cell
let members := filterMapWithWork
(preparedUnskippedReadWithWork source target parent b P exponent hb hP tau (nat F)
child initial R C hr hi) centers.1
if h : members.1 = [] then (none, centers.2 + members.2 + 1) else
let selected := dyadicSampledGroupActionReadWithWork source target parent b P exponent Q tau (nat F)
(fun i q => (child i q).1) initial current raw hraw draw members.1 h
(some selected.1, centers.2 + members.2 + selected.2 + 2)
theorem preparedCellGroupReadWithWork_eq (cell : ℕ × ℕ) (Rp Rc : ℕ)
(hp : ∀ r, (parentInitial r).2 ≤ Rp) (hc : ∀ i q, (current i q).2 ≤ Rc) :
(preparedCellGroupReadWithWork source target parent b P F exponent Q hb hP tau a
parentInitial child initial current R C hr hi raw hraw draw cell).1 =
(preparedCellGroupWithWork source target parent b P F exponent Q hb tau a
(fun r => (parentInitial r).1) (fun i q => (child i q).1)
(fun i q => (initial i q).1) (fun i q => (current i q).1) raw hraw draw hP cell).1 := by
have hcenters := (cellCentersReadWithWork_eq_cost P F b a (inversePowerTwo exponent)
parentInitial cell Rp hp).1
have hm : (filterMapWithWork
(preparedUnskippedReadWithWork source target parent b P exponent hb hP tau (nat F)
child initial R C hr hi)
(cellCentersWithWork P F b a (inversePowerTwo exponent) (fun r => (parentInitial r).1) cell).1).1 =
(filterMapWithWork
(preparedUnskippedCandidateWithWork source target parent b P exponent hb hP tau (nat F)
(fun i q => (child i q).1) (fun i q => (initial i q).1))
(cellCentersWithWork P F b a (inversePowerTwo exponent) (fun r => (parentInitial r).1) cell).1).1 := by
simp only [filterMapWithWork_value, preparedUnskippedReadWithWork_value]
unfold preparedCellGroupReadWithWork preparedCellGroupWithWork
dsimp only
simp only [hcenters, hm]
split_ifs with hempty
· rfl
· apply congrArg some
exact (sampledGroupActionReadWithWork_eq_cost source target parent b P exponent Q tau (nat F)
(fun i q => (child i q).1) initial current _ _ _ hempty Rc C hi hc).1
end Cell
end BinaryFraction
end EditApproximation
end OAI
|