openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /Numerical /AllFieldCertificates.lean
| import OAI.LinearAlgebra.MatrixMultiplication.Numerical.ComplexRationalLogCertificate | |
| namespace OAI | |
| /-! Exact rational intervals, logarithm bounds and arithmetic circuit soundness. -/ | |
| namespace MatrixMultiplication.AllFieldCertificates | |
| open MatrixMultiplication.Foundation.RationalLogCertificate | |
| structure Ball where | |
| center : ℚ | |
| radius : ℚ | |
| deriving DecidableEq | |
| namespace Ball | |
| def Encloses (b : Ball) (x : ℝ) : Prop := |x - (b.center : ℝ)| ≤ (b.radius : ℝ) | |
| def exact (q : ℚ) : Ball := ⟨q, 0⟩ | |
| def add (a b : Ball) : Ball := ⟨a.center + b.center, a.radius + b.radius⟩ | |
| def neg (a : Ball) : Ball := ⟨-a.center, a.radius⟩ | |
| def mul (a b : Ball) : Ball := | |
| ⟨a.center * b.center, | |
| |a.center| * b.radius + |b.center| * a.radius + a.radius * b.radius⟩ | |
| def lower (b : Ball) : ℚ := b.center - b.radius | |
| def upper (b : Ball) : ℚ := b.center + b.radius | |
| def ofBounds (lo hi : ℚ) : Ball := ⟨(lo + hi) / 2, (hi - lo) / 2⟩ | |
| theorem nonnegative_radius {b : Ball} {x : ℝ} (h : b.Encloses x) : 0 ≤ b.radius := by | |
| have : (0 : ℝ) ≤ b.radius := (abs_nonneg _).trans h | |
| exact_mod_cast this | |
| theorem bounds {b : Ball} {x : ℝ} (h : b.Encloses x) : | |
| (b.lower : ℝ) ≤ x ∧ x ≤ (b.upper : ℝ) := by | |
| obtain ⟨hl, hu⟩ := abs_le.mp h | |
| simp only [lower, upper, Rat.cast_sub, Rat.cast_add] | |
| constructor <;> linarith | |
| theorem ofBounds_sound {lo hi : ℚ} {x : ℝ} | |
| (hlo : (lo : ℝ) ≤ x) (hhi : x ≤ (hi : ℝ)) : | |
| (ofBounds lo hi).Encloses x := by | |
| simp only [Encloses, ofBounds, Rat.cast_add, Rat.cast_div, Rat.cast_ofNat, | |
| Rat.cast_sub] | |
| exact abs_le.mpr ⟨by linarith, by linarith⟩ | |
| theorem exact_sound (q : ℚ) : (exact q).Encloses (q : ℝ) := by | |
| simp [Encloses, exact] | |
| theorem add_sound {a b : Ball} {x y : ℝ} (hx : a.Encloses x) (hy : b.Encloses y) : | |
| (add a b).Encloses (x + y) := by | |
| unfold Encloses add | |
| simp only [Rat.cast_add] | |
| calc | |
| _ = |(x - (a.center : ℝ)) + (y - (b.center : ℝ))| := by congr 1; ring | |
| _ ≤ |x - (a.center : ℝ)| + |y - (b.center : ℝ)| := abs_add_le _ _ | |
| _ ≤ _ := add_le_add hx hy | |
| theorem neg_sound {a : Ball} {x : ℝ} (hx : a.Encloses x) : | |
| (neg a).Encloses (-x) := by | |
| simpa only [Encloses, neg, Rat.cast_neg, neg_sub_neg, abs_sub_comm] using hx | |
| theorem mul_sound {a b : Ball} {x y : ℝ} (hx : a.Encloses x) (hy : b.Encloses y) : | |
| (mul a b).Encloses (x * y) := by | |
| have ha : (0 : ℝ) ≤ a.radius := by exact_mod_cast nonnegative_radius hx | |
| have hb : (0 : ℝ) ≤ b.radius := by exact_mod_cast nonnegative_radius hy | |
| unfold Encloses mul | |
| simp only [Rat.cast_mul, Rat.cast_add, Rat.cast_abs] | |
| calc | |
| _ = |(a.center : ℝ) * (y - (b.center : ℝ)) + | |
| (b.center : ℝ) * (x - (a.center : ℝ)) + | |
| (x - (a.center : ℝ)) * (y - (b.center : ℝ))| := by congr 1; ring | |
| _ ≤ |(a.center : ℝ) * (y - (b.center : ℝ))| + | |
| |(b.center : ℝ) * (x - (a.center : ℝ))| + | |
| |(x - (a.center : ℝ)) * (y - (b.center : ℝ))| := | |
| (abs_add_le _ _).trans (add_le_add_left (abs_add_le _ _) _) | |
| _ = |(a.center : ℝ)| * |y - (b.center : ℝ)| + | |
| |(b.center : ℝ)| * |x - (a.center : ℝ)| + | |
| |x - (a.center : ℝ)| * |y - (b.center : ℝ)| := by simp only [abs_mul] | |
| _ ≤ _ := add_le_add | |
| (add_le_add (mul_le_mul_of_nonneg_left hy (abs_nonneg _)) | |
| (mul_le_mul_of_nonneg_left hx (abs_nonneg _))) | |
| (mul_le_mul hx hy (abs_nonneg _) ha) | |
| theorem widen_sound {a b : Ball} {x : ℝ} (hx : a.Encloses x) | |
| (h : |a.center - b.center| + a.radius ≤ b.radius) : b.Encloses x := by | |
| have hc : |(a.center : ℝ) - (b.center : ℝ)| + (a.radius : ℝ) ≤ (b.radius : ℝ) := by | |
| exact_mod_cast h | |
| unfold Encloses | |
| calc | |
| _ = |(x - (a.center : ℝ)) + ((a.center : ℝ) - (b.center : ℝ))| := by congr 1; ring | |
| _ ≤ |x - (a.center : ℝ)| + |(a.center : ℝ) - (b.center : ℝ)| := abs_add_le _ _ | |
| _ ≤ (a.radius : ℝ) + |(a.center : ℝ) - (b.center : ℝ)| := add_le_add_left hx _ | |
| _ ≤ _ := by linarith | |
| def inv (a : Ball) : Ball := ofBounds (1 / a.upper) (1 / a.lower) | |
| theorem inv_sound {a : Ball} {x : ℝ} (hx : a.Encloses x) | |
| (hpos : 0 < a.lower) : (inv a).Encloses x⁻¹ := by | |
| have hlo : (0 : ℝ) < a.lower := by exact_mod_cast hpos | |
| obtain ⟨hl, hu⟩ := bounds hx | |
| have hxp : 0 < x := lt_of_lt_of_le hlo hl | |
| apply ofBounds_sound | |
| · simpa only [Rat.cast_div, Rat.cast_one, Rat.cast_inv, one_div] using | |
| one_div_le_one_div_of_le hxp hu | |
| · simpa only [Rat.cast_div, Rat.cast_one, Rat.cast_inv, one_div] using | |
| one_div_le_one_div_of_le hlo hl | |
| end Ball | |
| def reductionError {x : ℚ} (d : ReducedArgument x) : ℚ := | |
| (1 + |(d.exponent : ℚ)|) / 2 ^ 120 | |
| theorem reduction_error_cast {x : ℚ} (d : ReducedArgument x) : | |
| (reductionError d : ℝ) = (1 + |(d.exponent : ℝ)|) / 2 ^ 120 := by | |
| simp [reductionError] | |
| def logBall (b : Ball) (dl : ReducedArgument b.lower) (du : ReducedArgument b.upper) : Ball := | |
| Ball.ofBounds (reducedApprox dl - reductionError dl) (reducedApprox du + reductionError du) | |
| theorem logBall_sound {b : Ball} {x : ℝ} (hx : b.Encloses x) | |
| (dl : ReducedArgument b.lower) (du : ReducedArgument b.upper) : | |
| (logBall b dl du).Encloses (Real.log x) := by | |
| have hlo : (0 : ℝ) < b.lower := by exact_mod_cast dl.positive | |
| obtain ⟨hl, hu⟩ := Ball.bounds hx | |
| have hxp : 0 < x := lt_of_lt_of_le hlo hl | |
| have el := abs_le.mp (reduced_log_error dl) | |
| have eu := abs_le.mp (reduced_log_error du) | |
| apply Ball.ofBounds_sound | |
| · have hm := Real.log_le_log hlo hl | |
| simp only [Rat.cast_sub, reduction_error_cast] | |
| linarith [el.1] | |
| · have hm := Real.log_le_log hxp hu | |
| simp only [Rat.cast_add, reduction_error_cast] | |
| linarith [eu.2] | |
| theorem log_center_lipschitz {b : Ball} {x : ℝ} (hx : b.Encloses x) | |
| (hpos : 0 < b.lower) : | |
| |Real.log x - Real.log (b.center : ℝ)| ≤ (b.radius / b.lower : ℚ) := by | |
| have hr : (0 : ℝ) ≤ b.radius := by exact_mod_cast Ball.nonnegative_radius hx | |
| have hl : (0 : ℝ) < b.lower := by exact_mod_cast hpos | |
| have hcl : (b.lower : ℝ) ≤ b.center := by | |
| simp only [Ball.lower, Rat.cast_sub] | |
| linarith | |
| have hc : (0 : ℝ) < b.center := hl.trans_le hcl | |
| obtain ⟨hxl, _⟩ := Ball.bounds hx | |
| have hxp : 0 < x := hl.trans_le hxl | |
| have logs (a c : ℝ) (ha : 0 < a) (hc : 0 < c) : | |
| Real.log a - Real.log c ≤ (a - c) / c := by | |
| rw [← Real.log_div ha.ne' hc.ne'] | |
| have h := Real.log_le_sub_one_of_pos (div_pos ha hc) | |
| have he : a / c - 1 = (a - c) / c := by field_simp | |
| rwa [he] at h | |
| have hup : Real.log x - Real.log (b.center : ℝ) ≤ (b.radius : ℝ) / (b.lower : ℝ) := by | |
| calc | |
| _ ≤ (x - (b.center : ℝ)) / (b.center : ℝ) := logs _ _ hxp hc | |
| _ ≤ (b.radius : ℝ) / (b.center : ℝ) := | |
| div_le_div_of_nonneg_right (abs_le.mp hx).2 hc.le | |
| _ ≤ _ := div_le_div_of_nonneg_left hr hl hcl | |
| have hdown : Real.log (b.center : ℝ) - Real.log x ≤ | |
| (b.radius : ℝ) / (b.lower : ℝ) := by | |
| calc | |
| _ ≤ ((b.center : ℝ) - x) / x := logs _ _ hc hxp | |
| _ ≤ (b.radius : ℝ) / x := | |
| div_le_div_of_nonneg_right (by linarith [(abs_le.mp hx).1]) hxp.le | |
| _ ≤ _ := div_le_div_of_nonneg_left hr hl hxl | |
| rw [Rat.cast_div] | |
| exact abs_le.mpr ⟨by linarith, hup⟩ | |
| inductive Expression where | |
| | constant : ℚ → Expression | |
| | add : Expression → Expression → Expression | |
| | neg : Expression → Expression | |
| | mul : Expression → Expression → Expression | |
| | inv : Expression → Expression | |
| | log : Expression → Expression | |
| noncomputable def Expression.value : Expression → ℝ | |
| | .constant q => q | |
| | .add a b => a.value + b.value | |
| | .neg a => -a.value | |
| | .mul a b => a.value * b.value | |
| | .inv a => a.value⁻¹ | |
| | .log a => Real.log a.value | |
| inductive Certificate : Expression → Ball → Prop where | |
| | constant (q : ℚ) : Certificate (.constant q) (.exact q) | |
| | add {e f a b} : Certificate e a → Certificate f b → Certificate (.add e f) (.add a b) | |
| | neg {e a} : Certificate e a → Certificate (.neg e) (.neg a) | |
| | mul {e f a b} : Certificate e a → Certificate f b → Certificate (.mul e f) (.mul a b) | |
| | inv {e a} : Certificate e a → 0 < a.lower → Certificate (.inv e) (.inv a) | |
| | log {e a} (dl : ReducedArgument a.lower) (du : ReducedArgument a.upper) : | |
| Certificate e a → Certificate (.log e) (logBall a dl du) | |
| | widen {e a b} : Certificate e a → |a.center - b.center| + a.radius ≤ b.radius → | |
| Certificate e b | |
| theorem Certificate.sound {e : Expression} {b : Ball} (h : Certificate e b) : | |
| b.Encloses e.value := by | |
| induction h with | |
| | constant q => exact Ball.exact_sound q | |
| | add _ _ ih₁ ih₂ => exact Ball.add_sound ih₁ ih₂ | |
| | neg _ ih => exact Ball.neg_sound ih | |
| | mul _ _ ih₁ ih₂ => exact Ball.mul_sound ih₁ ih₂ | |
| | inv _ hp ih => exact Ball.inv_sound ih hp | |
| | log dl du _ ih => exact logBall_sound ih dl du | |
| | widen _ hw ih => exact Ball.widen_sound ih hw | |
| theorem published_endpoint_below_target : | |
| (2371054886006745685 : ℚ) / 10 ^ 18 < (2371054887 : ℚ) / 10 ^ 9 := by | |
| decide +kernel | |
| theorem value_below_target_of_certificate {e : Expression} {b : Ball} | |
| (hc : Certificate e b) | |
| (hu : b.upper ≤ (2371054886006745685 : ℚ) / 10 ^ 18) : | |
| e.value < (2371054887 : ℝ) / 10 ^ 9 := by | |
| have hbound := (Ball.bounds hc.sound).2 | |
| have hu' : (b.upper : ℝ) ≤ (2371054886006745685 : ℝ) / 10 ^ 18 := by | |
| have hcast : (b.upper : ℝ) ≤ ((2371054886006745685 / 10 ^ 18 : ℚ) : ℝ) := | |
| Rat.cast_le.mpr hu | |
| simpa only [Rat.cast_div, Rat.cast_pow, Rat.cast_ofNat] using hcast | |
| have htarget : (2371054886006745685 : ℝ) / 10 ^ 18 < | |
| (2371054887 : ℝ) / 10 ^ 9 := by | |
| have hcast : ((2371054886006745685 / 10 ^ 18 : ℚ) : ℝ) < | |
| ((2371054887 / 10 ^ 9 : ℚ) : ℝ) := Rat.cast_lt.mpr published_endpoint_below_target | |
| simpa only [Rat.cast_div, Rat.cast_pow, Rat.cast_ofNat] using hcast | |
| exact lt_of_le_of_lt (hbound.trans hu') htarget | |
| end MatrixMultiplication.AllFieldCertificates | |
| end OAI | |