| import OAI.Combinatorics.LowSpaceSubsetSum.Representation.RepresentationStoredRecords |
|
|
| namespace OAI |
|
|
| /-! # Semantic maps for the mutable reader structures |
|
|
| Mapping records preserves the tournament paths and all cursor coordinates. |
| Immutable backing arrays are mapped once; they are not copied by a read. |
| -/ |
|
|
| namespace LowSpaceSubsetSum |
|
|
| namespace Tournament |
|
|
| variable {α β : Type*} |
|
|
| def map (f : α → β) : {d : ℕ} → Tree α d → Tree β d |
| | 0, .leaf v => .leaf (v.map f) |
| | _d + 1, .node w l r => .node (w.map f) (map f l) (map f r) |
|
|
| @[simp] theorem winner_map (f : α → β) {d : ℕ} (t : Tree α d) : |
| winner (map f t) = (winner t).map f := by cases t <;> rfl |
|
|
| @[simp] theorem nodes_map (f : α → β) {d : ℕ} (t : Tree α d) : |
| nodes (map f t) = nodes t := by |
| induction t with |
| | leaf _ => rfl |
| | node _ _ _ ihl ihr => simp only [map, nodes, ihl, ihr] |
|
|
| theorem pick_map (f : α → β) (key : β → ℤ) (a b : Option α) : |
| (pick (fun x => key (f x)) a b).map f = pick key (a.map f) (b.map f) := by |
| cases a <;> cases b <;> simp only [pick, Option.map_none, Option.map_some] |
| split <;> rfl |
|
|
| theorem node_map (f : α → β) (key : β → ℤ) {d : ℕ} (l r : Tree α d) : |
| map f (node (fun x => key (f x)) l r) = node key (map f l) (map f r) := by |
| simp only [node, map, pick_map, winner_map] |
|
|
| theorem valid_map (f : α → β) (key : β → ℤ) {d : ℕ} (t : Tree α d) |
| (h : Valid (fun x => key (f x)) t) : Valid key (map f t) := by |
| induction t with |
| | leaf _ => trivial |
| | node w l r ihl ihr => |
| refine ⟨?_, ihl h.2.1, ihr h.2.2⟩ |
| rw [h.1, pick_map, winner_map, winner_map] |
|
|
| theorem lookup_map (f : α → β) {d : ℕ} (t : Tree α d) (p : Fin d → Bool) : |
| lookup (map f t) p = (lookup t p).map f := by |
| induction t with |
| | leaf _ => rfl |
| | node _ _ _ ihl ihr => |
| simp only [map, lookup] |
| split <;> simp only [ihl, ihr] |
|
|
| theorem replace_map (f : α → β) (key : β → ℤ) {d : ℕ} (t : Tree α d) |
| (p : Fin d → Bool) (v : Option α) : |
| map f (replace (fun x => key (f x)) t p v) = replace key (map f t) p (v.map f) := by |
| induction t with |
| | leaf _ => rfl |
| | node _ _ _ ihl ihr => |
| simp only [map, replace] |
| split <;> simp only [node_map, ihl, ihr] |
|
|
| theorem build_map (f : α → β) (key : β → ℤ) (d : ℕ) |
| (front : (Fin d → Bool) → Option α) : |
| map f (build (fun x => key (f x)) d front) = |
| build key d (fun p => (front p).map f) := by |
| induction d with |
| | zero => rfl |
| | succ d ih => simp only [build, node_map, ih] |
|
|
| end Tournament |
|
|
| namespace CyclicCursor |
|
|
| variable {α β : Type*} {n : ℕ} [NeZero n] |
|
|
| theorem trace_map (f : α → β) (a : Fin n → α) (k : ℕ) (c : State n) : |
| (trace a k c).map f = trace (fun i => f (a i)) k c := by |
| induction k generalizing c with |
| | zero => rfl |
| | succ k ih => |
| simp only [trace] |
| split <;> simp only [List.map_nil, List.map_cons, ih] |
|
|
| end CyclicCursor |
|
|
| namespace SliceCursor |
|
|
| variable {α β : Type*} |
|
|
| def mapRange (f : α → β) (xs : Array α) (r : Range xs.size) : Range (xs.map f).size := |
| ⟨r.lo, r.length, by simpa using r.bounded⟩ |
|
|
| def mapState (f : α → β) (xs : Array α) (s : State xs.size) : State (xs.map f).size := |
| ⟨mapRange f xs s.range, s.cursor⟩ |
|
|
| theorem values_map (f : α → β) (xs : Array α) (r : Range xs.size) (i : Fin r.length) : |
| values (xs.map f) (mapRange f xs r) i = f (values xs r i) := by |
| simp only [values, mapRange, Array.getElem_map] |
|
|
| theorem next_map (f : α → β) (xs : Array α) (s : State xs.size) : |
| (next xs s).map (fun z => (f z.1, mapState f xs z.2)) = |
| next (xs.map f) (mapState f xs s) := by |
| cases h : s.cursor with |
| | none => simp only [next, mapState, h, Option.map_none] |
| | some c => |
| simp only [next, mapState, h] |
| split <;> simp only [Option.map_none, Option.map_some, values_map] |
| rfl |
|
|
| theorem output_map (f : α → β) (xs : Array α) (s : State xs.size) : |
| (output xs s).map f = output (xs.map f) (mapState f xs s) := by |
| cases h : s.cursor with |
| | none => simp only [output, mapState, h, List.map_nil] |
| | some c => |
| have : NeZero s.range.length := ⟨by have := c.position.isLt; omega⟩ |
| simp only [output, mapState, h, CyclicCursor.trace_map] |
| congr 1 |
| funext i |
| exact (values_map f xs s.range i).symm |
|
|
| end SliceCursor |
|
|
| namespace PairCursor |
|
|
| variable {α β γ δ : Type*} |
|
|
| def mapState (f : α → γ) (g : β → δ) (xs : Array β) (s : State α xs.size) : |
| State γ (xs.map g).size := ⟨f s.left, SliceCursor.mapState g xs s.cursor⟩ |
|
|
| theorem next_map (f : α → γ) (g : β → δ) (xs : Array β) (s : State α xs.size) : |
| (next xs s).map (fun z => (Prod.map f g z.1, mapState f g xs z.2)) = |
| next (xs.map g) (mapState f g xs s) := by |
| have h := SliceCursor.next_map g xs s.cursor |
| simp only [next, mapState] |
| rw [← h] |
| simp only [Option.map_map] |
| rfl |
|
|
| theorem output_map (f : α → γ) (g : β → δ) (xs : Array β) (s : State α xs.size) : |
| (output xs s).map (Prod.map f g) = output (xs.map g) (mapState f g xs s) := by |
| change ((SliceCursor.output xs s.cursor).map (fun y => (s.left, y))).map (Prod.map f g) = |
| (SliceCursor.output (xs.map g) (SliceCursor.mapState g xs s.cursor)).map |
| (fun y => (f s.left, y)) |
| rw [← SliceCursor.output_map g xs s.cursor] |
| simp only [List.map_map] |
| rfl |
|
|
| end PairCursor |
|
|
| namespace FilteredStream |
|
|
| variable {α β γ δ : Type*} |
|
|
| def mapCursor (f : α → γ) (g : β → δ) (xs : Array β) : |
| Cursor (α := α) xs → Cursor (α := γ) (xs.map g) := |
| Option.map (PairCursor.mapState f g xs) |
|
|
| theorem read_map (f : α → γ) (g : β → δ) (xs : Array β) (s : Cursor (α := α) xs) : |
| (read xs s).map (fun z => (Prod.map f g z.1, mapCursor f g xs z.2)) = |
| read (xs.map g) (mapCursor f g xs s) := by |
| cases s with |
| | none => rfl |
| | some s => |
| simp only [read, PaddedRows.next, mapCursor, Option.map_some] |
| rw [← PairCursor.next_map f g xs s] |
| simp only [Option.map_map] |
| rfl |
|
|
| theorem view_map (f : α → γ) (g : β → δ) (xs : Array β) (s : Cursor (α := α) xs) : |
| (view xs s).map (Prod.map f g) = view (xs.map g) (mapCursor f g xs s) := by |
| cases s with |
| | none => rfl |
| | some s => exact PairCursor.output_map f g xs s |
|
|
| end FilteredStream |
|
|
| namespace PaddedRows |
|
|
| variable {α β : Type*} |
|
|
| theorem rows_map (f : α → β) (xs : Array α) (d : ℕ) (p : RowMerge.Path d) : |
| (rows xs d p).map f = rows (xs.map f) d p := by |
| simp only [rows, Array.size_map] |
| split <;> simp only [Option.map_some, Option.map_none, Array.getElem_map] |
|
|
| end PaddedRows |
|
|
| namespace RowMerge |
|
|
| variable {α β σ τ : Type*} {d : ℕ} |
|
|
| def mapFront (f : α → β) (g : σ → τ) (x : Front d α σ) : Front d β τ := |
| ⟨x.row, f x.value, g x.after⟩ |
|
|
| theorem front_map (f : α → β) (g : σ → τ) |
| (readA : σ → Option (α × σ)) (readB : τ → Option (β × τ)) |
| (hr : ∀ s, (readA s).map (fun z => (f z.1, g z.2)) = readB (g s)) |
| (p : Path d) (s : σ) : |
| (front readA p s).map (mapFront f g) = front readB p (g s) := by |
| unfold front |
| rw [← hr] |
| simp only [Option.map_map] |
| rfl |
|
|
| theorem start_map (f : α → β) (g : σ → τ) (key : β → ℤ) |
| (readA : σ → Option (α × σ)) (readB : τ → Option (β × τ)) |
| (hr : ∀ s, (readA s).map (fun z => (f z.1, g z.2)) = readB (g s)) |
| (rows : Path d → σ) : |
| Tournament.map (mapFront f g) (start (fun x => key (f x)) readA rows) = |
| start key readB (fun p => g (rows p)) := by |
| unfold start |
| change Tournament.map (mapFront f g) |
| (Tournament.build (fun x => (fun y : Front d β τ => key y.value) (mapFront f g x)) |
| d (fun p => front readA p (rows p))) = _ |
| rw [Tournament.build_map (mapFront f g) (fun y : Front d β τ => key y.value) d |
| (fun p => front readA p (rows p))] |
| congr 1 |
| funext p |
| exact front_map f g readA readB hr p (rows p) |
|
|
| theorem advance_map (f : α → β) (g : σ → τ) (key : β → ℤ) |
| (readA : σ → Option (α × σ)) (readB : τ → Option (β × τ)) |
| (hr : ∀ s, (readA s).map (fun z => (f z.1, g z.2)) = readB (g s)) |
| (t : Tournament.Tree (Front d α σ) d) : |
| (advance (fun x => key (f x)) readA t).map |
| (fun z => (f z.1, Tournament.map (mapFront f g) z.2)) = |
| advance key readB (Tournament.map (mapFront f g) t) := by |
| simp only [advance, Tournament.winner_map] |
| cases h : Tournament.winner t with |
| | none => rfl |
| | some x => |
| simp only [Option.map_some] |
| congr 1 |
| apply Prod.ext |
| · rfl |
| change Tournament.map (mapFront f g) |
| (Tournament.replace (fun y => key (mapFront f g y).value) t x.row |
| (front readA x.row x.after)) = |
| Tournament.replace (fun y => key y.value) (Tournament.map (mapFront f g) t) |
| x.row (front readB x.row (g x.after)) |
| rw [Tournament.replace_map (mapFront f g) (fun y : Front d β τ => key y.value) |
| t x.row (front readA x.row x.after), front_map f g readA readB hr] |
|
|
| theorem aligned_map (f : α → β) (g : σ → τ) |
| (t : Tournament.Tree (Front d α σ) d) (h : Aligned t) : |
| Aligned (Tournament.map (mapFront f g) t) := by |
| intro p y hy |
| rw [Tournament.lookup_map] at hy |
| obtain ⟨x, hx, he⟩ := Option.map_eq_some_iff.mp hy |
| rw [← he] |
| exact h p x hx |
|
|
| theorem remaining_map (f : α → β) (g : σ → τ) |
| (viewA : σ → List α) (viewB : τ → List β) |
| (hv : ∀ s, (viewA s).map f = viewB (g s)) |
| (t : Tournament.Tree (Front d α σ) d) (p : Path d) : |
| remaining viewB (Tournament.map (mapFront f g) t) p = (remaining viewA t p).map f := by |
| unfold remaining |
| rw [Tournament.lookup_map] |
| cases ht : Tournament.lookup t p with |
| | none => rfl |
| | some x => simp only [Option.map_some, mapFront, List.map_cons, hv] |
|
|
| theorem rowsSorted_map (f : α → β) (g : σ → τ) (key : β → ℤ) |
| (viewA : σ → List α) (viewB : τ → List β) |
| (hv : ∀ s, (viewA s).map f = viewB (g s)) |
| (t : Tournament.Tree (Front d α σ) d) (h : RowsSorted (fun x => key (f x)) viewA t) : |
| RowsSorted key viewB (Tournament.map (mapFront f g) t) := by |
| intro p |
| rw [remaining_map f g viewA viewB hv, List.pairwise_map] |
| exact h p |
|
|
| theorem potential_map (f : α → β) (g : σ → τ) |
| (viewA : σ → List α) (viewB : τ → List β) |
| (hv : ∀ s, (viewA s).map f = viewB (g s)) |
| (t : Tournament.Tree (Front d α σ) d) : |
| potential viewB (Tournament.map (mapFront f g) t) = potential viewA t := by |
| unfold potential |
| apply Finset.sum_congr rfl |
| intro p _ |
| rw [remaining_map f g viewA viewB hv, List.length_map] |
|
|
| theorem trace_map (f : α → β) (g : σ → τ) (key : β → ℤ) |
| (readA : σ → Option (α × σ)) (readB : τ → Option (β × τ)) |
| (hr : ∀ s, (readA s).map (fun z => (f z.1, g z.2)) = readB (g s)) |
| (k : ℕ) (t : Tournament.Tree (Front d α σ) d) : |
| (trace (fun x => key (f x)) readA k t).map f = |
| trace key readB k (Tournament.map (mapFront f g) t) := by |
| induction k generalizing t with |
| | zero => rfl |
| | succ k ih => |
| have h := advance_map f g key readA readB hr t |
| cases ha : advance (fun x => key (f x)) readA t with |
| | none => |
| have hb : advance key readB (Tournament.map (mapFront f g) t) = none := by |
| simpa only [ha, Option.map_none] using h.symm |
| simp only [trace, ha, hb, List.map_nil] |
| | some z => |
| obtain ⟨a, t'⟩ := z |
| have hb : advance key readB (Tournament.map (mapFront f g) t) = |
| some (f a, Tournament.map (mapFront f g) t') := by |
| simpa only [ha, Option.map_some] using h.symm |
| simp only [trace, ha, hb, List.map_cons, ih] |
|
|
| end RowMerge |
|
|
| namespace MergedReader |
|
|
| variable {α β σ τ : Type*} {d : ℕ} |
|
|
| def mapState (f : α → β) (g : σ → τ) (key : β → ℤ) |
| (viewA : σ → List α) (viewB : τ → List β) |
| (hv : ∀ s, (viewA s).map f = viewB (g s)) |
| (s : State (fun x => key (f x)) viewA d) : State key viewB d := |
| ⟨Tournament.map (RowMerge.mapFront f g) s.tree, |
| Tournament.valid_map (RowMerge.mapFront f g) (fun x => key x.value) s.tree s.valid, |
| RowMerge.aligned_map f g s.tree s.aligned, |
| RowMerge.rowsSorted_map f g key viewA viewB hv s.tree s.sorted⟩ |
|
|
| theorem next_map (f : α → β) (g : σ → τ) (key : β → ℤ) |
| (readA : σ → Option (α × σ)) (readB : τ → Option (β × τ)) |
| (hr : ∀ s, (readA s).map (fun z => (f z.1, g z.2)) = readB (g s)) |
| (viewA : σ → List α) (viewB : τ → List β) |
| (hv : ∀ s, (viewA s).map f = viewB (g s)) |
| (ha : RowMerge.IsReader readA viewA) (hb : RowMerge.IsReader readB viewB) |
| (s : State (fun x => key (f x)) viewA d) : |
| (next (fun x => key (f x)) readA viewA ha s).map |
| (fun z => (f z.1, mapState f g key viewA viewB hv z.2)) = |
| next key readB viewB hb (mapState f g key viewA viewB hv s) := by |
| have h := RowMerge.advance_map f g key readA readB hr s.tree |
| cases he : RowMerge.advance (fun x => key (f x)) readA s.tree with |
| | none => |
| have h' : RowMerge.advance key readB (Tournament.map (RowMerge.mapFront f g) s.tree) = none := by |
| simpa only [he, Option.map_none] using h.symm |
| rw [next_none _ _ _ _ _ he, next_none _ _ _ _ _ h'] |
| rfl |
| | some z => |
| obtain ⟨a, t⟩ := z |
| have h' : RowMerge.advance key readB (Tournament.map (RowMerge.mapFront f g) s.tree) = |
| some (f a, Tournament.map (RowMerge.mapFront f g) t) := by |
| simpa only [he, Option.map_some] using h.symm |
| rw [next_some _ _ _ _ _ he, next_some _ _ _ _ _ h'] |
| rfl |
|
|
| theorem output_map (f : α → β) (g : σ → τ) (key : β → ℤ) |
| (readA : σ → Option (α × σ)) (readB : τ → Option (β × τ)) |
| (hr : ∀ s, (readA s).map (fun z => (f z.1, g z.2)) = readB (g s)) |
| (viewA : σ → List α) (viewB : τ → List β) |
| (hv : ∀ s, (viewA s).map f = viewB (g s)) |
| (s : State (fun x => key (f x)) viewA d) : |
| (output (fun x => key (f x)) readA viewA s).map f = |
| output key readB viewB (mapState f g key viewA viewB hv s) := by |
| unfold output |
| rw [show RowMerge.potential viewB (mapState f g key viewA viewB hv s).tree = |
| RowMerge.potential viewA s.tree from RowMerge.potential_map f g viewA viewB hv s.tree] |
| exact RowMerge.trace_map f g key readA readB hr _ _ |
|
|
| end MergedReader |
| end LowSpaceSubsetSum |
|
|
| end OAI |
|
|
