| import OAI.NumberTheory.TwoPoint.Walks.IndexedBlockFamily |
| import OAI.NumberTheory.TwoPoint.Walks.ColumnNameTransport |
|
|
| namespace OAI |
|
|
| /-! Identify the shared indexed path family with the actual decoder pieces. -/ |
|
|
| namespace TwoPointCorrelations |
|
|
| variable {α : Type*} [DecidableEq α] |
|
|
| theorem columnChunkPieces_via_blocks (omitted : α → Bool) (chunks : List (List α ⊕ α)) : |
| columnChunkPieces omitted chunks = |
| (chunks.filterMap (Sum.elim some (fun _ => none))).flatMap |
| (fun block => partitionColumnRuns omitted (columnRunHeads (block.map some) none)) := by |
| induction chunks with |
| | nil => rfl |
| | cons chunk chunks ih => |
| cases chunk with |
| | inl block => |
| simpa only [columnChunkPieces, List.flatMap_cons, List.filterMap_cons, Sum.elim_inl] using |
| congrArg (fun rest => partitionColumnRuns omitted |
| (columnRunHeads (block.map some) none) ++ rest) ih |
| | inr a => |
| simpa only [columnChunkPieces, List.flatMap_cons, List.filterMap_cons, |
| Sum.elim_inr, List.nil_append] using ih |
|
|
| theorem columnChunkPieces_from_intervals (label : ℕ → α) (omitted : α → Bool) |
| (chunks : List (List α ⊕ α)) (blocks : List (ℕ × ℕ)) |
| (hblocks : chunks.filterMap (Sum.elim some (fun _ => none)) = |
| blocks.map (fun b => blockLabelList label b.1 b.2)) : |
| columnChunkPieces omitted chunks = blocks.flatMap (fun b => |
| partitionColumnRuns omitted (columnRunHeads ((blockLabelList label b.1 b.2).map some) none)) := by |
| rw [columnChunkPieces_via_blocks, hblocks, List.flatMap_map] |
|
|
| /-- Forgetting the stored run-start indices gives exactly the regular |
| piece list consumed by the column decoder, in the same order. -/ |
| theorem indexedRegularSegments_labels (label : ℕ → α) (omitted : α → Bool) |
| (blocks : List (ℕ × ℕ)) : |
| (indexedRegularSegments label omitted blocks).map (List.map Prod.snd) = |
| (blocks.flatMap (fun b => partitionColumnRuns omitted |
| (columnRunHeads ((blockLabelList label b.1 b.2).map some) none))).filterMap |
| (Sum.elim some (fun _ => none)) := by |
| induction blocks with |
| | nil => rfl |
| | cons b blocks ih => |
| change ((_ ++ indexedRegularSegments label omitted blocks).map (List.map Prod.snd)) = _ |
| rw [List.map_append] |
| simp only [List.flatMap_cons, List.filterMap_append] |
| rw [ih] |
| congr 1 |
| rw [← mapped_pieces_regular, indexedBlockRuns_partition] |
|
|
| theorem indexedRegularSegments_eq_regular_pieces (label : ℕ → α) (omitted : α → Bool) |
| (chunks : List (List α ⊕ α)) (blocks : List (ℕ × ℕ)) |
| (hblocks : chunks.filterMap (Sum.elim some (fun _ => none)) = |
| blocks.map (fun b => blockLabelList label b.1 b.2)) : |
| (indexedRegularSegments label omitted blocks).map (List.map Prod.snd) = |
| (columnChunkPieces omitted chunks).filterMap (Sum.elim some (fun _ => none)) := by |
| rw [columnChunkPieces_from_intervals label omitted chunks blocks hblocks] |
| exact indexedRegularSegments_labels label omitted blocks |
|
|
| omit [DecidableEq α] in |
| /-- Every original perfect occurrence belongs to one of the actual perfect |
| blocks. This includes occurrences immediately next to imperfect positions. -/ |
| theorem perfect_entry_mem_block (chunks : List (List α ⊕ α)) (a : α) |
| (ha : (a, true) ∈ columnChunkEntries chunks) : |
| ∃ block, Sum.inl block ∈ chunks ∧ a ∈ block := by |
| obtain ⟨chunk, hc, ha⟩ := List.mem_flatMap.mp ha |
| cases chunk with |
| | inl block => |
| obtain ⟨b, hb, heq⟩ := List.mem_map.mp ha |
| have he : b = a := congrArg Prod.fst heq |
| exact ⟨block, hc, he ▸ hb⟩ |
| | inr b => |
| have heq := List.mem_singleton.mp ha |
| have hfalse : false = true := (congrArg Prod.snd heq).symm |
| contradiction |
|
|
| /-- Every regular perfect label appears in the actual indexed path family. -/ |
| theorem perfect_regular_entry_covered (label : ℕ → α) (omitted : α → Bool) |
| (chunks : List (List α ⊕ α)) (blocks : List (ℕ × ℕ)) |
| (hblocks : chunks.filterMap (Sum.elim some (fun _ => none)) = |
| blocks.map (fun b => blockLabelList label b.1 b.2)) |
| (a : α) (ha : (a, true) ∈ columnChunkEntries chunks) (hr : omitted a = false) : |
| ∃ segment ∈ indexedRegularSegments label omitted blocks, ∃ p ∈ segment, p.2 = a := by |
| obtain ⟨block, hb, hab⟩ := perfect_entry_mem_block chunks a ha |
| have hm : block ∈ chunks.filterMap (Sum.elim some (fun _ => none)) := |
| List.mem_filterMap.mpr ⟨.inl block, hb, rfl⟩ |
| rw [hblocks] at hm |
| obtain ⟨b, hbb, he⟩ := List.mem_map.mp hm |
| apply indexedRegularSegments_cover label omitted blocks b hbb a _ hr |
| rwa [he] |
|
|
| end TwoPointCorrelations |
|
|
| end OAI |
|
|
