File size: 9,380 Bytes
e63eb7f | 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 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 | import OAI.Combinatorics.EditApproximation.Coarse.CoarseArrayRepresentation
namespace OAI
namespace EditApproximation
namespace BinaryFraction
private theorem coarseMin_result (a b : BinaryFraction) :
(minWithWork a b).1 = a ∨ (minWithWork a b).1 = b := by
unfold minWithWork
dsimp only
split_ifs <;> simp only [true_or, or_true]
theorem coarseGridScan_den (two previous : BinaryFraction) (source : List BinaryFraction)
(hp : previous.representation.den = two.representation.den)
(hs : ∀ a ∈ source, a.representation.den = two.representation.den) :
∀ a ∈ (coarseGridScanWithWork two previous source).1,
a.representation.den = two.representation.den := by
induction source generalizing previous with
| nil => simpa only [coarseGridScanWithWork, List.mem_singleton] using
(fun a (ha : a = previous) => ha ▸ hp)
| cons head rest ih =>
have hh := hs head List.mem_cons_self
have ha := (coarseGridAddWithWork_den previous two).trans hp
have hn : (minWithWork head (coarseGridAddWithWork previous two).1).1.representation.den =
two.representation.den := by
rcases coarseMin_result head (coarseGridAddWithWork previous two).1 with h | h
· simpa only [h] using hh
· simpa only [h] using ha
intro a hmem
change a ∈ previous :: _ at hmem
rcases List.mem_cons.mp hmem with rfl | hmem
· exact hp
· exact ih _ hn (fun a ha => hs a (List.mem_cons_of_mem _ ha)) a hmem
theorem coarseGridLeft_den (two : BinaryFraction) (source : List BinaryFraction)
(hs : ∀ a ∈ source, a.representation.den = two.representation.den) :
∀ a ∈ (coarseGridLeftWithWork two source).1,
a.representation.den = two.representation.den := by
cases source with
| nil => simp only [coarseGridLeftWithWork, List.not_mem_nil, false_implies, implies_true]
| cons head rest =>
exact coarseGridScan_den two head rest (hs head List.mem_cons_self)
(fun a ha => hs a (List.mem_cons_of_mem _ ha))
theorem coarseGridZipMinimum_den (left right : List BinaryFraction) (D : ℕ)
(hl : ∀ a ∈ left, a.representation.den = D)
(hr : ∀ a ∈ right, a.representation.den = D) :
∀ a ∈ (coarseGridZipMinimumWithWork left right).1, a.representation.den = D := by
induction left generalizing right with
| nil => simp only [coarseGridZipMinimumWithWork, List.not_mem_nil, false_implies, implies_true]
| cons a left ih =>
cases right with
| nil => simp only [coarseGridZipMinimumWithWork, List.not_mem_nil, false_implies, implies_true]
| cons b right =>
intro c hc
change c ∈ (minWithWork a b).1 :: _ at hc
rcases List.mem_cons.mp hc with rfl | hc
· rcases coarseMin_result a b with h | h
· simpa only [h] using hl a List.mem_cons_self
· simpa only [h] using hr b List.mem_cons_self
· exact ih right (fun a ha => hl a (List.mem_cons_of_mem _ ha))
(fun b hb => hr b (List.mem_cons_of_mem _ hb)) c hc
theorem coarseGridPenalty_den (two : BinaryFraction) (source : List BinaryFraction)
(hs : ∀ a ∈ source, a.representation.den = two.representation.den) :
∀ a ∈ (coarseGridPenaltyWithWork two source).1,
a.representation.den = two.representation.den := by
apply coarseGridZipMinimum_den
· exact coarseGridLeft_den two source hs
· intro a ha
exact coarseGridLeft_den two source.reverse
(fun b hb => hs b (List.mem_reverse.mp hb)) a (List.mem_reverse.mp ha)
theorem coarseGridZipAdd_den (left right : List BinaryFraction) (D : ℕ)
(hl : ∀ a ∈ left, a.representation.den = D) :
∀ a ∈ (coarseGridZipAddWithWork left right).1, a.representation.den = D := by
induction left generalizing right with
| nil => simp only [coarseGridZipAddWithWork, List.not_mem_nil, false_implies, implies_true]
| cons a left ih =>
cases right with
| nil => simp only [coarseGridZipAddWithWork, List.not_mem_nil, false_implies, implies_true]
| cons b right =>
intro c hc
change c ∈ (coarseGridAddWithWork a b).1 :: _ at hc
rcases List.mem_cons.mp hc with rfl | hc
· exact (coarseGridAddWithWork_den a b).trans (hl a List.mem_cons_self)
· exact ih right (fun a ha => hl a (List.mem_cons_of_mem _ ha)) c hc
/-- The array relation ignores proof fields and keeps exact stored values. -/
def CoarseArrayRep {n : ℕ} (actual : CoarseBinaryArray) (spec : CoarseStoredArray n) : Prop :=
coarseBinaryContents actual = coarseRationalContents spec
def CoarseArrayOnGrid (D : ℕ) (actual : CoarseBinaryArray) : Prop :=
∀ values, actual = some values → ∀ a ∈ values, a.representation.den = D
theorem coarseBinaryAdd_grid (a b : CoarseBinaryArray) (D : ℕ)
(ha : CoarseArrayOnGrid D a) (hb : CoarseArrayOnGrid D b) :
CoarseArrayOnGrid D (coarseBinaryAddWithWork a b).1 := by
cases a with
| none => exact hb
| some a =>
cases b with
| none => exact ha
| some b =>
intro values hv
have heq : (coarseGridZipAddWithWork a b).1 = values := Option.some.inj hv
rw [← heq]
exact coarseGridZipAdd_den a b D (ha a rfl)
theorem coarseBinaryPenalty_grid (two : BinaryFraction) (a : CoarseBinaryArray)
(ha : CoarseArrayOnGrid two.representation.den a) :
CoarseArrayOnGrid two.representation.den (coarseBinaryPenaltyWithWork two a).1 := by
cases a with
| none => intro values hv; cases hv
| some a =>
intro values hv
have heq : (coarseGridPenaltyWithWork two a).1 = values := Option.some.inj hv
rw [← heq]
exact coarseGridPenalty_den two a (ha a rfl)
theorem coarseBinaryMap_grid (f : BinaryFraction → BinaryFraction × ℕ) (a : CoarseBinaryArray)
(D : ℕ) (ha : CoarseArrayOnGrid D a)
(hf : ∀ z, z.representation.den = D → (f z).1.representation.den = D) :
CoarseArrayOnGrid D (coarseBinaryMapWithWork f a).1 := by
cases a with
| none => intro values hv; cases hv
| some a =>
intro values hv z hz
have heq : (arithmeticMapWithWork f a).1 = values := Option.some.inj hv
rw [← heq, arithmeticMapWithWork_value] at hz
obtain ⟨x, hx, rfl⟩ := List.mem_map.mp hz
exact hf x (ha a rfl x hx)
def coarseContentsAdd : Option (List ℚ) → Option (List ℚ) → Option (List ℚ)
| none, b => b
| a, none => a
| some a, some b => some (List.zipWith (· + ·) a b)
theorem coarseStoredAdd_contents {n : ℕ} (a b : CoarseStoredArray n) :
coarseRationalContents (coarseStoredAdd a b).1 =
coarseContentsAdd (coarseRationalContents a) (coarseRationalContents b) := by
cases a <;> cases b <;> rfl
theorem coarseBinaryAdd_contents (a b : CoarseBinaryArray) (D : ℕ)
(ha : ∀ values, a = some values → ∀ x ∈ values, x.representation.den = D)
(hb : ∀ values, b = some values → ∀ x ∈ values, x.representation.den = D) :
coarseBinaryContents (coarseBinaryAddWithWork a b).1 =
coarseContentsAdd (coarseBinaryContents a) (coarseBinaryContents b) := by
cases a with
| none => rfl
| some a =>
cases b with
| none => rfl
| some b =>
exact congrArg some (coarseGridZipAddWithWork_value a b
(fun x hx y hy => (ha a rfl x hx).trans (hb b rfl y hy).symm))
theorem coarseBinaryAdd_rep {n : ℕ} (a b : CoarseBinaryArray) (x y : CoarseStoredArray n)
(D : ℕ) (hx : CoarseArrayRep a x) (hy : CoarseArrayRep b y)
(ha : ∀ values, a = some values → ∀ z ∈ values, z.representation.den = D)
(hb : ∀ values, b = some values → ∀ z ∈ values, z.representation.den = D) :
CoarseArrayRep (coarseBinaryAddWithWork a b).1 (coarseStoredAdd x y).1 := by
change coarseBinaryContents _ = coarseRationalContents _
rw [coarseBinaryAdd_contents a b D ha hb, coarseStoredAdd_contents, hx, hy]
theorem coarseStoredPenalty_contents {n : ℕ} (a : CoarseStoredArray n) :
coarseRationalContents (coarseStoredPenalty a).1 =
(coarseRationalContents a).map coarsePenaltyTransform := by
cases a with
| none => rfl
| some a =>
exact congrArg some (coarseCostedPenaltyTransform_result a.1).1
theorem coarseBinaryPenalty_rep {n : ℕ} (two : BinaryFraction) (a : CoarseBinaryArray)
(x : CoarseStoredArray n) (htwo : two.value = 2) (hx : CoarseArrayRep a x)
(ha : ∀ values, a = some values → ∀ z ∈ values, z.representation.den = two.representation.den) :
CoarseArrayRep (coarseBinaryPenaltyWithWork two a).1 (coarseStoredPenalty x).1 := by
change coarseBinaryContents _ = coarseRationalContents _
rw [coarseStoredPenalty_contents, ← hx]
cases a with
| none => rfl
| some a => exact coarseBinaryPenaltyWithWork_value two a htwo (ha a rfl)
theorem coarseStoredMap_contents {n : ℕ} (f : ℚ → ℚ) (a : CoarseStoredArray n) :
coarseRationalContents (coarseStoredMap f a).1 = (coarseRationalContents a).map (List.map f) := by
cases a <;> rfl
theorem coarseBinaryMap_rep {n : ℕ} (f : BinaryFraction → BinaryFraction × ℕ) (g : ℚ → ℚ)
(hf : ∀ a, (f a).1.value = g a.value) (a : CoarseBinaryArray) (x : CoarseStoredArray n)
(hx : CoarseArrayRep a x) :
CoarseArrayRep (coarseBinaryMapWithWork f a).1 (coarseStoredMap g x).1 := by
change coarseBinaryContents _ = coarseRationalContents _
rw [coarseBinaryMapWithWork_value f g hf, coarseStoredMap_contents, hx]
end BinaryFraction
end EditApproximation
end OAI
|