File size: 8,699 Bytes
180bc03 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 | 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
|