openAI-math-dataset / lean /OAI /Combinatorics /EditApproximation /Coarse /CoarseArraySimulation.lean
| 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 | |