| import OAI.NumberTheory.TwoPoint.Bounds.RegularFamilyNames |
| import OAI.NumberTheory.TwoPoint.Walks.ColumnPieceMembership |
| import OAI.NumberTheory.TwoPoint.Walks.CanonicalColumnEncoding |
| import OAI.NumberTheory.TwoPoint.Walks.ColumnPatternRecovery |
|
|
| namespace OAI |
|
|
| /-! Assemble an actual column code from the shared forest of its regular paths. -/ |
|
|
| namespace TwoPointCorrelations |
|
|
| variable {α : Type*} [DecidableEq α] |
|
|
| theorem column_code_from_regular_forest {n N O I : ℕ} (hN : 0 < N) (hn : n ≤ N) |
| (label : Fin n → α) (perfect : Finset (Fin n)) |
| (regular : Finset α) (number : regular → ℕ) (lineNumber : α → ℕ) |
| (hnumber : ∀ z (hz : z ∈ regular), lineNumber z = number ⟨z, hz⟩) |
| (labelNat : ℕ → α) |
| (chunks : List (List α ⊕ α)) (blocks : List (ℕ × ℕ)) |
| (hentries : columnChunkEntries chunks = |
| (columnPositionEntries perfect).map (fun p => (label p.1, p.2))) |
| (hblocks : chunks.filterMap (Sum.elim some (fun _ => none)) = |
| blocks.map (fun b => blockLabelList labelNat b.1 b.2)) |
| (pathCode : ForestPathData.Code N |
| (indexedRegularSegments labelNat (fun z => decide (z ∉ regular)) blocks).length) |
| (hbound : ∀ segment ∈ indexedRegularSegments labelNat (fun z => decide (z ∉ regular)) blocks, |
| ∀ p ∈ segment, lineNumber p.2 < N) |
| (hinj : ∀ segment ∈ indexedRegularSegments labelNat (fun z => decide (z ∉ regular)) blocks, |
| ∀ p ∈ segment, |
| ∀ other ∈ indexedRegularSegments labelNat (fun z => decide (z ∉ regular)) blocks, |
| ∀ q ∈ other, lineNumber p.2 = lineNumber q.2 → p.2 = q.2) |
| (hdecode : List.ofFn (fun i => evenEntries (decodeForestPaths pathCode i)) = |
| (indexedRegularSegments labelNat (fun z => decide (z ∉ regular)) blocks).map |
| (fun segment => segment.map (fun p => lineNumber p.2))) |
| (hO : omittedPieceCount (columnChunkPieces (fun z => decide (z ∉ regular)) chunks) ≤ O) |
| (hI : ((columnPositionEntries perfect).filter (fun a => !a.2)).length ≤ I) : |
| ∃ code : ColumnDecoderCode N |
| (indexedRegularSegments labelNat (fun z => decide (z ∉ regular)) blocks).length O I, |
| (decodeColumnLabels code).take n = |
| List.ofFn (canonicalColumnName label perfect (forestPerfectName label perfect regular number)) ∧ |
| decodeColumnPrefixPattern hn code = (fun i j => decide (label i = label j)) := by |
| let isOmitted := fun z : α => decide (z ∉ regular) |
| let segments := indexedRegularSegments labelNat isOmitted blocks |
| let names := forestPerfectName label perfect regular number |
| let f := observedColumnName label perfect names |
| let raw := columnChunkPieces isOmitted chunks |
| let pieces := raw.map (Sum.map (List.map f) f) |
| let namedChunks := chunks.map (Sum.map (List.map f) f) |
| let cuts := columnChunkCuts namedChunks |
| have hprops := regular_family_name_properties label perfect regular number lineNumber hnumber |
| labelNat chunks blocks hentries hblocks hbound hinj |
| have heq (i j : Fin n) : f (label i) = f (label j) ↔ label i = label j := |
| observed_forest_name_eq_iff label perfect regular number hprops.2 i j |
| have hlocal : ∀ block, Sum.inl block ∈ chunks → |
| ∀ a ∈ block, ∀ b ∈ block, f a = f b ↔ a = b := by |
| intro block hb a ha b hbb |
| have ha' : (a, true) ∈ columnChunkEntries chunks := |
| List.mem_flatMap.mpr ⟨.inl block, hb, List.mem_map.mpr ⟨a, ha, rfl⟩⟩ |
| have hb' : (b, true) ∈ columnChunkEntries chunks := |
| List.mem_flatMap.mpr ⟨.inl block, hb, List.mem_map.mpr ⟨b, hbb, rfl⟩⟩ |
| obtain ⟨i, _, hi⟩ := perfect_label_position label perfect chunks hentries a ha' |
| obtain ⟨j, _, hj⟩ := perfect_label_position label perfect chunks hentries b hb' |
| simpa only [hi, hj] using heq i j |
| have hcuts : cuts.map Prod.fst = canonicalPerfectEntries label perfect names := by |
| change (columnChunkCuts namedChunks).map Prod.fst = _ |
| rw [columnChunkCuts_values] |
| change (columnChunkEntries (chunks.map (Sum.map (List.map f) f))).map _ = _ |
| rw [columnChunkEntries_map, hentries] |
| simp only [columnPositionEntries, List.map_ofFn, canonicalPerfectEntries, |
| Function.comp_def] |
| congr 1 |
| funext i |
| by_cases hi : i ∈ perfect <;> simp [f, observedColumnName_at, hi] |
| have hpieces : pieces.length ≤ N := by |
| change (raw.map _).length ≤ N |
| rw [List.length_map] |
| apply (columnChunkPieces_length_le isOmitted chunks).trans |
| rw [hentries, List.length_map] |
| simpa only [columnPositionEntries, List.length_ofFn] using hn |
| have hlabels : segments.map (List.map Prod.snd) = |
| raw.filterMap (Sum.elim some (fun _ => none)) := |
| indexedRegularSegments_eq_regular_pieces labelNat isOmitted chunks blocks hblocks |
| have hregularName : ∀ segment ∈ segments, ∀ p ∈ segment, |
| f p.2 = .regular (lineNumber p.2) := by |
| intro segment hs p hp |
| have hs' : segment.map Prod.snd ∈ raw.filterMap (Sum.elim some (fun _ => none)) := by |
| rw [← hlabels] |
| exact List.mem_map.mpr ⟨segment, hs, rfl⟩ |
| obtain ⟨piece, hpiece, hs'⟩ := List.mem_filterMap.mp hs' |
| have hinl : Sum.inl (segment.map Prod.snd) ∈ raw := by |
| cases piece with |
| | inl l => cases hs'; exact hpiece |
| | inr a => simp at hs' |
| have hm := (columnChunkPieces_regular_membership isOmitted chunks _ hinl).2 p.2 |
| (List.mem_map.mpr ⟨p, hp, rfl⟩) |
| have hr : p.2 ∈ regular := by simpa only [isOmitted, decide_eq_false_iff_not, not_not] using hm.1 |
| obtain ⟨i, hip, hi⟩ := perfect_label_position label perfect chunks hentries p.2 hm.2 |
| have hir : label i ∈ regular := hi.symm ▸ hr |
| have hn' : lineNumber p.2 = number ⟨label i, hir⟩ := by |
| rw [← hi] |
| exact hnumber (label i) hir |
| calc |
| f p.2 = f (label i) := congrArg f hi.symm |
| _ = .regular (number ⟨label i, hir⟩) := observed_forest_name_regular label perfect regular number i hip hir |
| _ = _ := congrArg CanonicalColumnLabel.regular hn'.symm |
| have hregular : List.ofFn (fun i => (evenEntries (decodeForestPaths pathCode i)).map |
| CanonicalColumnLabel.regular) = pieces.filterMap (Sum.elim some (fun _ => none)) := by |
| have hd := congrArg (List.map (List.map CanonicalColumnLabel.regular)) hdecode |
| simp only [List.map_ofFn, List.map_map, Function.comp_def] at hd |
| calc |
| _ = segments.map (fun segment => segment.map (fun p => .regular (lineNumber p.2))) := hd |
| _ = segments.map (fun segment => segment.map (fun p => f p.2)) := by |
| apply List.map_congr_left |
| intro segment hs |
| apply List.map_congr_left |
| intro p hp |
| exact (hregularName segment hs p hp).symm |
| _ = (segments.map (List.map Prod.snd)).map (List.map f) := by |
| simp only [List.map_map, Function.comp_def] |
| _ = (raw.filterMap (Sum.elim some (fun _ => none))).map (List.map f) := by rw [hlabels] |
| _ = _ := (mapped_pieces_regular f raw).symm |
| have homit : ∀ a ∈ pieces.filterMap (Sum.elim (fun _ => none) some), |
| ∃ j : Fin N, a = .omitted j.val := by |
| intro a ha |
| change a ∈ (raw.map (Sum.map (List.map f) f)).filterMap _ at ha |
| rw [mapped_pieces_omitted] at ha |
| obtain ⟨z, hz, rfl⟩ := List.mem_map.mp ha |
| obtain ⟨piece, hp, hz⟩ := List.mem_filterMap.mp hz |
| have hinr : Sum.inr z ∈ raw := by |
| cases piece with |
| | inl l => simp at hz |
| | inr b => cases hz; exact hp |
| have hm := columnChunkPieces_omitted_membership isOmitted chunks z hinr |
| have hr : z ∉ regular := of_decide_eq_true hm.1 |
| obtain ⟨i, hip, hi⟩ := perfect_label_position label perfect chunks hentries z hm.2 |
| have hir : label i ∉ regular := hi.symm ▸ hr |
| refine ⟨Fin.castLE hn (columnRepresentative label perfect i), ?_⟩ |
| simpa only [f, names, hi, Fin.val_castLE] using |
| observed_forest_name_omitted label perfect regular number i hip hir |
| obtain ⟨omittedNames, holen, homap⟩ := omitted_names_lift _ homit |
| have ho : omittedNames.length ≤ O := by |
| rw [holen] |
| change ((raw.map (Sum.map (List.map f) f)).filterMap _).length ≤ O |
| rw [mapped_pieces_omitted, List.length_map] |
| exact hO |
| have hheads : pieces.flatMap (Sum.elim id List.singleton) = columnRunHeadsWithCuts cuts none := |
| mapped_column_pieces_heads f isOmitted chunks hlocal |
| obtain ⟨code, hprefix⟩ := canonical_column_encoding hN hn label perfect names pathCode cuts hcuts pieces hpieces [] |
| (by simpa only [List.append_nil] using hregular) omittedNames ho homap.symm hheads hI |
| exact ⟨code, hprefix, column_prefix_pattern_recovers hn code label _ hprefix |
| (canonical_forest_name_eq_iff label perfect regular number hprops.2)⟩ |
| |
| end TwoPointCorrelations |
| |
| end OAI |
| |
