| import OAI.NumberTheory.TwoPoint.Walks.ColumnChunks |
| import Mathlib.Data.Finset.Card |
|
|
| namespace OAI |
|
|
| /-! Exact decoder budgets for lists of actual perfect blocks. -/ |
|
|
| namespace TwoPointCorrelations |
|
|
| open Finset |
|
|
| variable {α : Type*} [DecidableEq α] |
|
|
| omit [DecidableEq α] in |
| @[simp] theorem regularPieceCount_append (a b : List (List α ⊕ α)) : |
| regularPieceCount (a ++ b) = regularPieceCount a + regularPieceCount b := by |
| simp [regularPieceCount, List.filterMap_append] |
|
|
| omit [DecidableEq α] in |
| @[simp] theorem omittedPieceCount_append (a b : List (List α ⊕ α)) : |
| omittedPieceCount (a ++ b) = omittedPieceCount a + omittedPieceCount b := by |
| simp [omittedPieceCount, List.filterMap_append] |
|
|
| /-- Interval-shaped label occurrences imply the concrete omitted-run budget. -/ |
| theorem block_omitted_piece_budget (l : List α) (omitted : Finset α) |
| (hinterval : ∀ i j k : Fin l.length, i ≤ j → j ≤ k → |
| l.get i = l.get k → l.get j = l.get i) : |
| omittedPieceCount (partitionColumnRuns (fun a => decide (a ∈ omitted)) |
| (columnRunHeads (l.map some) none)) ≤ omitted.card := by |
| let runs := columnRunHeads (l.map some) none |
| have hn : (runs.filter (fun a => decide (a ∈ omitted))).Nodup := |
| (columnRunHeads_nodup l hinterval).filter _ |
| change ((partitionColumnRuns _ runs).filterMap _).length ≤ _ |
| rw [partitionColumnRuns_omitted, ← List.toFinset_card_of_nodup hn] |
| apply card_le_card |
| intro a ha |
| exact of_decide_eq_true (List.mem_filter.mp (List.mem_toFinset.mp ha)).2 |
|
|
| theorem block_regular_piece_budget (l : List α) (omitted : Finset α) |
| (hinterval : ∀ i j k : Fin l.length, i ≤ j → j ≤ k → |
| l.get i = l.get k → l.get j = l.get i) : |
| regularPieceCount (partitionColumnRuns (fun a => decide (a ∈ omitted)) |
| (columnRunHeads (l.map some) none)) ≤ omitted.card + 1 := by |
| have ho := block_omitted_piece_budget l omitted hinterval |
| have hr := partitionColumnRuns_regular_count (fun a => decide (a ∈ omitted)) |
| (columnRunHeads (l.map some) none) |
| have he := congrArg List.length (partitionColumnRuns_omitted |
| (fun a => decide (a ∈ omitted)) (columnRunHeads (l.map some) none)) |
| change omittedPieceCount _ = _ at he |
| omega |
|
|
| def perfectChunkCount (chunks : List (List α ⊕ α)) : ℕ := |
| (chunks.filterMap (Sum.elim some (fun _ => none))).length |
|
|
| /-- Across actual perfect blocks, each omitted class is charged only once |
| per block, and every regular segment is charged to an omitted run or a block start. -/ |
| theorem columnChunk_piece_budgets (chunks : List (List α ⊕ α)) (omitted : Finset α) |
| (hinterval : ∀ l, Sum.inl l ∈ chunks → ∀ i j k : Fin l.length, i ≤ j → j ≤ k → |
| l.get i = l.get k → l.get j = l.get i) : |
| omittedPieceCount (columnChunkPieces (fun a => decide (a ∈ omitted)) chunks) ≤ |
| omitted.card * perfectChunkCount chunks ∧ |
| regularPieceCount (columnChunkPieces (fun a => decide (a ∈ omitted)) chunks) ≤ |
| (omitted.card + 1) * perfectChunkCount chunks := by |
| induction chunks with |
| | nil => simp [columnChunkPieces, perfectChunkCount, omittedPieceCount, regularPieceCount] |
| | cons chunk rest ih => |
| have hir := ih (fun l hl => hinterval l (List.mem_cons_of_mem _ hl)) |
| cases chunk with |
| | inl l => |
| have ho := block_omitted_piece_budget l omitted (hinterval l (List.mem_cons_self)) |
| have hr := block_regular_piece_budget l omitted (hinterval l (List.mem_cons_self)) |
| simp only [columnChunkPieces, List.flatMap_cons, Sum.elim_inl, |
| omittedPieceCount_append, regularPieceCount_append] |
| change _ ≤ omitted.card * (perfectChunkCount rest + 1) ∧ |
| _ ≤ (omitted.card + 1) * (perfectChunkCount rest + 1) |
| constructor |
| · change omittedPieceCount (partitionColumnRuns _ _) + |
| omittedPieceCount (columnChunkPieces _ rest) ≤ _ |
| calc |
| _ ≤ omitted.card + omitted.card * perfectChunkCount rest := Nat.add_le_add ho hir.1 |
| _ = _ := by ring |
| · change regularPieceCount (partitionColumnRuns _ _) + |
| regularPieceCount (columnChunkPieces _ rest) ≤ _ |
| calc |
| _ ≤ (omitted.card + 1) + (omitted.card + 1) * perfectChunkCount rest := |
| Nat.add_le_add hr hir.2 |
| _ = _ := by ring |
| | inr a => |
| simpa [columnChunkPieces, perfectChunkCount, List.filterMap_cons, Sum.elim] using hir |
|
|
| /-- The full merge mask fits in the original column length. -/ |
| theorem columnChunkPieces_length_le (omitted : α → Bool) (chunks : List (List α ⊕ α)) : |
| (columnChunkPieces omitted chunks).length ≤ (columnChunkEntries chunks).length := by |
| induction chunks with |
| | nil => rfl |
| | cons chunk rest ih => |
| cases chunk with |
| | inl l => |
| have hl := (partitionColumnRuns_length_le omitted (columnRunHeads (l.map some) none)).trans |
| (columnRunHeads_length_le (l.map some) none) |
| simp only [List.length_map] at hl |
| simpa only [columnChunkPieces, columnChunkEntries, List.flatMap_cons, Sum.elim_inl, |
| List.length_append, List.length_map] using Nat.add_le_add hl ih |
| | inr a => |
| simpa [columnChunkPieces, columnChunkEntries] using ih.trans (Nat.le_succ _) |
|
|
| end TwoPointCorrelations |
|
|
| end OAI |
|
|
