| import OAI.NumberTheory.TwoPoint.Walks.CanonicalColumnNames |
| import OAI.NumberTheory.TwoPoint.Walks.ColumnEncodingRealization |
|
|
| namespace OAI |
|
|
| /-! Occurrence representatives recover all equalities involving imperfect positions. -/ |
|
|
| namespace TwoPointCorrelations |
|
|
| private theorem reference_filterMap_length {α β : Type*} (reference : α → β) |
| (entries : List (α × Bool)) : |
| (entries.filterMap (fun a => if a.2 then none else some (reference a.1))).length = |
| (entries.filter (fun a => !a.2)).length := by |
| induction entries with |
| | nil => rfl |
| | cons entry rest ih => |
| rcases entry with ⟨a, flag⟩ |
| cases flag <;> simp [ih] |
|
|
| /-- Once the regular-path and omitted-run geometry is encoded, all remaining |
| positions use their proved canonical representatives; no reference lookup |
| or equality-pattern reconstruction hypothesis is needed. -/ |
| theorem canonical_column_encoding {α : Type*} [DecidableEq α] |
| {n N segments omitted imperfect : ℕ} (hN : 0 < N) (hn : n ≤ N) |
| (label : Fin n → α) (perfect : Finset (Fin n)) (name : Fin n → ℕ ⊕ ℕ) |
| (pathCode : ForestPathData.Code N segments) |
| (cuts : List (Option CanonicalColumnLabel × Bool)) |
| (hcuts : cuts.map Prod.fst = canonicalPerfectEntries label perfect name) |
| (pieces : List (List CanonicalColumnLabel ⊕ CanonicalColumnLabel)) |
| (hpieces : pieces.length ≤ N) |
| (regularTail : List (List CanonicalColumnLabel)) |
| (hregular : List.ofFn (fun i => (evenEntries (decodeForestPaths pathCode i)).map |
| CanonicalColumnLabel.regular) = |
| pieces.filterMap (Sum.elim some (fun _ => none)) ++ regularTail) |
| (omittedNames : List (Fin N)) (homittedSize : omittedNames.length ≤ omitted) |
| (homitted : pieces.filterMap (Sum.elim (fun _ => none) some) = |
| omittedNames.map (fun j => CanonicalColumnLabel.omitted j.val)) |
| (hheads : pieces.flatMap (Sum.elim id List.singleton) = columnRunHeadsWithCuts cuts none) |
| (hI : ((columnPositionEntries perfect).filter (fun a => !a.2)).length ≤ imperfect) : |
| ∃ code : ColumnDecoderCode N segments omitted imperfect, |
| (decodeColumnLabels code).take n = List.ofFn (canonicalColumnName label perfect name) := by |
| let reference : Fin n → Fin N := fun i => Fin.castLE hn (columnRepresentative label perfect i) |
| have h := column_encoding_realization (imperfect := imperfect) hN (canonicalColumnName label perfect name) pathCode |
| (columnPositionEntries perfect) (by simpa [columnPositionEntries] using hn) |
| cuts (hcuts.trans (marked_position_entries label perfect name).symm) |
| pieces hpieces regularTail hregular omittedNames homittedSize homitted hheads reference |
| (by rw [reference_filterMap_length]; exact hI) |
| (by intro a _ _; simpa only [reference, columnPositionEntries, List.length_ofFn, Fin.val_castLE] using |
| (columnRepresentative label perfect a.1).isLt) |
| (by intro a _ _; rw [marked_position_entries]; exact canonical_reference_resolves label perfect name a.1) |
| simpa only [columnPositionEntries, List.length_ofFn, List.map_ofFn, Function.comp_def] using h |
|
|
| end TwoPointCorrelations |
|
|
| end OAI |
|
|
