openAI-math-dataset / lean /OAI /Combinatorics /LowSpaceSubsetSum /Streams /ReaderInitializationMap.lean
| import OAI.Combinatorics.LowSpaceSubsetSum.Streams.ReaderMap | |
| namespace OAI | |
| /-! # Semantic maps commute with the actual binary-search initialization -/ | |
| namespace LowSpaceSubsetSum | |
| namespace BinarySlice | |
| variable {α β : Type*} | |
| private theorem search_lo_congr {m n : ℕ} (h : m = n) | |
| (p : Fin m → Bool) (q : Fin n → Bool) | |
| (hpq : ∀ i j, i.val = j.val → p i = q j) (k : ℕ) : | |
| (BinaryPivot.search p k).lo = (BinaryPivot.search q k).lo := by | |
| subst n | |
| have he : p = q := funext (fun i => hpq i i rfl) | |
| rw [he] | |
| theorem lower_map (f : α → β) (xs : Array α) (key : β → ℤ) (r : ℤ) (k : ℕ) : | |
| lower (xs.map f) key r k = lower xs (fun x => key (f x)) r k := by | |
| unfold lower | |
| apply search_lo_congr Array.size_map | |
| intro i j hij | |
| simp only [Array.getElem_map, hij] | |
| theorem upper_map (f : α → β) (xs : Array α) (key : β → ℤ) (r : ℤ) (k : ℕ) : | |
| upper (xs.map f) key r k = upper xs (fun x => key (f x)) r k := by | |
| unfold upper | |
| apply search_lo_congr Array.size_map | |
| intro i j hij | |
| simp only [Array.getElem_map, hij] | |
| theorem range_map (f : α → β) (xs : Array α) (key : β → ℤ) (r : ℤ) (k : ℕ) | |
| (hs : Monotone (fun i : Fin xs.size => key (f xs[i.val]))) | |
| (ht : Monotone (fun i : Fin (xs.map f).size => key (xs.map f)[i.val])) | |
| (hk : xs.size < 2 ^ k) (hk' : (xs.map f).size < 2 ^ k) : | |
| SliceCursor.mapRange f xs (range xs (fun x => key (f x)) r k hs hk) = | |
| range (xs.map f) key r k ht hk' := by | |
| simp only [SliceCursor.mapRange, range, lower_map, upper_map] | |
| end BinarySlice | |
| namespace SliceModular | |
| variable {α β : Type*} | |
| theorem forward_map (f : α → β) (xs : Array α) (rr : SliceCursor.Range xs.size) | |
| (key : β → ℤ) (P r : ℤ) (k : ℕ) : | |
| SliceCursor.mapState f xs (forward xs rr (fun x => key (f x)) P r k) = | |
| forward (xs.map f) (SliceCursor.mapRange f xs rr) key P r k := by | |
| by_cases h : 0 < rr.length | |
| · have : NeZero rr.length := ⟨by omega⟩ | |
| rw [forward, dite_eq_left h, forward, dite_eq_left (show 0 < (SliceCursor.mapRange f xs rr).length from h)] | |
| simp only [SliceCursor.mapState, SliceCursor.mapRange, | |
| ModularCursor.forwardStart, SliceCursor.values, Array.getElem_map] | |
| rfl | |
| · rw [forward, dite_eq_right h, forward, dite_eq_right (show ¬ 0 < (SliceCursor.mapRange f xs rr).length from h)] | |
| rfl | |
| theorem reverse_map (f : α → β) (xs : Array α) (rr : SliceCursor.Range xs.size) | |
| (key : β → ℤ) (r : ℤ) (k : ℕ) : | |
| SliceCursor.mapState f xs (reverse xs rr (fun x => key (f x)) r k) = | |
| reverse (xs.map f) (SliceCursor.mapRange f xs rr) key r k := by | |
| by_cases h : 0 < rr.length | |
| · have : NeZero rr.length := ⟨by omega⟩ | |
| rw [reverse, dite_eq_left h, reverse, dite_eq_left (show 0 < (SliceCursor.mapRange f xs rr).length from h)] | |
| simp only [SliceCursor.mapState, SliceCursor.mapRange, | |
| ModularCursor.reverseStart, SliceCursor.values, Array.getElem_map] | |
| rfl | |
| · rw [reverse, dite_eq_right h, reverse, dite_eq_right (show ¬ 0 < (SliceCursor.mapRange f xs rr).length from h)] | |
| rfl | |
| end SliceModular | |
| namespace FilteredRow | |
| variable {α β γ δ : Type*} | |
| theorem forward_map (f : α → γ) (g : β → δ) (xs : Array β) | |
| (wl : γ → ℤ) (wr : δ → ℤ) (p P c : ℤ) (k : ℕ) | |
| (hs : PrimarySorted xs (fun y => wr (g y)) p) | |
| (ht : PrimarySorted (xs.map g) wr p) | |
| (hk : xs.size < 2 ^ k) (hk' : (xs.map g).size < 2 ^ k) (x : α) : | |
| PairCursor.mapState f g xs | |
| (forward xs (fun y => wl (f y)) (fun y => wr (g y)) p P c k hs hk x) = | |
| forward (xs.map g) wl wr p P c k ht hk' (f x) := by | |
| simp only [forward, PairCursor.mapState, range] | |
| congr 1 | |
| rw [SliceModular.forward_map g xs _ (fun y => wr y % P) P (wl (f x) % P) k] | |
| congr 1 | |
| exact BinarySlice.range_map g xs (fun y => wr y % p) _ k hs ht hk hk' | |
| theorem reverse_map (f : α → γ) (g : β → δ) (xs : Array β) | |
| (wl : γ → ℤ) (wr : δ → ℤ) (p P c v : ℤ) (k : ℕ) | |
| (hs : PrimarySorted xs (fun y => wr (g y)) p) | |
| (ht : PrimarySorted (xs.map g) wr p) | |
| (hk : xs.size < 2 ^ k) (hk' : (xs.map g).size < 2 ^ k) (x : α) : | |
| PairCursor.mapState f g xs | |
| (reverse xs (fun y => wl (f y)) (fun y => wr (g y)) p P c v k hs hk x) = | |
| reverse (xs.map g) wl wr p P c v k ht hk' (f x) := by | |
| simp only [reverse, PairCursor.mapState, range] | |
| congr 1 | |
| rw [SliceModular.reverse_map g xs _ (fun y => wr y % P) ((v - wl (f x)) % P) k] | |
| congr 1 | |
| exact BinarySlice.range_map g xs (fun y => wr y % p) _ k hs ht hk hk' | |
| end FilteredRow | |
| namespace FilteredStream | |
| variable {α β γ δ : Type*} | |
| theorem key_map (f : α → γ) (g : β → δ) (wl : γ → ℤ) (wr : δ → ℤ) | |
| (P : ℤ) (mode : Mode) (x : α × β) : | |
| key (fun y => wl (f y)) (fun y => wr (g y)) P mode x = | |
| key wl wr P mode (Prod.map f g x) := by | |
| cases mode <;> rfl | |
| theorem row_map (f : α → γ) (g : β → δ) (right : Array β) | |
| (wl : γ → ℤ) (wr : δ → ℤ) (p P c : ℤ) | |
| (hs : FilteredRow.PrimarySorted right (fun y => wr (g y)) p) | |
| (ht : FilteredRow.PrimarySorted (right.map g) wr p) (mode : Mode) (x : α) : | |
| PairCursor.mapState f g right | |
| (row right (fun y => wl (f y)) (fun y => wr (g y)) p P c hs mode x) = | |
| row (right.map g) wl wr p P c ht mode (f x) := by | |
| cases mode with | |
| | direct => | |
| simpa only [row, Array.size_map] using | |
| FilteredRow.forward_map f g right wl wr p P c (steps right.size) hs ht | |
| (steps_sufficient right.size) (by simpa using steps_sufficient right.size) x | |
| | complementary v => | |
| simpa only [row, Array.size_map] using | |
| FilteredRow.reverse_map f g right wl wr p P c v (steps right.size) hs ht | |
| (steps_sufficient right.size) (by simpa using steps_sufficient right.size) x | |
| theorem rowArray_map (f : α → γ) (g : β → δ) (left : Array α) (right : Array β) | |
| (wl : γ → ℤ) (wr : δ → ℤ) (p P c : ℤ) | |
| (hs : FilteredRow.PrimarySorted right (fun y => wr (g y)) p) | |
| (ht : FilteredRow.PrimarySorted (right.map g) wr p) (mode : Mode) : | |
| (rowArray left right (fun y => wl (f y)) (fun y => wr (g y)) p P c hs mode).map | |
| (PairCursor.mapState f g right) = | |
| rowArray (left.map f) (right.map g) wl wr p P c ht mode := by | |
| apply Array.toList_inj.mp | |
| simp only [rowArray, Array.toList_map, List.map_map] | |
| congr 1 | |
| funext x | |
| exact row_map f g right wl wr p P c hs ht mode x | |
| theorem initial_tree_map (f : α → γ) (g : β → δ) (left : Array α) (right : Array β) | |
| (wl : γ → ℤ) (wr : δ → ℤ) (p P c : ℤ) | |
| (hs : FilteredRow.PrimarySorted right (fun y => wr (g y)) p) | |
| (ht : FilteredRow.PrimarySorted (right.map g) wr p) (mode : Mode) (d : ℕ) : | |
| Tournament.map (RowMerge.mapFront (Prod.map f g) (mapCursor f g right)) | |
| (RowMerge.start (key (fun y => wl (f y)) (fun y => wr (g y)) P mode) | |
| (read right) | |
| (PaddedRows.rows (rowArray left right (fun y => wl (f y)) | |
| (fun y => wr (g y)) p P c hs mode) d)) = | |
| RowMerge.start (key wl wr P mode) (read (right.map g)) | |
| (PaddedRows.rows (rowArray (left.map f) (right.map g) wl wr p P c ht mode) d) := by | |
| have he : key (fun y => wl (f y)) (fun y => wr (g y)) P mode = | |
| (fun x => key wl wr P mode (Prod.map f g x)) := by cases mode <;> rfl | |
| rw [he, RowMerge.start_map (Prod.map f g) (mapCursor f g right) | |
| (key wl wr P mode) (read right) (read (right.map g)) (read_map f g right)] | |
| congr 1 | |
| funext path | |
| change (PaddedRows.rows _ d path).map (PairCursor.mapState f g right) = _ | |
| rw [PaddedRows.rows_map, rowArray_map f g left right wl wr p P c hs ht mode] | |
| end FilteredStream | |
| end LowSpaceSubsetSum | |
| end OAI | |