| import OAI.NumberTheory.TwoPoint.Walks.ColumnBoundaryEncoding |
| import OAI.NumberTheory.TwoPoint.Bounds.PaddedListCode |
|
|
| namespace OAI |
|
|
| /-! A full column code from path segments, omitted runs and occurrence references. -/ |
|
|
| namespace TwoPointCorrelations |
|
|
| private def columnPieceMask (pieces : List (List CanonicalColumnLabel ⊕ CanonicalColumnLabel)) : |
| List Bool := pieces.map (Sum.elim (fun _ => true) (fun _ => false)) |
|
|
| private def columnPieceRegular (pieces : List (List CanonicalColumnLabel ⊕ CanonicalColumnLabel)) : |
| List (List CanonicalColumnLabel) := |
| pieces.filterMap (Sum.elim some (fun _ => none)) |
|
|
| private def columnPieceOmitted (pieces : List (List CanonicalColumnLabel ⊕ CanonicalColumnLabel)) : |
| List CanonicalColumnLabel := |
| pieces.filterMap (Sum.elim (fun _ => none) some) |
|
|
| private def columnPieceFlatten (pieces : List (List CanonicalColumnLabel ⊕ CanonicalColumnLabel)) : |
| List CanonicalColumnLabel := |
| pieces.flatMap (Sum.elim id List.singleton) |
|
|
| theorem resolveColumnReference_append (full padding : List (Option CanonicalColumnLabel)) |
| (j : ℕ) (hj : j < full.length) : |
| resolveColumnReference (full ++ padding) j = resolveColumnReference full j := by |
| simp only [resolveColumnReference, List.getElem?_append_left hj] |
|
|
| / |
| of regular segments with omitted runs. No full equality-pattern or decoder |
| conclusion is assumed. All unused slots may be padded independently. -/ |
| theorem column_encoding_realization {α : Type*} {N segments omitted imperfect : ℕ} (hN : 0 < N) |
| (name : α → CanonicalColumnLabel) |
| (pathCode : ForestPathData.Code N segments) |
| (entries : List (α × Bool)) (hentries : entries.length ≤ N) |
| (cuts : List (Option CanonicalColumnLabel × Bool)) |
| (hcuts : cuts.map Prod.fst = markedColumn name entries) |
| (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) = |
| columnPieceRegular pieces ++ regularTail) |
| (omittedNames : List (Fin N)) (homittedSize : omittedNames.length ≤ omitted) |
| (homitted : columnPieceOmitted pieces = |
| omittedNames.map (fun j => CanonicalColumnLabel.omitted j.val)) |
| (hheads : columnPieceFlatten pieces = columnRunHeadsWithCuts cuts none) |
| (reference : α → Fin N) |
| (hreferenceSize : |
| (entries.filterMap (fun a => if a.2 then none else some (reference a.1))).length ≤ imperfect) |
| (hreferenceBound : ∀ a ∈ entries, a.2 = false → (reference a.1).val < entries.length) |
| (hreference : ∀ a ∈ entries, a.2 = false → |
| resolveColumnReference (markedColumn name entries) (reference a.1).val = name a.1) : |
| ∃ code : ColumnDecoderCode N segments omitted imperfect, |
| (decodeColumnLabels code).take entries.length = entries.map (fun a => name a.1) := by |
| let zero : Fin N := ⟨0, hN⟩ |
| let marked := markedColumn name entries |
| let flags := columnFlagsWithCuts cuts none |
| have hflags : flags.length ≤ N := by |
| have hc := congrArg List.length hcuts |
| simp only [List.length_map, markedColumn] at hc |
| simpa only [flags, columnFlagsWithCuts_length] using hc.le.trans hentries |
| have hmask : (columnPieceMask pieces).length ≤ N := by |
| simpa only [columnPieceMask, List.length_map] using hpieces |
| let refs := entries.filterMap (fun a => if a.2 then none else some (reference a.1)) |
| let code : ColumnDecoderCode N segments omitted imperfect := |
| (pathCode, paddedListCode (columnPieceMask pieces) hmask false, |
| paddedListCode flags hflags (false, false), |
| paddedListCode omittedNames homittedSize zero, |
| paddedListCode refs hreferenceSize zero) |
| let omittedTail := (List.replicate (omitted - omittedNames.length) zero).map |
| (fun j => CanonicalColumnLabel.omitted j.val) |
| let maskPadding := List.replicate (N - (columnPieceMask pieces).length) false |
| let extraRuns := mergeColumnRuns maskPadding regularTail omittedTail |
| have hpaths : List.ofFn (fun i => (evenEntries (decodeForestPaths code.1 i)).map |
| CanonicalColumnLabel.regular) = columnPieceRegular pieces ++ regularTail := by |
| change List.ofFn (fun i => (evenEntries (decodeForestPaths pathCode i)).map |
| CanonicalColumnLabel.regular) = _ |
| exact hregular |
| have homit : List.ofFn (fun i => CanonicalColumnLabel.omitted (code.2.2.2.1 i).val) = |
| columnPieceOmitted pieces ++ omittedTail := by |
| change List.ofFn (fun i => CanonicalColumnLabel.omitted |
| (paddedListCode omittedNames homittedSize zero i).val) = _ |
| rw [List.ofFn_comp' (paddedListCode omittedNames homittedSize zero) |
| (fun j : Fin N => CanonicalColumnLabel.omitted j.val), |
| paddedListCode_ofFn, List.map_append, ← homitted] |
| have hruns : mergeColumnRuns (List.ofFn code.2.1) |
| (List.ofFn (fun i => (evenEntries (decodeForestPaths code.1 i)).map CanonicalColumnLabel.regular)) |
| (List.ofFn (fun i => CanonicalColumnLabel.omitted (code.2.2.2.1 i).val)) = |
| columnRunHeadsWithCuts cuts none ++ extraRuns := by |
| rw [hpaths, homit] |
| change mergeColumnRuns (List.ofFn (paddedListCode (columnPieceMask pieces) hmask false)) _ _ = _ |
| rw [paddedListCode_ofFn] |
| have hm := mergeColumnRuns_append pieces maskPadding regularTail omittedTail |
| have hm' : mergeColumnRuns (columnPieceMask pieces ++ maskPadding) |
| (columnPieceRegular pieces ++ regularTail) (columnPieceOmitted pieces ++ omittedTail) = |
| columnPieceFlatten pieces ++ extraRuns := by |
| simpa only [columnPieceMask, columnPieceRegular, columnPieceOmitted, |
| columnPieceFlatten, extraRuns] using hm |
| rw [hheads] at hm' |
| exact hm' |
| let full := expandColumnRuns (List.ofFn code.2.2.1) (columnRunHeadsWithCuts cuts none ++ extraRuns) none |
| have hfullPrefix : full.take entries.length = marked := by |
| have ht := expandColumnRuns_take_append flags (List.replicate (N - flags.length) (false, false)) |
| (columnRunHeadsWithCuts cuts none ++ extraRuns) none |
| rw [expandColumnRuns_cuts_recover] at ht |
| rw [hcuts] at ht |
| change (expandColumnRuns (List.ofFn (paddedListCode flags hflags (false, false))) |
| (columnRunHeadsWithCuts cuts none ++ extraRuns) none).take entries.length = marked |
| rw [paddedListCode_ofFn] |
| have hc : cuts.length = entries.length := by |
| have hh := congrArg List.length hcuts |
| simpa only [List.length_map, markedColumn] using hh |
| simpa only [flags, columnFlagsWithCuts_length, hc, marked] using ht |
| have hfull : full = marked ++ full.drop entries.length := by |
| rw [← hfullPrefix] |
| exact (List.take_append_drop _ _).symm |
| have hlookup : ∀ a ∈ entries, a.2 = false → |
| resolveColumnReference full (reference a.1).val = name a.1 := by |
| intro a ha hp |
| rw [hfull, resolveColumnReference_append] |
| · exact hreference a ha hp |
| · simpa only [marked, markedColumn, List.length_map] using hreferenceBound a ha hp |
| have hrefs : List.ofFn (fun i => (code.2.2.2.2 i).val) = |
| imperfectColumnReferences (fun a => (reference a).val) entries ++ |
| (List.replicate (imperfect - refs.length) zero).map Fin.val := by |
| change List.ofFn (fun i => (paddedListCode refs hreferenceSize zero i).val) = _ |
| rw [List.ofFn_comp', paddedListCode_ofFn, List.map_append] |
| congr 1 |
| simp only [refs, imperfectColumnReferences, List.map_filterMap] |
| apply List.filterMap_congr |
| intro a _ |
| cases a.2 <;> rfl |
| have hatt := attachImperfectLabels_recover_append full name (fun a => (reference a).val) |
| entries (full.drop entries.length) |
| ((List.replicate (imperfect - refs.length) zero).map Fin.val) hlookup |
| refine ⟨code, ?_⟩ |
| have hdecode : decodeColumnLabels code = |
| entries.map (fun a => name a.1) ++ attachImperfectLabels full (full.drop entries.length) |
| ((List.replicate (imperfect - refs.length) zero).map Fin.val) := by |
| dsimp only [decodeColumnLabels] |
| rw [hruns] |
| change attachImperfectLabels full full (List.ofFn (fun i => (code.2.2.2.2 i).val)) = _ |
| rw [hrefs] |
| calc |
| _ = attachImperfectLabels full (marked ++ full.drop entries.length) |
| (imperfectColumnReferences (fun a => (reference a).val) entries ++ |
| (List.replicate (imperfect - refs.length) zero).map Fin.val) := |
| congrArg (fun l => attachImperfectLabels full l _) hfull |
| _ = _ := hatt |
| rw [hdecode] |
| simpa only [List.length_map] using |
| (List.take_left (l₁ := entries.map (fun a => name a.1)) |
| (l₂ := attachImperfectLabels full (full.drop entries.length) |
| ((List.replicate (imperfect - refs.length) zero).map Fin.val))) |
|
|
| end TwoPointCorrelations |
|
|
| end OAI |
|
|
