File size: 8,760 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 157 158 159 160 | 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]
/-- The geometric inputs are exact regular path lists and an interleaving
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
|