├── .gitignore ├── leanpkg.toml ├── LICENSE ├── src ├── riemann_hypothesis.lean ├── complex.lean ├── riemann_zeta.lean ├── exponential.lean ├── mathlib │ └── impl.lean ├── dirichlet_eta.lean ├── cauchy.lean └── basic.lean └── README.md /.gitignore: -------------------------------------------------------------------------------- 1 | *.olean 2 | /_target 3 | /leanpkg.path 4 | -------------------------------------------------------------------------------- /leanpkg.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | lean_version = "leanprover-community/lean:3.18.4" 3 | name = "riemann_hypothesis" 4 | path = "src" 5 | version = "0.1" 6 | 7 | [dependencies] 8 | mathlib = {git = "https://github.com/leanprover-community/mathlib", rev = "bc72d9035a130cbf8d47f7398a6fa53196c40880"} 9 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2020-2021 Brandon H. Gomes and Alex Kontorovich 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /src/riemann_hypothesis.lean: -------------------------------------------------------------------------------- 1 | /- ------------------------------------------------------------------------- -| 2 | | @project: riemann_hypothesis | 3 | | @file: riemann_hypothesis.lean | 4 | | @authors: Brandon H. Gomes, Alex Kontorovich | 5 | | @affil: Rutgers University | 6 | |- ------------------------------------------------------------------------- -/ 7 | 8 | import .dirichlet_eta 9 | 10 | /-! 11 | -/ 12 | 13 | namespace riemann_hypothesis --——————————————————————————————————————————————————————————-- 14 | variables {ℂ : Type*} {ℝ : Type*} 15 | [has_lift_t nat ℝ] [has_lift_t ℝ ℂ] [preorder ℝ] [Algebra ℝ] [Algebra ℂ] 16 | (ℭ : Complex ℂ ℝ) 17 | 18 | open algebra 19 | 20 | /-- 21 | -/ 22 | def form.dirichlet_eta 23 | [has_lift_zero_same nat ℝ] 24 | [has_lift_lt_comm nat ℝ] 25 | (s) (σpos : 0 < ℭ.real_part s) (σ_le_one : ℭ.real_part s < 1) 26 | := is_convergent ℭ.abs (dirichlet_eta.partial_pairs ℭ s) 0 → ℭ.real_part s = 2⁻¹ 27 | 28 | end riemann_hypothesis --————————————————————————————————————————————————————————————————-- 29 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Riemann Hypothesis in Lean 2 | 3 | [![DOI](https://zenodo.org/badge/275204877.svg)](https://zenodo.org/badge/latestdoi/275204877) 4 | 5 | _by Brandon H. Gomes and Alex Kontorovich through the Department of Mathematics, Rutgers University_ 6 | 7 | ## Formalization 8 | 9 | The Riemann Hypothesis is formalized by assuming some algebraic properties of the real and complex numbers and the existence/properties of the complex exponential function and the real logarithm. These axioms are then used to construct the Dirichlet η function which we use to define the Riemann Hypothesis as the following type: 10 | 11 | ```lean 12 | (Re s ∈ (0,1)) ∧ (eta s = 0) → (Re s = 1/2) 13 | ``` 14 | 15 | We also include the file, [`mathlib/impl.lean`](src/mathlib/impl.lean), which is a witness that the axioms can be proved using [`mathlib`](https://github.com/leanprover-community/mathlib). 16 | 17 | ## Acknowledgements 18 | 19 | We would like to thank Alex Best, Kevin Buzzard, Colin Fan, Sebastien Gouezel, Heather Macbeth, and the Zulip Lean community for many suggestions that made this project possible. 20 | 21 | The work of the first-named author was supported by the Rutgers Math Department through the DIMACS REU, and both are supported in part by the second-named author's NSF grant DMS-1802119. 22 | -------------------------------------------------------------------------------- /src/complex.lean: -------------------------------------------------------------------------------- 1 | /- ------------------------------------------------------------------------- -| 2 | | @project: riemann_hypothesis | 3 | | @file: complex.lean | 4 | | @authors: Brandon H. Gomes, Alex Kontorovich | 5 | | @affil: Rutgers University | 6 | |- ------------------------------------------------------------------------- -/ 7 | 8 | import .exponential 9 | 10 | /-! 11 | -/ 12 | 13 | namespace riemann_hypothesis --——————————————————————————————————————————————————————————-- 14 | 15 | /-- 16 | -/ 17 | class Algebra (α : Type*) 18 | extends has_zero α, has_one α, has_neg α, has_add α, has_sub α, has_mul α, has_inv α 19 | 20 | --———————————————————————————————————————————————————————————————————————————————————————-- 21 | variables (ℂ : Type*) (ℝ : Type*) 22 | 23 | variables [preorder ℝ] [Algebra ℝ] 24 | 25 | variables [Algebra ℂ] 26 | 27 | variables [has_lift_t ℝ ℂ] 28 | 29 | /-- 30 | -/ 31 | structure Complex 32 | := (real_part : ℂ → ℝ) 33 | (abs : ℂ → ℝ) 34 | (exp : ℂ → ℂ) 35 | (real_explog : ExpLog ℝ ℝ) 36 | (abs_nonneg : Π z, 0 ≤ abs z) 37 | (exp_nonzero : Π z, exp z ≠ 0) 38 | (exp_homomorphism_zero : exp 0 = 1) 39 | (exp_homomorphism : Π w z, exp (w + z) = exp w * exp z) 40 | (exp_homomorphism_inv : Π w z, exp (w - z) = exp w * (exp z)⁻¹) 41 | (real_part_scaling : Π x z, real_part (↑x * z) = x * real_part z) 42 | (abs_exp_is_exp_real_part : Π z, abs (exp z) = real_explog.exp (real_part z)) 43 | (exp_linearization : Π x, abs x ≤ 1 44 | → Π z, abs (exp (x * z) - (x * z + 1)) 45 | ≤ (abs x * abs x) * real_explog.exp (abs z)) 46 | (real_log_bound : Π x (p : 0 < 1 - x), abs ↑x ≤ 2⁻¹ 47 | → abs ↑(real_explog.log (1 - x) p) 48 | ≤ abs ↑x + abs ↑x) 49 | 50 | namespace Complex --—————————————————————————————————————————————————————————————————————-- 51 | variables {ℂ ℝ} (ℭ : Complex ℂ ℝ) 52 | 53 | open algebra 54 | 55 | /-- 56 | -/ 57 | def real_abs (x : ℝ) 58 | := ℭ.abs (↑x) 59 | 60 | /-- 61 | -/ 62 | def real_exp (x) 63 | := ℭ.real_explog.exp x 64 | 65 | /-- 66 | -/ 67 | def real_log (x) 68 | := ℭ.real_explog.log x 69 | 70 | /-- 71 | -/ 72 | def pow (a apos x) 73 | := ℭ.exp (↑(ℭ.real_explog.log a apos) * x) 74 | 75 | /-- 76 | -/ 77 | def pow_domain_irrel 78 | (x xpos) 79 | (y ypos) 80 | (z) 81 | : x = y → ℭ.pow x xpos z = ℭ.pow y ypos z := 82 | begin 83 | intros x_eq_y, 84 | rw [pow, pow], 85 | rw ExpLog.log_domain_irrel _ _ _ _ _ x_eq_y, 86 | end 87 | 88 | /-- 89 | -/ 90 | def pow_nonzero (a apos x) 91 | : ℭ.pow a apos x ≠ 0 92 | := ℭ.exp_nonzero _ 93 | 94 | /-- 95 | -/ 96 | def pow_neg_exponent_inverts 97 | [has_left_sub_distributivity ℂ] 98 | [has_mul_zero_is_zero ℂ] 99 | [has_left_unit ℂ] 100 | (a apos x) 101 | : ℭ.pow a apos (0 - x) = (ℭ.pow a apos x)⁻¹ := 102 | begin 103 | rw pow, 104 | rw has_left_sub_distributivity.eq, 105 | rw has_mul_zero_is_zero.eq, 106 | rw exp_homomorphism_inv, 107 | rw exp_homomorphism_zero, 108 | rw has_left_unit.eq, 109 | rw ← pow, 110 | end 111 | 112 | /-- 113 | -/ 114 | def abs_pow_is_real_pow (x xpos z) 115 | : ℭ.abs (ℭ.pow x xpos z) = ℭ.real_explog.pow x xpos (ℭ.real_part z) 116 | := by rw [pow, abs_exp_is_exp_real_part, real_part_scaling, ExpLog.pow] 117 | 118 | --———————————————————————————————————————————————————————————————————————————————————————-- 119 | local notation `|` z `|` := ℭ.abs z 120 | 121 | /-- 122 | -/ 123 | def one_minus_pow_bound 124 | [has_lift_t nat ℝ] 125 | 126 | [has_add_le_add ℝ] 127 | 128 | [has_left_unit ℝ] 129 | [has_right_unit ℝ] 130 | 131 | [has_squared_le_monotonic ℝ] 132 | 133 | [has_inv_mul_right_cancel_self ℝ] 134 | 135 | [has_le_nonneg_mul_preserves_left ℝ] 136 | [has_le_nonneg_mul_preserves_right ℝ] 137 | 138 | [has_mul_assoc ℝ] 139 | 140 | [has_left_add_distributivity ℝ] 141 | [has_right_add_distributivity ℝ] 142 | 143 | [has_sub_add_sub_cancel ℂ] 144 | [has_add_sub_assoc ℂ] 145 | [has_sub_self_is_zero ℂ] 146 | [has_zero_right_add_cancel ℂ] 147 | 148 | [has_zero_right_add_cancel ℝ] 149 | 150 | (zero_lt_two : 0 < (2 : ℝ)) 151 | (one_le_two : 1 ≤ (2 : ℝ)) 152 | 153 | (abs_mul : Π a b, |a * b| = |a| * |b|) 154 | (abs_triangle : Π a b, |a + b| ≤ |a| + |b|) 155 | 156 | (z) (x : ℝ) (abs_x_le_half : |↑x| ≤ 2⁻¹) (one_minus_x_pos : 0 < 1 - x) 157 | 158 | : | ℭ.pow (1 - x) one_minus_x_pos z - 1 | ≤ |↑x| * (4 * ℭ.real_exp (|z|) + (|z| + |z|)) := 159 | 160 | begin 161 | rw ← has_sub_add_sub_cancel.eq _ (↑(ℭ.real_log (1 - x) one_minus_x_pos) * z + 1) _, 162 | 163 | refine le_trans (abs_triangle _ _) _, 164 | 165 | rw has_add_sub_assoc.eq, 166 | rw has_sub_self_is_zero.eq, 167 | rw has_zero_right_add_cancel.eq, 168 | rw abs_mul, 169 | rw has_left_add_distributivity.eq, 170 | rw ← has_mul_assoc.eq, 171 | 172 | let log_bound 173 | := ℭ.real_log_bound _ one_minus_x_pos abs_x_le_half, 174 | 175 | let abs_x_inequality 176 | := has_le_nonneg_mul_preserves_left.le (le_of_lt zero_lt_two) abs_x_le_half, 177 | 178 | rw has_inv_mul_right_cancel_self.eq _ (ne_of_lt zero_lt_two).symm 179 | at abs_x_inequality, 180 | 181 | rw two_mul_lemma at abs_x_inequality, 182 | 183 | refine has_add_le_add.le 184 | (le_trans 185 | (ℭ.exp_linearization _ (le_trans log_bound abs_x_inequality) _) 186 | (has_le_nonneg_mul_preserves_right.le 187 | (le_of_lt (ExpLog.exp_positive _ _)) 188 | (le_trans 189 | (has_squared_le_monotonic.le (abs_nonneg _ _) log_bound) _))) _, 190 | 191 | rw ← two_squares_is_four_lemma', 192 | 193 | refine has_le_nonneg_mul_preserves_right.le _ _, 194 | 195 | let zero_le_four 196 | := has_add_le_add.le (le_of_lt zero_lt_two) (le_of_lt zero_lt_two), 197 | 198 | rw has_zero_right_add_cancel.eq at zero_le_four, 199 | 200 | refine zero_le_four, 201 | 202 | have abs_x_le_one : |↑x| ≤ 1, 203 | { 204 | refine le_trans _ abs_x_inequality, 205 | 206 | rw ← two_mul_lemma', 207 | rw ← has_right_unit.eq (|↑x|), 208 | rw has_mul_assoc.eq, 209 | rw has_left_unit.eq, 210 | 211 | refine has_le_nonneg_mul_preserves_left.le (abs_nonneg _ _) one_le_two, 212 | }, 213 | 214 | let square_le_id 215 | := has_le_nonneg_mul_preserves_right.le (abs_nonneg _ _) abs_x_le_one, 216 | 217 | rw has_left_unit.eq at square_le_id, 218 | 219 | refine square_le_id, 220 | 221 | rw has_left_add_distributivity.eq, 222 | rw ← has_right_add_distributivity.eq, 223 | 224 | refine has_le_nonneg_mul_preserves_right.le (abs_nonneg _ _) log_bound, 225 | end 226 | 227 | end Complex --———————————————————————————————————————————————————————————————————————————-- 228 | 229 | end riemann_hypothesis --————————————————————————————————————————————————————————————————-- 230 | -------------------------------------------------------------------------------- /src/riemann_zeta.lean: -------------------------------------------------------------------------------- 1 | /- ------------------------------------------------------------------------- -| 2 | | @project: riemann_hypothesis | 3 | | @file: riemann_zeta.lean | 4 | | @authors: Brandon H. Gomes, Alex Kontorovich | 5 | | @affil: Rutgers University | 6 | |- ------------------------------------------------------------------------- -/ 7 | 8 | import .cauchy 9 | 10 | /-! 11 | -/ 12 | 13 | namespace riemann_hypothesis --——————————————————————————————————————————————————————————-- 14 | namespace riemann_zeta --————————————————————————————————————————————————————————————————-- 15 | variables {ℝ : Type*} 16 | [has_lift_t nat ℝ] [preorder ℝ] [has_zero ℝ] [has_one ℝ] 17 | [has_neg ℝ] [has_add ℝ] [has_sub ℝ] [has_mul ℝ] [has_inv ℝ] 18 | 19 | open algebra 20 | 21 | /-- 22 | -/ 23 | def term {α β γ} 24 | [has_zero α] 25 | [has_lt α] 26 | [has_lift_t nat α] 27 | [has_lift_zero_same nat α] 28 | [has_lift_lt_comm nat α] 29 | [has_neg β] 30 | (pow : Π a : α, 0 < a → β → γ) 31 | (s n) 32 | := pow ↑(nat.succ n) (nat.lift.succ_pos α _) (-s) 33 | 34 | namespace term --——————————————————————————————————————————————————————————————————————————-- 35 | 36 | /-- 37 | `ζ` Series Term for Real Inputs 38 | 39 | `ζₙ(σ) := (n+1) ^ -σ` 40 | -/ 41 | def on_reals 42 | [has_lift_zero_same nat ℝ] 43 | [has_lift_lt_comm nat ℝ] 44 | (ℯ : ExpLog ℝ ℝ) 45 | (σ n) 46 | := term ℯ.pow σ n 47 | 48 | /-- 49 | -/ 50 | def on_reals.nonneg 51 | [has_lift_zero_same nat ℝ] 52 | [has_lift_lt_comm nat ℝ] 53 | (ℯ : ExpLog ℝ ℝ) 54 | (σ n) 55 | : 0 ≤ on_reals ℯ σ n 56 | := le_of_lt (ExpLog.exp_positive _ _) 57 | 58 | /-- 59 | -/ 60 | def on_reals.non_increasing 61 | [has_left_unit ℝ] 62 | [has_mul_zero_is_zero ℝ] 63 | [has_left_sub_distributivity ℝ] 64 | [has_inv_reverses_lt ℝ] 65 | [has_lt_pos_mul_preserves_right ℝ] 66 | [has_zero_sub_is_neg ℝ] 67 | [has_lift_lt_comm nat ℝ] 68 | [has_lift_zero_same nat ℝ] 69 | (ℯ : ExpLog ℝ ℝ) 70 | (σ σpos) 71 | : non_increasing (on_reals ℯ σ) := 72 | begin 73 | intros _, 74 | 75 | rw [on_reals, on_reals, term, term], 76 | rw ← has_zero_sub_is_neg.eq, 77 | rw [ExpLog.pow_neg_exponent_inverts, ExpLog.pow_neg_exponent_inverts], 78 | 79 | refine le_of_lt 80 | (has_inv_reverses_lt.lt 81 | (ExpLog.pow_monotonic _ _ _ σpos 82 | (has_lift_lt_comm.lt (nat.lt_succ_self _)))), 83 | end 84 | 85 | /-- 86 | -/ 87 | def on_reals.rewrite.pow_reduction 88 | [has_left_add_distributivity ℝ] 89 | [has_right_add_distributivity ℝ] 90 | [has_left_sub_distributivity ℝ] 91 | 92 | [has_left_unit ℝ] 93 | [has_right_unit ℝ] 94 | 95 | [has_zero_mul_is_zero ℝ] 96 | [has_mul_zero_is_zero ℝ] 97 | 98 | [has_zero_sub_is_neg ℝ] 99 | 100 | [has_mul_pos ℝ] 101 | 102 | [has_lift_one_same nat ℝ] 103 | [has_lift_zero_same nat ℝ] 104 | [has_lift_add_comm nat ℝ] 105 | [has_lift_mul_comm nat ℝ] 106 | [has_lift_lt_comm nat ℝ] 107 | [has_lift_le_comm nat ℝ] 108 | 109 | (ℯ : ExpLog ℝ ℝ) 110 | 111 | (σ) (n : nat) 112 | 113 | : ↑(2 ^ n) * on_reals ℯ σ (2 ^ n - 1) 114 | = ℯ.pow (ℯ.pow ↑2 _ (1 - σ)) (ℯ.pow_positivity _ (nat.lift.succ_pos ℝ _) _) ↑n := 115 | 116 | begin 117 | have lifted_pow2_pos : Π k : nat, 0 < (↑(2 ^ k) : ℝ), 118 | intros k, 119 | refine (lt_of_lt_of_le (nat.lift.zero_lt_one ℝ) _), 120 | rw one_is_lifted_one_lemma nat ℝ, 121 | refine has_lift_le_comm.le (nat.pow_two_ge_one _), 122 | 123 | rw [on_reals, term], 124 | rw ← ℯ.pow_id_at_one ↑(_) (lifted_pow2_pos _), 125 | 126 | rw ExpLog.pow_domain_irrel _ 127 | ↑(nat.succ (2 ^ n - 1)) _ _ (lifted_pow2_pos _) _ 128 | (by rw [nat.succ_eq_add_one, nat.sub_add_cancel (nat.pow_two_ge_one _)]), 129 | 130 | rw ℯ.pow_homomorphism_inv_from_neg, 131 | 132 | induction n with n hn, 133 | rw has_lift_zero_same.eq, 134 | rw ExpLog.pow_homomorphism_zero, 135 | 136 | rw ExpLog.pow_domain_irrel _ ↑(2 ^ 0) _ (1 : ℝ) _ _ 137 | (by rw [nat.pow_zero, has_lift_one_same.eq]), 138 | 139 | rw ExpLog.pow_homomorphism_one, 140 | 141 | rw ℯ.pow_succ_reduce _ 142 | (ℯ.pow_positivity _ (nat.lift.succ_pos ℝ _) _), 143 | 144 | have scaled_pow_ineq : 0 < (↑(2 ^ n) * ↑2 : ℝ), 145 | rw zero_is_lifted_zero_lemma nat ℝ, 146 | rw ← has_lift_mul_comm.eq, 147 | rw ← nat.pow_succ, 148 | refine has_lift_lt_comm.lt 149 | (lt_of_lt_of_le (nat.zero_lt_one) (nat.pow_two_ge_one _)), 150 | 151 | rw ExpLog.pow_domain_irrel _ ↑(2 ^ n.succ) _ _ scaled_pow_ineq _ 152 | (by rw [nat.pow_succ, has_lift_mul_comm.eq]), 153 | 154 | rw ℯ.pow_homomorphism_mul _ 155 | (lifted_pow2_pos _) _ (nat.lift.succ_pos ℝ _) _, 156 | 157 | rw hn, 158 | end 159 | 160 | end term --——————————————————————————————————————————————————————————————————————————————-- 161 | 162 | /-- 163 | `ζ` Series Partial Sum for Real Inputs 164 | -/ 165 | def partial.on_reals 166 | [has_lift_zero_same nat ℝ] 167 | [has_lift_lt_comm nat ℝ] 168 | (ℯ : ExpLog ℝ ℝ) 169 | := partial_sum ∘ (term.on_reals ℯ) 170 | 171 | /-- 172 | -/ 173 | def partial.on_reals.is_cauchy 174 | [has_add_le_add ℝ] 175 | [has_add_lt_add ℝ] 176 | 177 | [has_add_nonneg ℝ] 178 | [has_add_sub_assoc ℝ] 179 | [has_le_add_of_nonneg_of_le ℝ] 180 | [has_left_add_distributivity ℝ] 181 | [has_left_sub_distributivity ℝ] 182 | [has_lt_sub_neg ℝ] 183 | [has_mul_assoc ℝ] 184 | [has_pos_mul_neg_is_neg ℝ] 185 | [has_zero_right_add_cancel ℝ] 186 | [has_right_add_distributivity ℝ] 187 | 188 | [has_left_unit ℝ] 189 | [has_right_unit ℝ] 190 | 191 | [has_lift_one_same nat ℝ] 192 | [has_lift_zero_same nat ℝ] 193 | [has_lift_mul_comm nat ℝ] 194 | [has_lift_add_comm nat ℝ] 195 | [has_lift_lt_comm nat ℝ] 196 | [has_lift_le_comm nat ℝ] 197 | 198 | [has_sub_add_sub_cancel ℝ] 199 | [has_sub_self_is_zero ℝ] 200 | [has_sub_sub ℝ] 201 | [has_sub_ne_zero_of_ne ℝ] 202 | [has_zero_left_add_cancel ℝ] 203 | [has_zero_mul_is_zero ℝ] 204 | [has_mul_zero_is_zero ℝ] 205 | [has_inv_mul_right_cancel_self ℝ] 206 | [has_right_sub_distributivity ℝ] 207 | [has_add_sub_exchange ℝ] 208 | [has_inv_right_mul_lt_pos ℝ] 209 | [has_left_mul_inv_lt_neg ℝ] 210 | [has_zero_sub_is_neg ℝ] 211 | [has_inv_reverses_lt ℝ] 212 | [has_lt_pos_mul_preserves_right ℝ] 213 | [has_mul_pos ℝ] 214 | [has_sub_pos ℝ] 215 | 216 | (ℯ : ExpLog ℝ ℝ) 217 | 218 | (abs) 219 | (abs_zero abs_one abs_add abs_sub abs_mul abs_inv abs_ge_zero ge_zero_to_abs) 220 | 221 | (half ceil) 222 | 223 | (σ σ_gt_1) 224 | 225 | : is_cauchy abs (partial.on_reals ℯ σ) := 226 | 227 | begin 228 | refine condensation.cauchy_test _ abs_zero abs_ge_zero abs_add ge_zero_to_abs _ 229 | (term.on_reals.nonneg _ _) 230 | (term.on_reals.non_increasing _ _ 231 | (lt_trans (nat.lift.zero_lt_one _) σ_gt_1)) _, 232 | 233 | rw funext (term.on_reals.rewrite.pow_reduction ℯ _), 234 | 235 | refine geometric.series.is_cauchy _ 236 | abs_one abs_inv abs_sub abs_add abs_mul ge_zero_to_abs _ half ceil _ _ 237 | (ExpLog.exp_lt_zero_is_lt_one _ 238 | (has_pos_mul_neg_is_neg.lt 239 | (ExpLog.log_gt_one_is_gt_zero _ (nat.lift.succ_pos ℝ _) _) 240 | (has_lt_sub_neg.lt σ_gt_1))), 241 | 242 | rw one_is_lifted_one_lemma nat ℝ, 243 | 244 | refine has_lift_lt_comm.lt (nat.lt_succ_self _), 245 | end 246 | 247 | end riemann_zeta --——————————————————————————————————————————————————————————————————————-- 248 | end riemann_hypothesis --————————————————————————————————————————————————————————————————-- 249 | -------------------------------------------------------------------------------- /src/exponential.lean: -------------------------------------------------------------------------------- 1 | /- ------------------------------------------------------------------------- -| 2 | | @project: riemann_hypothesis | 3 | | @file: exponential.lean | 4 | | @authors: Brandon H. Gomes, Alex Kontorovich | 5 | | @affil: Rutgers University | 6 | |- ------------------------------------------------------------------------- -/ 7 | 8 | import .basic 9 | 10 | /-! 11 | -/ 12 | 13 | namespace riemann_hypothesis --——————————————————————————————————————————————————————————-- 14 | variables (α : Type*) (β : Type*) 15 | variables [has_lt α] [has_zero α] [has_one α] [has_mul α] [has_inv α] 16 | [has_lt β] [has_zero β] [has_add β] [has_sub β] 17 | 18 | /-- 19 | -/ 20 | structure ExpLog 21 | := (exp : β → α) 22 | (exp_homomorphism_zero : exp 0 = 1) 23 | (exp_homomorphism : Π (x y), exp (x + y) = exp x * exp y) 24 | (exp_homomorphism_inv : Π (x y), exp (x - y) = exp x * (exp y)⁻¹) 25 | (exp_injective : Π {x y}, exp x = exp y → x = y) 26 | (exp_monotonic : Π {x y}, x < y → exp x < exp y) 27 | (exp_monotonic_reverse : Π {x y}, exp x < exp y → x < y) 28 | (exp_positive : Π b, 0 < exp b) 29 | (log : Π a : α, 0 < a → β) 30 | (log_domain_irrel : Π x xpos y ypos, x = y → log x xpos = log y ypos) 31 | (log_inverted : Π a apos, exp (log a apos) = a) 32 | 33 | namespace ExpLog --——————————————————————————————————————————————————————————————————————-- 34 | variables {α β} 35 | 36 | open algebra 37 | 38 | /-- 39 | -/ 40 | def log_homomorphism_zero 41 | [has_zero_lt_one α] 42 | (ℯ : ExpLog α β) 43 | : ℯ.log 1 has_zero_lt_one.lt = 0 := 44 | begin 45 | refine ℯ.exp_injective _, 46 | rw exp_homomorphism_zero, 47 | rw ℯ.log_inverted _ has_zero_lt_one.lt, 48 | end 49 | 50 | /-- 51 | -/ 52 | def log_homomorphism 53 | [has_mul_pos α] 54 | (ℯ : ExpLog α β) 55 | {x y} 56 | (xpos ypos) 57 | : ℯ.log (x * y) (has_mul_pos.lt xpos ypos) 58 | = ℯ.log x xpos + ℯ.log y ypos := 59 | begin 60 | refine ℯ.exp_injective _, 61 | rw exp_homomorphism, 62 | rw [ℯ.log_inverted, ℯ.log_inverted, ℯ.log_inverted], 63 | end 64 | 65 | /-- 66 | -/ 67 | def log_homomorphism_inv 68 | [has_mul_pos α] 69 | [has_inv_pos α] 70 | (ℯ : ExpLog α β) 71 | {x y} 72 | (xpos ypos) 73 | : ℯ.log (x * y⁻¹) (has_mul_pos.lt xpos (has_inv_pos.lt ypos)) 74 | = ℯ.log x xpos - ℯ.log y ypos := 75 | begin 76 | refine ℯ.exp_injective _, 77 | rw exp_homomorphism_inv, 78 | rw [ℯ.log_inverted, ℯ.log_inverted, ℯ.log_inverted], 79 | end 80 | 81 | /-- 82 | -/ 83 | def log_monotonic 84 | (ℯ : ExpLog α β) 85 | {x y} 86 | (xpos ypos) 87 | : x < y → ℯ.log x xpos < ℯ.log y ypos := 88 | begin 89 | intros x_lt_y, 90 | rw [← ℯ.log_inverted _ xpos, ← ℯ.log_inverted _ ypos] at x_lt_y, 91 | refine exp_monotonic_reverse _ x_lt_y, 92 | end 93 | 94 | /-- 95 | -/ 96 | def log_monotonic_reverse 97 | (ℯ : ExpLog α β) 98 | {x y} 99 | (xpos ypos) 100 | : ℯ.log x xpos < ℯ.log y ypos → x < y := 101 | begin 102 | intros logx_lt_logy, 103 | rw [← ℯ.log_inverted _ xpos, ← ℯ.log_inverted _ ypos], 104 | refine exp_monotonic _ logx_lt_logy, 105 | end 106 | 107 | /-- 108 | -/ 109 | def log_lt_one_is_lt_zero 110 | [has_zero_lt_one α] 111 | (ℯ : ExpLog α β) 112 | {a} 113 | (apos) 114 | : a < 1 → ℯ.log a apos < 0 := 115 | begin 116 | intros a_lt_1, 117 | rw ← ℯ.log_homomorphism_zero, 118 | refine ℯ.log_monotonic _ _ a_lt_1, 119 | end 120 | 121 | /-- 122 | -/ 123 | def log_gt_one_is_gt_zero 124 | [has_zero_lt_one α] 125 | (ℯ : ExpLog α β) 126 | {a} 127 | (apos) 128 | : a > 1 → ℯ.log a apos > 0 := 129 | begin 130 | intros a_gt_1, 131 | rw ← ℯ.log_homomorphism_zero, 132 | refine ℯ.log_monotonic _ _ a_gt_1, 133 | end 134 | 135 | /-- 136 | -/ 137 | def exp_lt_zero_is_lt_one 138 | (ℯ : ExpLog α β) 139 | {b} 140 | : b < 0 → ℯ.exp b < 1 := 141 | begin 142 | intros b_lt_0, 143 | rw ← ℯ.exp_homomorphism_zero, 144 | refine ℯ.exp_monotonic b_lt_0, 145 | end 146 | 147 | /-- 148 | -/ 149 | def exp_gt_zero_is_gt_one 150 | (ℯ : ExpLog α β) 151 | {x} 152 | : x > 0 → ℯ.exp x > 1 := 153 | begin 154 | intros b_gt_0, 155 | rw ← ℯ.exp_homomorphism_zero, 156 | refine ℯ.exp_monotonic b_gt_0, 157 | end 158 | 159 | --———————————————————————————————————————————————————————————————————————————————————————-- 160 | variables [has_mul β] 161 | 162 | /-- 163 | -/ 164 | def pow 165 | (ℯ : ExpLog α β) 166 | (a apos) 167 | (b) 168 | := ℯ.exp (ℯ.log a apos * b) 169 | 170 | /-- 171 | -/ 172 | def pow_domain_irrel 173 | (ℯ : ExpLog α β) 174 | (x xpos) 175 | (y ypos) 176 | (b) 177 | : x = y → ℯ.pow x xpos b = ℯ.pow y ypos b := 178 | begin 179 | intros x_eq_y, 180 | rw [pow, pow], 181 | rw log_domain_irrel _ _ _ _ _ x_eq_y, 182 | end 183 | 184 | /-- 185 | -/ 186 | def pow_homomorphism_zero 187 | [has_mul_zero_is_zero β] 188 | (ℯ : ExpLog α β) 189 | (a apos) 190 | : ℯ.pow a apos 0 = 1 := 191 | begin 192 | rw pow, 193 | rw has_mul_zero_is_zero.eq, 194 | rw exp_homomorphism_zero, 195 | end 196 | 197 | /-- 198 | -/ 199 | def pow_homomorphism 200 | [has_left_add_distributivity β] 201 | (ℯ : ExpLog α β) 202 | (a apos x y) 203 | : ℯ.pow a apos (x + y) = ℯ.pow a apos x * ℯ.pow a apos y := 204 | begin 205 | rw pow, 206 | rw has_left_add_distributivity.eq, 207 | rw exp_homomorphism, 208 | rw [← pow, ← pow], 209 | end 210 | 211 | /-- 212 | -/ 213 | def pow_homomorphism_mul 214 | [has_mul_pos α] 215 | [has_right_add_distributivity β] 216 | (ℯ : ExpLog α β) 217 | (x xpos y ypos b) 218 | : ℯ.pow (x * y) (has_mul_pos.lt xpos ypos) b = ℯ.pow x xpos b * ℯ.pow y ypos b := 219 | begin 220 | rw pow, 221 | rw log_homomorphism, 222 | rw has_right_add_distributivity.eq, 223 | rw exp_homomorphism, 224 | rw [← pow, ← pow], 225 | end 226 | 227 | /-- 228 | -/ 229 | def pow_homomorphism_inv 230 | [has_left_sub_distributivity β] 231 | (ℯ : ExpLog α β) 232 | (a apos x y) 233 | : ℯ.pow a apos (x - y) = ℯ.pow a apos x * (ℯ.pow a apos y)⁻¹ := 234 | begin 235 | rw pow, 236 | rw has_left_sub_distributivity.eq, 237 | rw exp_homomorphism_inv, 238 | rw [← pow, ← pow], 239 | end 240 | 241 | /-- 242 | -/ 243 | def pow_id_at_one 244 | [has_one β] 245 | [has_right_unit β] 246 | (ℯ : ExpLog α β) 247 | (a apos) 248 | : ℯ.pow a apos 1 = a := 249 | begin 250 | rw pow, 251 | rw has_right_unit.eq, 252 | rw log_inverted, 253 | end 254 | 255 | /-- 256 | -/ 257 | def pow_homomorphism_one 258 | [has_zero_lt_one α] 259 | [has_zero_mul_is_zero β] 260 | (ℯ : ExpLog α β) 261 | (b) 262 | : ℯ.pow 1 has_zero_lt_one.lt b = 1 := 263 | begin 264 | rw pow, 265 | rw log_homomorphism_zero, 266 | rw has_zero_mul_is_zero.eq, 267 | rw exp_homomorphism_zero, 268 | end 269 | 270 | /-- 271 | -/ 272 | def pow_positivity 273 | (ℯ : ExpLog α β) 274 | (a apos b) 275 | : 0 < ℯ.pow a apos b 276 | := exp_positive _ _ 277 | 278 | /-- 279 | -/ 280 | def pow_neg_exponent_inverts 281 | [has_one β] 282 | [has_left_sub_distributivity β] 283 | [has_mul_zero_is_zero β] 284 | [has_left_unit α] 285 | (ℯ : ExpLog α β) 286 | (a apos b) 287 | : ℯ.pow a apos (0 - b) = (ℯ.pow a apos b)⁻¹ := 288 | begin 289 | rw pow_homomorphism_inv, 290 | rw pow_homomorphism_zero, 291 | rw has_left_unit.eq, 292 | end 293 | 294 | /-- 295 | -/ 296 | def pow_homomorphism_inv_from_neg 297 | [has_one β] 298 | [has_neg β] 299 | [has_zero_sub_is_neg β] 300 | [has_left_sub_distributivity β] 301 | [has_mul_zero_is_zero β] 302 | [has_left_unit α] 303 | (ℯ : ExpLog α β) 304 | (a apos x y) 305 | : ℯ.pow a apos x * ℯ.pow a apos (-y) = ℯ.pow a apos (x - y) := 306 | begin 307 | rw ← has_zero_sub_is_neg.eq, 308 | rw pow_neg_exponent_inverts, 309 | rw ← pow_homomorphism_inv, 310 | end 311 | 312 | /-- 313 | -/ 314 | def pow_succ_reduce 315 | [has_lift_t nat β] 316 | [has_one β] 317 | [has_right_unit β] 318 | [has_left_add_distributivity β] 319 | [has_lift_add_comm nat β] 320 | [has_lift_one_same nat β] 321 | (ℯ : ExpLog α β) 322 | (a apos) 323 | (n : nat) 324 | : ℯ.pow a apos ↑n.succ = ℯ.pow a apos ↑n * a := 325 | begin 326 | rw ← nat.add_one, 327 | rw has_lift_add_comm.eq, 328 | rw pow_homomorphism, 329 | rw has_lift_one_same.eq, 330 | rw pow_id_at_one, 331 | end 332 | 333 | /-- 334 | -/ 335 | def pow_monotonic 336 | [has_lt_pos_mul_preserves_right β] 337 | (ℯ : ExpLog α β) 338 | {x y} 339 | (xpos ypos) 340 | {b} 341 | (bpos) 342 | : x < y → ℯ.pow x xpos b < ℯ.pow y ypos b := 343 | begin 344 | intros x_lt_y, 345 | refine exp_monotonic _ 346 | (has_lt_pos_mul_preserves_right.lt bpos (log_monotonic _ _ _ x_lt_y)), 347 | end 348 | 349 | /-- 350 | -/ 351 | def nat_pow 352 | [has_lift_t nat β] 353 | (ℯ : ExpLog α β) 354 | (a apos) 355 | (n : nat) 356 | := ℯ.pow a apos ↑n 357 | 358 | /-- 359 | -/ 360 | def nat_pow_to_nat_power 361 | [has_one β] 362 | [has_right_unit β] 363 | [has_mul_zero_is_zero β] 364 | [has_left_add_distributivity β] 365 | [has_lift_t nat β] 366 | [has_lift_zero_same nat β] 367 | [has_lift_one_same nat β] 368 | [has_lift_add_comm nat β] 369 | (ℯ : ExpLog α β) 370 | (a : α) (apos : 0 < a) 371 | : nat.power a = ℯ.nat_pow a apos := 372 | begin 373 | refine funext _, 374 | intros n, 375 | induction n with n hn, 376 | rw nat.power, 377 | rw nat_pow, 378 | rw has_lift_zero_same.eq, 379 | rw pow_homomorphism_zero, 380 | rw nat.power, 381 | rw nat.succ_eq_add_one, 382 | rw nat_pow, 383 | rw has_lift_add_comm.eq, 384 | rw pow_homomorphism, 385 | rw has_lift_one_same.eq, 386 | rw pow_id_at_one, 387 | rw hn, 388 | rw nat_pow, 389 | end 390 | 391 | end ExpLog --————————————————————————————————————————————————————————————————————————————-- 392 | end riemann_hypothesis --————————————————————————————————————————————————————————————————-- 393 | -------------------------------------------------------------------------------- /src/mathlib/impl.lean: -------------------------------------------------------------------------------- 1 | /- ------------------------------------------------------------------------- -| 2 | | @project: riemann_hypothesis | 3 | | @file: mathlib/impl.lean | 4 | | @authors: Brandon H. Gomes, Alex Kontorovich | 5 | | @affil: Rutgers University | 6 | |- ------------------------------------------------------------------------- -/ 7 | 8 | import analysis.special_functions.exp_log 9 | import topology.metric_space.cau_seq_filter 10 | 11 | import riemann_hypothesis 12 | 13 | /-! 14 | -/ 15 | 16 | open riemann_hypothesis 17 | open_locale big_operators 18 | 19 | noncomputable theory 20 | 21 | /-- 22 | -/ 23 | instance : Algebra ℝ := { 24 | zero := has_zero.zero, 25 | one := has_one.one, 26 | neg := has_neg.neg, 27 | add := has_add.add, 28 | sub := has_sub.sub, 29 | mul := has_mul.mul, 30 | inv := has_inv.inv 31 | } 32 | 33 | /-- 34 | -/ 35 | instance : Algebra ℂ := { 36 | zero := has_zero.zero, 37 | one := has_one.one, 38 | neg := has_neg.neg, 39 | add := has_add.add, 40 | sub := has_sub.sub, 41 | mul := has_mul.mul, 42 | inv := has_inv.inv 43 | } 44 | 45 | /-- 46 | -/ 47 | def real_explog : ExpLog ℝ ℝ := 48 | { 49 | exp := real.exp, 50 | exp_homomorphism_zero := real.exp_zero, 51 | exp_homomorphism := real.exp_add, 52 | exp_homomorphism_inv := λ _ _, by rw [real.exp_sub, division_def], 53 | exp_injective := λ _ _ eq, real.exp_injective eq, 54 | exp_monotonic := λ _ _ lt, real.exp_lt_exp.mpr lt, 55 | exp_monotonic_reverse := λ _ _ lt, real.exp_lt_exp.mp lt, 56 | exp_positive := real.exp_pos, 57 | log := λ a _, real.log a, 58 | log_domain_irrel := λ _ _ _ _ eq, by rw eq, 59 | log_inverted := λ _ apos, by rw real.exp_log apos, 60 | } 61 | 62 | /-- 63 | -/ 64 | def complex_witness.proofs.abs_exp_is_exp_real_part 65 | : Π z, complex.abs (complex.exp z) = real.exp (complex.re z) := 66 | begin 67 | intros, 68 | rw [← complex.exp_of_real_re, 69 | complex.abs_exp_eq_iff_re_eq.mpr, 70 | ← complex.of_real_exp, 71 | complex.abs_of_real, 72 | abs_of_pos (real.exp_pos _)], 73 | repeat { refine rfl }, 74 | end 75 | 76 | /-- 77 | -/ 78 | def lim_le (f : cau_seq ℝ abs) (g : cau_seq ℝ abs) 79 | : (∃ j, ∀ i, j ≤ i → f i ≤ g i) → f.lim ≤ g.lim := 80 | begin 81 | intros, 82 | refine le_of_tendsto_of_tendsto (cau_seq.tendsto_limit _) (cau_seq.tendsto_limit _) _, 83 | rwa [filter.eventually_le, filter.eventually_at_top], 84 | end 85 | 86 | /-- 87 | -/ 88 | def unit_circle_pow_lemma 89 | : Π x, complex.abs x ≤ 1 → Π (n : ℕ), complex.abs (x ^ n) ≤ 1 := 90 | begin 91 | intros _ x_le_1 _, 92 | induction n with n hn, 93 | simp, 94 | rw pow_succ, 95 | refine le_trans _ hn, 96 | rw is_absolute_value.abv_pow complex.abs, 97 | rw complex.abs_mul, 98 | rw (_ : complex.abs x ^ n = 1 * complex.abs x ^ n), 99 | refine mul_le_mul 100 | x_le_1 (le_of_eq (is_absolute_value.abv_pow _ _ _)) (complex.abs_nonneg _) zero_le_one, 101 | simp, 102 | end 103 | 104 | /-- 105 | -/ 106 | def complex_witness.proofs.exp_linearization 107 | : Π x, complex.abs x ≤ 1 108 | → Π z, complex.abs (complex.exp (x * z) - (x * z + 1)) 109 | ≤ (complex.abs x * complex.abs x) * real.exp (complex.abs z) := 110 | begin 111 | intros _ x_le_1 _, 112 | rw complex.exp, 113 | rw ← cau_seq.lim_const (x*z+1), 114 | rw sub_eq_add_neg, 115 | rw ← cau_seq.lim_neg, 116 | rw cau_seq.lim_add, 117 | rw ← complex.lim_abs, 118 | rw real.exp, 119 | rw complex.exp, 120 | rw ← complex.lim_re, 121 | rw ← cau_seq.lim_const ((complex.abs x) * (complex.abs x)), 122 | rw cau_seq.lim_mul_lim, 123 | rw mul_comm (cau_seq.const _ _), 124 | 125 | refine lim_le _ _ _, 126 | existsi 2, 127 | intros i i_ge_2, 128 | 129 | rw (complex.cau_seq_re _).mul_apply, 130 | 131 | rw (_ : (complex.cau_seq_re (complex.exp' ↑(complex.abs z))) i 132 | = (∑ k in finset.range i, ((complex.abs z) : ℂ) ^ k / k.fact).re), 133 | 134 | rw ← (finset.range _).sum_hom complex.re, 135 | norm_cast, 136 | 137 | show complex.abs (∑ k in finset.range i, (x * z) ^ k / k.fact - (x * z + 1)) 138 | ≤ (∑ k in finset.range i, (complex.abs z) ^ k / k.fact) * (complex.abs x * complex.abs x), 139 | 140 | rw (_ : (x * z + 1) = ∑ k in finset.range 2, (x * z) ^ k / ↑(k.fact)), 141 | 142 | rw sum_range_sub_sum_range i_ge_2, 143 | 144 | rw (_ : complex.abs (∑ k in (finset.range i).filter (λ k, 2 ≤ k), (x * z) ^ k / ↑(k.fact)) 145 | = complex.abs (∑ k in (finset.range i).filter (λ k, 2 ≤ k), x ^ 2 * x ^ (k - 2) * z ^ k / ↑(k.fact))), 146 | 147 | rw (_ : (∑ k in finset.range i, complex.abs z ^ k / ↑(k.fact)) 148 | = (∑ k in (finset.range i).filter (λ k, 2 ≤ k), complex.abs z ^ k / ↑(k.fact) + (1 + complex.abs z))), 149 | 150 | rw (_ : (∑ k in (finset.range i).filter (λ k, 2 ≤ k), complex.abs z ^ k / ↑(k.fact) + (1 + complex.abs z)) 151 | * (complex.abs x * complex.abs x) 152 | = complex.abs x ^ 2 153 | * (∑ k in (finset.range i).filter (λ k, 2 ≤ k), complex.abs z ^ k / ↑(k.fact) + (1 + complex.abs z))), 154 | 155 | have drop_extra_powers_of_x 156 | : complex.abs (∑ k in (finset.range i).filter (λ k, 2 ≤ k), x ^ 2 * x ^ (k - 2) * z ^ k / ↑(k.fact)) 157 | ≤ ∑ k in (finset.range i).filter (λ k, 2 ≤ k), complex.abs x ^ 2 * (complex.abs z ^ k / ↑(k.fact)), 158 | { 159 | refine le_trans (abv_sum_le_sum_abv _ _) (finset.sum_le_sum (λ m _, _)), 160 | 161 | rw mul_div_assoc, 162 | rw complex.abs_mul, 163 | rw complex.abs_mul, 164 | rw is_absolute_value.abv_pow complex.abs, 165 | rw complex.abs_div, 166 | rw complex.abs_cast_nat, 167 | rw ← mul_div_assoc, 168 | rw division_def, 169 | rw division_def, 170 | rw ← is_absolute_value.abv_pow complex.abs z, 171 | rw ← mul_assoc, 172 | 173 | refine mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_right _ (complex.abs_nonneg _)) (by simp), 174 | 175 | have : complex.abs x ^ 2 * complex.abs (x ^ (m - 2)) ≤ complex.abs x ^ 2 * 1, 176 | by refine mul_le_mul_of_nonneg_left (unit_circle_pow_lemma _ x_le_1 _) (pow_nonneg (complex.abs_nonneg _) _), 177 | 178 | simp at this, 179 | refine this, 180 | }, 181 | 182 | simp [abs_mul, is_absolute_value.abv_pow complex.abs, complex.abs_div, finset.mul_sum.symm] 183 | at drop_extra_powers_of_x, 184 | 185 | refine le_trans drop_extra_powers_of_x (mul_le_mul (le_refl _) _ _ (pow_nonneg (complex.abs_nonneg _) _)), 186 | 187 | rw (_ : ∑ k in (finset.range i).filter (λ k, 2 ≤ k), complex.abs z ^ k / ↑(k.fact) 188 | = ∑ k in (finset.range i).filter (λ k, 2 ≤ k), complex.abs z ^ k / ↑(k.fact) + 0), 189 | 190 | rw (_ : ∑ k in (finset.range i).filter (λ k, 2 ≤ k), complex.abs z ^ k / ↑(k.fact) + 0 + (1 + complex.abs z) 191 | = ∑ k in (finset.range i).filter (λ k, 2 ≤ k), complex.abs z ^ k / ↑(k.fact) + (1 + complex.abs z)), 192 | 193 | refine add_le_add_left _ (∑ k in (finset.range i).filter (λ k, 2 ≤ k), complex.abs z ^ k / ↑(k.fact)), 194 | rw (_ : (0 : ℝ) = 0 + 0), 195 | refine add_le_add (by linarith) (complex.abs_nonneg _), 196 | simp, 197 | simp, 198 | simp, 199 | rw (_ : (0 : ℝ) = ∑ k in (finset.range i).filter (λ k, 2 ≤ k), 0), 200 | refine finset.sum_le_sum _, 201 | intros m _, 202 | rw (_ : complex.abs z ^ m / (m.fact : ℝ) = complex.abs z ^ m * (1 / (m.fact : ℝ))), 203 | refine mul_nonneg _ _, 204 | rw ← is_absolute_value.abv_pow complex.abs, 205 | refine complex.abs_nonneg _, 206 | refine le_of_lt (one_div_pos.mpr _), 207 | norm_cast, 208 | refine nat.fact_pos _, 209 | ring, 210 | refine (finset.sum_eq_zero _).symm, 211 | intros, 212 | refine rfl, 213 | ring, 214 | rw (_ : (1 + complex.abs z) = ∑ k in finset.range 2, (complex.abs z) ^ k / ↑(k.fact)), 215 | rw ← sum_range_sub_sum_range i_ge_2, 216 | simp, 217 | simp [sub_eq_add_neg, finset.sum_range_succ, add_assoc], 218 | ring, 219 | refine congr_arg complex.abs _, 220 | refine finset.sum_congr rfl _, 221 | intros, 222 | rw mul_pow, 223 | rw ← pow_add, 224 | rw nat.add_sub_cancel', 225 | simp at H, 226 | refine H.2, 227 | simp [sub_eq_add_neg, finset.sum_range_succ, add_assoc], 228 | refine rfl, 229 | end 230 | 231 | /-- 232 | -/ 233 | def complex_witness.proofs.real_log_bound 234 | : Π (x : ℝ) (p : 0 < 1 - x), 235 | complex.abs ↑x ≤ 2⁻¹ → complex.abs ↑(real.log (1 - x)) ≤ complex.abs ↑x + complex.abs ↑x := 236 | begin 237 | intros _ _ x_le_half, 238 | rw complex.abs_of_real at x_le_half, 239 | simp, 240 | 241 | have ineq0 : abs (∑ i in finset.range 0, x ^ (i + 1) / (↑i + 1) + real.log (1 - x)) 242 | ≤ abs x ^ (0 + 1) / (1 - abs x), 243 | { 244 | refine real.abs_log_sub_add_sum_range_le _ _, 245 | rw (_ : (2 : ℝ)⁻¹ = 1 / 2) at x_le_half, 246 | linarith, 247 | simp, 248 | }, 249 | simp at ineq0, 250 | 251 | rw (_: abs x + abs x = abs x / (1 - 2⁻¹)), 252 | 253 | have ineq1 : -(2⁻¹) ≤ -(abs x), 254 | by refine neg_le_neg x_le_half, 255 | 256 | have ineq2 : 1 - 2⁻¹ ≤ 1 - abs x, 257 | by refine sub_le_sub_left x_le_half _, 258 | 259 | have ineq3 : (1 - abs x)⁻¹ ≤ (1 - 2⁻¹)⁻¹, 260 | { 261 | refine inv_le_inv_of_le _ _, 262 | simp, 263 | rw (_ : (2 : ℝ)⁻¹ = 1 / 2), 264 | linarith, 265 | simp, 266 | refine ineq2, 267 | }, 268 | 269 | have ineq4 : abs x / (1 - abs x) ≤ abs x / (1 - 2⁻¹) , 270 | { 271 | rw (_ : abs x / (1 - abs x) = (1 - abs x)⁻¹ * abs x), 272 | rw (_ : abs x / (1 - 2⁻¹) = (1 - 2⁻¹)⁻¹ * abs x), 273 | refine mul_le_mul ineq3 _ _ _, 274 | refine le_refl _, 275 | refine abs_nonneg _, 276 | rw (_: (1 - (2 : ℝ)⁻¹)⁻¹ = 2), 277 | linarith, 278 | ring, 279 | ring, 280 | ring, 281 | }, 282 | 283 | linarith, 284 | ring, 285 | end 286 | 287 | /-- 288 | -/ 289 | def complex_witness : Complex ℂ ℝ := 290 | { 291 | real_part := complex.re, 292 | abs := complex.abs, 293 | exp := complex.exp, 294 | real_explog := real_explog, 295 | abs_nonneg := complex.abs_nonneg, 296 | exp_nonzero := complex.exp_ne_zero, 297 | exp_homomorphism_zero := complex.exp_zero, 298 | exp_homomorphism := complex.exp_add, 299 | exp_homomorphism_inv := λ _ _, by rw [complex.exp_sub, division_def], 300 | real_part_scaling := λ _ _, by rw [complex.mul_re, complex.of_real_im, complex.of_real_re, zero_mul, sub_zero], 301 | abs_exp_is_exp_real_part := complex_witness.proofs.abs_exp_is_exp_real_part, 302 | exp_linearization := complex_witness.proofs.exp_linearization, 303 | real_log_bound := complex_witness.proofs.real_log_bound 304 | } 305 | -------------------------------------------------------------------------------- /src/dirichlet_eta.lean: -------------------------------------------------------------------------------- 1 | /- ------------------------------------------------------------------------- -| 2 | | @project: riemann_hypothesis | 3 | | @file: dirichlet_eta.lean | 4 | | @authors: Brandon H. Gomes, Alex Kontorovich | 5 | | @affil: Rutgers University | 6 | |- ------------------------------------------------------------------------- -/ 7 | 8 | import .complex 9 | import .riemann_zeta 10 | 11 | /-! 12 | -/ 13 | 14 | namespace riemann_hypothesis --——————————————————————————————————————————————————————————-- 15 | variables {ℂ : Type*} {ℝ : Type*} 16 | [has_lift_t nat ℝ] [has_lift_t ℝ ℂ] [preorder ℝ] [Algebra ℝ] [Algebra ℂ] 17 | (ℭ : Complex ℂ ℝ) 18 | 19 | namespace dirichlet_eta --———————————————————————————————————————————————————————————————-- 20 | 21 | open algebra 22 | 23 | /-- 24 | -/ 25 | def term_pair 26 | [has_lift_zero_same nat ℝ] 27 | [has_lift_lt_comm nat ℝ] 28 | (s n) 29 | := riemann_zeta.term ℭ.pow s (2 * n) - riemann_zeta.term ℭ.pow s (2 * n).succ 30 | 31 | namespace term_pair --———————————————————————————————————————————————————————————————————-- 32 | 33 | /-- 34 | -/ 35 | def riemann_zeta_bound (s) 36 | := ↑4 * ℭ.real_exp (ℭ.abs s) + ↑3 * ℭ.abs s 37 | 38 | namespace riemann_zeta_bound --——————————————————————————————————————————————————————————-- 39 | variables [has_zero_mul_is_zero ℝ] [has_nonneg_mul_nonneg_is_nonneg ℝ] 40 | [has_lt_add_of_le_of_pos ℝ] [has_lt_pos_mul_preserves_right ℝ] 41 | [has_lift_zero_same nat ℝ] [has_lift_one_same nat ℝ] 42 | [has_lift_add_comm nat ℝ] [has_lift_lt_comm nat ℝ] 43 | 44 | /-- 45 | -/ 46 | def positive (s) 47 | : 0 < riemann_zeta_bound ℭ s := 48 | begin 49 | refine has_lt_add_of_le_of_pos.lt _ 50 | (has_nonneg_mul_nonneg_is_nonneg.le 51 | (le_of_lt (nat.lift.succ_pos ℝ _)) (ℭ.abs_nonneg _)), 52 | 53 | let four_exponentials_are_positive 54 | := has_lt_pos_mul_preserves_right.lt 55 | (ℭ.real_explog.exp_positive _) (nat.lift.succ_pos ℝ _), 56 | 57 | rw has_zero_mul_is_zero.eq at four_exponentials_are_positive, 58 | 59 | refine four_exponentials_are_positive, 60 | end 61 | 62 | /-- 63 | -/ 64 | def abs_positive 65 | (ge_zero_to_abs : Π z, 0 ≤ z → ℭ.abs ↑z = z) 66 | (s) 67 | : 0 < ℭ.abs ↑(riemann_zeta_bound ℭ s) := 68 | begin 69 | rw ge_zero_to_abs _ (le_of_lt (positive ℭ _)), 70 | refine positive ℭ _, 71 | end 72 | 73 | end riemann_zeta_bound --————————————————————————————————————————————————————————————————-- 74 | 75 | /-- 76 | -/ 77 | def bounded_by_riemann_zeta 78 | [has_add_le_add ℝ] 79 | [has_inv_mul_reverse ℝ] 80 | [has_inv_mul_right_cancel_self ℝ] 81 | [has_inv_reverses_le ℝ] 82 | [has_le_nonneg_mul_preserves_left ℝ] 83 | [has_le_nonneg_mul_preserves_right ℝ] 84 | [has_le_pos_mul_preserves_left ℝ] 85 | [has_le_pos_mul_preserves_right ℝ] 86 | [has_left_add_distributivity ℝ] 87 | [has_left_sub_distributivity ℝ] 88 | [has_left_unit ℝ] 89 | [has_lt_add_of_le_of_pos ℝ] 90 | [has_lt_pos_mul_preserves_right ℝ] 91 | [has_mul_assoc ℝ] 92 | [has_nonneg_mul_nonneg_is_nonneg ℝ] 93 | [has_right_add_distributivity ℝ] 94 | [has_right_inv_pos_lt ℝ] 95 | [has_right_sub_distributivity ℝ] 96 | [has_right_unit ℝ] 97 | [has_squared_le_monotonic ℝ] 98 | [has_zero_mul_is_zero ℝ] 99 | [has_mul_zero_is_zero ℝ] 100 | [has_zero_right_add_cancel ℝ] 101 | [has_zero_sub_is_neg ℝ] 102 | [has_mul_pos ℝ] 103 | [has_inv_pos ℝ] 104 | 105 | [has_lift_add_comm nat ℝ] 106 | [has_lift_le_comm nat ℝ] 107 | [has_lift_lt_comm nat ℝ] 108 | [has_lift_ne_comm nat ℝ] 109 | [has_lift_sub_comm nat ℝ] 110 | [has_lift_one_same nat ℝ] 111 | [has_lift_zero_same nat ℝ] 112 | 113 | [has_add_sub_assoc ℂ] 114 | [has_inv_mul_left_cancel_self ℂ] 115 | [has_left_sub_distributivity ℂ] 116 | [has_left_unit ℂ] 117 | [has_mul_assoc ℂ] 118 | [has_right_sub_distributivity ℂ] 119 | [has_right_unit ℂ] 120 | [has_sub_add_sub_cancel ℂ] 121 | [has_sub_self_is_zero ℂ] 122 | [has_mul_zero_is_zero ℂ] 123 | [has_zero_right_add_cancel ℂ] 124 | [has_zero_sub_is_neg ℂ] 125 | 126 | [has_lift_sub_comm ℝ ℂ] 127 | 128 | (abs_mul : Π a b, ℭ.abs (a * b) = ℭ.abs (a) * ℭ.abs (b)) 129 | (abs_sub : Π a b, ℭ.abs (a - b) = ℭ.abs (b - a)) 130 | (abs_inv : Π z, ℭ.abs (z⁻¹) = (ℭ.abs z)⁻¹) 131 | (abs_add : Π a b, ℭ.abs (a + b) ≤ ℭ.abs a + ℭ.abs b) 132 | (ge_zero_to_abs : Π x, 0 ≤ x → ℭ.abs ↑x = x) 133 | 134 | (s n) 135 | 136 | : ℭ.abs (term_pair ℭ s n) 137 | ≤ riemann_zeta.term.on_reals ℭ.real_explog (1 + ℭ.real_part s) (2 * n) 138 | * riemann_zeta_bound ℭ s := 139 | 140 | begin 141 | rw [term_pair, riemann_zeta.term.on_reals], 142 | rw [riemann_zeta.term, riemann_zeta.term, riemann_zeta.term], 143 | rw [← has_zero_sub_is_neg.eq, ← has_zero_sub_is_neg.eq], 144 | rw ExpLog.pow_neg_exponent_inverts, 145 | rw ExpLog.pow_homomorphism, 146 | rw has_inv_mul_reverse.eq, 147 | rw ℭ.real_explog.pow_id_at_one _ (nat.lift.succ_pos ℝ _), 148 | rw Complex.pow_neg_exponent_inverts, 149 | rw Complex.pow_neg_exponent_inverts, 150 | rw inv_sub_inv_lemma' (ℭ.pow_nonzero _ _ _), 151 | rw abs_mul, 152 | rw abs_inv, 153 | rw Complex.abs_pow_is_real_pow, 154 | rw has_mul_assoc.eq, 155 | rw ← ExpLog.pow_neg_exponent_inverts, 156 | 157 | let K := (↑(2 * n).succ.succ : ℝ), 158 | 159 | have Kinv_ge_zero : K⁻¹ ≥ 0, 160 | { 161 | let ineq 162 | := has_right_inv_pos_lt.lt 163 | (nat.lift.succ_pos ℝ _) (nat.lift.zero_lt_one ℝ), 164 | 165 | rw [has_zero_mul_is_zero.eq, has_left_unit.eq] at ineq, 166 | 167 | refine le_of_lt ineq, 168 | }, 169 | 170 | let remove_abs 171 | := ge_zero_to_abs _ Kinv_ge_zero, 172 | 173 | refine has_le_pos_mul_preserves_left.le 174 | (ℭ.real_explog.pow_positivity _ (nat.lift.succ_pos ℝ _) _) _, 175 | 176 | rw [Complex.pow, Complex.pow], 177 | rw ← Complex.exp_homomorphism_inv, 178 | rw ← has_right_sub_distributivity.eq, 179 | rw ← has_lift_sub_comm.eq, 180 | 181 | rw ← ℭ.real_explog.log_homomorphism_inv 182 | (nat.lift.succ_pos ℝ _) (nat.lift.succ_pos ℝ _), 183 | 184 | rw ← Complex.pow, 185 | 186 | rw ℭ.pow_domain_irrel 187 | (↑((2 * n).succ) * (↑((2 * n).succ.succ))⁻¹) _ 188 | (1 - (↑(2 * n).succ.succ)⁻¹) _ 189 | _ (by rw mul_inv_add_one_lemma), 190 | 191 | refine le_trans _ 192 | (has_le_pos_mul_preserves_right.le (riemann_zeta_bound.positive _ _) 193 | (has_inv_reverses_le.le (le_of_lt (has_lift_lt_comm.lt 194 | (nat.lt_succ_self _))))), 195 | 196 | rw ← mul_inv_add_one_lemma, 197 | 198 | refine has_mul_pos.lt 199 | (nat.lift.succ_pos ℝ _) 200 | (has_inv_pos.lt (nat.lift.succ_pos ℝ _)), 201 | 202 | rw abs_sub, 203 | rw riemann_zeta_bound, 204 | rw has_left_add_distributivity.eq, 205 | 206 | refine le_trans (Complex.one_minus_pow_bound _ _ _ abs_mul abs_add _ _ _ _) _, 207 | 208 | rw two_is_lifted_two_lemma nat ℝ, 209 | 210 | refine nat.lift.succ_pos ℝ _, 211 | 212 | rw two_is_lifted_two_lemma nat ℝ, 213 | rw one_is_lifted_one_lemma nat ℝ, 214 | 215 | refine has_lift_le_comm.le (le_of_lt (nat.lt_succ_self _)), 216 | 217 | rw remove_abs, 218 | rw two_is_lifted_two_lemma nat ℝ, 219 | 220 | refine has_inv_reverses_le.le 221 | (has_lift_le_comm.le (nat.smallest_positive_even _)), 222 | 223 | rw remove_abs, 224 | rw ← has_left_add_distributivity.eq, 225 | 226 | rw four_is_lifted_four_lemma nat ℝ, 227 | rw ← two_mul_lemma, 228 | 229 | refine has_le_nonneg_mul_preserves_left.le 230 | Kinv_ge_zero 231 | (has_add_le_add.le 232 | (le_refl _) (has_le_nonneg_mul_preserves_right.le (ℭ.abs_nonneg _) _)), 233 | 234 | rw two_is_lifted_two_lemma nat ℝ, 235 | 236 | refine has_lift_le_comm.le (le_of_lt (nat.lt_succ_self _)), 237 | end 238 | 239 | end term_pair --—————————————————————————————————————————————————————————————————————————-- 240 | 241 | /-- 242 | -/ 243 | def partial_pairs 244 | [has_lift_lt_comm nat ℝ] 245 | [has_lift_zero_same nat ℝ] 246 | (s) 247 | := partial_sum (term_pair ℭ s) 248 | 249 | /-- 250 | -/ 251 | def partial_pairs.is_cauchy 252 | [has_add_le_add ℝ] 253 | [has_add_left_lt ℝ] 254 | [has_add_lt_add ℝ] 255 | [has_add_nonneg ℝ] 256 | [has_add_sub_assoc ℝ] 257 | [has_add_sub_exchange ℝ] 258 | [has_inv_mul_left_cancel_self ℝ] 259 | [has_inv_mul_reverse ℝ] 260 | [has_inv_mul_right_cancel_self ℝ] 261 | [has_inv_reverses_le ℝ] 262 | [has_inv_reverses_lt ℝ] 263 | [has_inv_right_mul_lt_pos ℝ] 264 | [has_le_add_of_nonneg_of_le ℝ] 265 | [has_le_nonneg_mul_preserves_left ℝ] 266 | [has_le_nonneg_mul_preserves_right ℝ] 267 | [has_le_pos_mul_preserves_left ℝ] 268 | [has_le_pos_mul_preserves_right ℝ] 269 | [has_le_sub_add_le ℝ] 270 | [has_left_add_distributivity ℝ] 271 | [has_left_mul_inv_lt_neg ℝ] 272 | [has_left_mul_inv_lt_pos ℝ] 273 | [has_left_sub_distributivity ℝ] 274 | [has_left_unit ℝ] 275 | [has_lt_add_of_le_of_pos ℝ] 276 | [has_lt_pos_mul_preserves_right ℝ] 277 | [has_lt_sub_neg ℝ] 278 | [has_mul_assoc ℝ] 279 | [has_nonneg_mul_nonneg_is_nonneg ℝ] 280 | [has_pos_mul_neg_is_neg ℝ] 281 | [has_right_add_distributivity ℝ] 282 | [has_right_inv_pos_lt ℝ] 283 | [has_right_sub_distributivity ℝ] 284 | [has_right_unit ℝ] 285 | [has_squared_le_monotonic ℝ] 286 | [has_sub_add_sub_cancel ℝ] 287 | [has_sub_self_is_zero ℝ] 288 | [has_sub_ne_zero_of_ne ℝ] 289 | [has_sub_sub ℝ] 290 | [has_zero_mul_is_zero ℝ] 291 | [has_mul_zero_is_zero ℝ] 292 | [has_zero_left_add_cancel ℝ] 293 | [has_zero_right_add_cancel ℝ] 294 | [has_zero_sub_is_neg ℝ] 295 | [has_mul_pos ℝ] 296 | [has_inv_pos ℝ] 297 | [has_sub_pos ℝ] 298 | 299 | [has_lift_zero_same nat ℝ] 300 | [has_lift_one_same nat ℝ] 301 | [has_lift_add_comm nat ℝ] 302 | [has_lift_mul_comm nat ℝ] 303 | [has_lift_sub_comm nat ℝ] 304 | [has_lift_le_comm nat ℝ] 305 | [has_lift_lt_comm nat ℝ] 306 | [has_lift_ne_comm nat ℝ] 307 | 308 | [has_add_sub_assoc ℂ] 309 | [has_inv_mul_left_cancel_self ℂ] 310 | [has_left_sub_distributivity ℂ] 311 | [has_left_unit ℂ] 312 | [has_mul_assoc ℂ] 313 | [has_right_sub_distributivity ℂ] 314 | [has_right_unit ℂ] 315 | [has_sub_add_sub_cancel ℂ] 316 | [has_sub_self_is_zero ℂ] 317 | [has_mul_zero_is_zero ℂ] 318 | [has_zero_right_add_cancel ℂ] 319 | [has_zero_sub_is_neg ℂ] 320 | 321 | [has_lift_zero_same ℝ ℂ] 322 | [has_lift_one_same ℝ ℂ] 323 | [has_lift_add_comm ℝ ℂ] 324 | [has_lift_sub_comm ℝ ℂ] 325 | [has_lift_mul_comm ℝ ℂ] 326 | [has_lift_inv_comm ℝ ℂ] 327 | 328 | (abs_zero abs_one) 329 | (abs_add : Π w z, ℭ.abs (w + z) ≤ ℭ.abs w + ℭ.abs z) 330 | (abs_sub : Π w z, ℭ.abs (w - z) = ℭ.abs (z - w)) 331 | (abs_mul : Π w z, ℭ.abs (w * z) = ℭ.abs w * ℭ.abs z) 332 | (abs_inv : Π z, ℭ.abs (z⁻¹) = (ℭ.abs z)⁻¹) 333 | (abs_ge_zero) 334 | 335 | (pos_to_absℝ abs_monoℝ) 336 | 337 | (half ceil) 338 | 339 | (s) (σpos : 0 < ℭ.real_part s) 340 | 341 | : is_cauchy ℭ.abs (partial_pairs ℭ s) := 342 | 343 | begin 344 | let one_plus_σ_gt_one := has_add_left_lt.lt _ _ 1 σpos, 345 | 346 | rw has_zero_right_add_cancel.eq at one_plus_σ_gt_one, 347 | 348 | have abs_zeroℝ : ℭ.abs ↑(0 : ℝ) = 0, 349 | rw has_lift_zero_same.eq, 350 | refine abs_zero, 351 | 352 | have abs_oneℝ : ℭ.abs ↑(1 : ℝ) = 1, 353 | rw has_lift_one_same.eq, 354 | refine abs_one, 355 | 356 | have abs_addℝ : Π x y : ℝ, ℭ.abs ↑(x + y) ≤ ℭ.abs ↑x + ℭ.abs ↑y, 357 | intros, 358 | rw has_lift_add_comm.eq, 359 | refine abs_add _ _, 360 | 361 | have abs_subℝ : Π x y : ℝ, ℭ.abs ↑(x - y) = ℭ.abs ↑(y - x), 362 | intros, 363 | rw [has_lift_sub_comm.eq, has_lift_sub_comm.eq], 364 | refine abs_sub _ _, 365 | 366 | have abs_mulℝ : Π x y : ℝ, ℭ.abs ↑(x * y) = ℭ.abs ↑x * ℭ.abs ↑y, 367 | intros, 368 | rw has_lift_mul_comm.eq, 369 | refine abs_mul _ _, 370 | 371 | have abs_invℝ : Π x : ℝ, ℭ.abs ↑(x⁻¹) = (ℭ.abs ↑x)⁻¹, 372 | intros, 373 | rw has_lift_inv_comm.eq, 374 | refine abs_inv _, 375 | 376 | refine is_cauchy.comparison _ pos_to_absℝ _ abs_zero abs_add abs_ge_zero _ _ 377 | (term_pair.bounded_by_riemann_zeta _ 378 | abs_mul abs_sub abs_inv abs_add pos_to_absℝ _) 379 | (is_cauchy.closed.partial_sum_right_mul _ abs_mulℝ _ _ 380 | (term_pair.riemann_zeta_bound.abs_positive _ pos_to_absℝ _) 381 | (is_cauchy.closed.scaled_sequence_partial_sum _ abs_monoℝ _ 382 | (riemann_zeta.term.on_reals.nonneg _ _) _ (nat.zero_lt_one_add _) 383 | (riemann_zeta.partial.on_reals.is_cauchy _ _ 384 | abs_zeroℝ abs_oneℝ abs_addℝ abs_subℝ abs_mulℝ abs_invℝ 385 | (λ _, abs_ge_zero _) pos_to_absℝ 386 | half ceil _ 387 | one_plus_σ_gt_one))), 388 | end 389 | 390 | end dirichlet_eta --—————————————————————————————————————————————————————————————————————-- 391 | end riemann_hypothesis --————————————————————————————————————————————————————————————————-- 392 | -------------------------------------------------------------------------------- /src/cauchy.lean: -------------------------------------------------------------------------------- 1 | /- ------------------------------------------------------------------------- -| 2 | | @project: riemann_hypothesis | 3 | | @file: cauchy.lean | 4 | | @authors: Brandon H. Gomes, Alex Kontorovich | 5 | | @affil: Rutgers University | 6 | |- ------------------------------------------------------------------------- -/ 7 | 8 | import .exponential 9 | 10 | /-! 11 | -/ 12 | 13 | namespace riemann_hypothesis --——————————————————————————————————————————————————————————-- 14 | variables {α : Type*} {β : Type*} 15 | 16 | open algebra 17 | 18 | section cauchy --————————————————————————————————————————————————————————————————————————-- 19 | variables [has_lt α] [has_zero α] 20 | 21 | variables [has_sub β] 22 | 23 | variables (abs : β → α) 24 | 25 | variables (seq : nat → β) 26 | 27 | /-- 28 | -/ 29 | structure is_cauchy.struct (ε : α) (εpos : 0 < ε) 30 | := (index : nat) 31 | (boundedness : Π j, index ≤ j → abs (seq j - seq index) < ε) 32 | 33 | /-- 34 | -/ 35 | def is_cauchy 36 | := Π ε εpos, is_cauchy.struct abs seq ε εpos 37 | 38 | /-- 39 | -/ 40 | structure is_convergent.struct (ℓ : β) (ε : α) (εpos : 0 < ε) 41 | := (index : nat) 42 | (boundedness : Π n, index ≤ n → abs (ℓ - seq n) < ε) 43 | 44 | /-- 45 | -/ 46 | def is_convergent (ℓ) 47 | := Π ε εpos, is_convergent.struct abs seq ℓ ε εpos 48 | 49 | /-- 50 | -/ 51 | structure CauchySequence 52 | := (sequence : nat → β) 53 | (condition : is_cauchy abs sequence) 54 | 55 | /-- 56 | -/ 57 | structure ConvergentSequence 58 | := (sequence : nat → β) 59 | (limit : β) 60 | (condition : is_convergent abs sequence limit) 61 | 62 | end cauchy --————————————————————————————————————————————————————————————————————————————-- 63 | 64 | namespace is_cauchy --———————————————————————————————————————————————————————————————————-- 65 | variables [has_zero α] 66 | 67 | /-- 68 | -/ 69 | def from_convergent 70 | [has_add α] [preorder α] [has_add_lt_add α] 71 | 72 | [has_sub β] [has_add β] [has_sub_add_sub_cancel β] 73 | 74 | (abs : β → α) 75 | (abs_sub : Π x y, abs (x - y) = abs (y - x)) 76 | (abs_add : Π x y, abs (x + y) ≤ abs x + abs y) 77 | 78 | (half : Half α) 79 | 80 | (seq ℓ) 81 | 82 | : is_convergent abs seq ℓ → is_cauchy abs seq := 83 | 84 | begin 85 | intros convergence ε εpos, 86 | 87 | let cond := convergence _ (half.preserve_pos εpos), 88 | let i := cond.index, 89 | 90 | existsi i, 91 | 92 | intros _ le_j, 93 | 94 | rw ← has_sub_add_sub_cancel.eq _ ℓ _, 95 | 96 | refine lt_of_le_of_lt (abs_add _ _) _, 97 | 98 | rw abs_sub, 99 | rw ← half.doubled_inv ε, 100 | 101 | refine has_add_lt_add.lt 102 | (cond.boundedness _ le_j) (cond.boundedness _ (le_refl _)), 103 | end 104 | 105 | --———————————————————————————————————————————————————————————————————————————————————————-- 106 | variables [has_sub α] 107 | 108 | section closed_mul --————————————————————————————————————————————————————————————————————-- 109 | variables [has_lt α] [has_mul α] [has_inv α] 110 | 111 | section closed_left_mul --———————————————————————————————————————————————————————————————-- 112 | variables [has_left_sub_distributivity α] [has_left_inv_pos_lt α] 113 | [has_mul_zero_is_zero α] [has_right_mul_inv_lt_pos α] 114 | 115 | /-- 116 | -/ 117 | def closed.sequence_left_mul 118 | (abs : α → α) 119 | (abs_mul : Π x y, abs (x * y) = abs x * abs y) 120 | 121 | (seq) 122 | 123 | (C absC_pos) 124 | 125 | : is_cauchy abs seq → is_cauchy abs (λ n, C * seq n) := 126 | 127 | begin 128 | intros cauchy_condition ε εpos, 129 | 130 | let division := has_left_inv_pos_lt.lt absC_pos εpos, 131 | 132 | rw has_mul_zero_is_zero.eq at division, 133 | 134 | let cauchy := cauchy_condition _ division, 135 | 136 | existsi cauchy.index, 137 | intros _ le_j, 138 | 139 | rw ← has_left_sub_distributivity.eq, 140 | rw abs_mul, 141 | 142 | refine has_right_mul_inv_lt_pos.lt absC_pos (cauchy.boundedness _ le_j), 143 | end 144 | 145 | /-- 146 | -/ 147 | def closed.partial_sum_left_mul 148 | [has_add α] [has_left_add_distributivity α] 149 | 150 | (abs abs_mul) 151 | 152 | (seq : nat → α) 153 | 154 | (C absC_pos) 155 | 156 | : is_cauchy abs (partial_sum seq) → is_cauchy abs (partial_sum (λ n, C * seq n)) := 157 | 158 | begin 159 | rw partial_sum.left_mul_commute _ C, 160 | refine closed.sequence_left_mul _ abs_mul _ _ absC_pos, 161 | end 162 | 163 | end closed_left_mul --———————————————————————————————————————————————————————————————————-- 164 | 165 | section closed_right_mul --——————————————————————————————————————————————————————————————-- 166 | variables [has_right_sub_distributivity α] [has_right_inv_pos_lt α] 167 | [has_zero_mul_is_zero α] [has_left_mul_inv_lt_pos α] 168 | 169 | /-- 170 | -/ 171 | def closed.sequence_right_mul 172 | (abs : α → α) 173 | (abs_mul : Π x y, abs (x * y) = abs x * abs y) 174 | 175 | (seq) 176 | 177 | (C absC_pos) 178 | 179 | : is_cauchy abs seq → is_cauchy abs (λ n, seq n * C) := 180 | 181 | begin 182 | intros cauchy_condition ε εpos, 183 | 184 | let division := has_right_inv_pos_lt.lt absC_pos εpos, 185 | 186 | rw has_zero_mul_is_zero.eq at division, 187 | 188 | let cauchy := cauchy_condition _ division, 189 | 190 | existsi cauchy.index, 191 | intros _ le_j, 192 | 193 | rw ← has_right_sub_distributivity.eq, 194 | rw abs_mul, 195 | 196 | refine has_left_mul_inv_lt_pos.lt absC_pos (cauchy.boundedness _ le_j), 197 | end 198 | 199 | /-- 200 | -/ 201 | def closed.partial_sum_right_mul 202 | [has_add α] [has_right_add_distributivity α] 203 | 204 | (abs abs_mul) 205 | 206 | (seq : nat → α) 207 | 208 | (C absC_pos) 209 | 210 | : is_cauchy abs (partial_sum seq) → is_cauchy abs (partial_sum (λ n, seq n * C)) := 211 | 212 | begin 213 | rw partial_sum.right_mul_commute _ C, 214 | refine closed.sequence_right_mul _ abs_mul _ _ absC_pos, 215 | end 216 | 217 | end closed_right_mul --——————————————————————————————————————————————————————————————————-- 218 | 219 | end closed_mul --————————————————————————————————————————————————————————————————————————-- 220 | 221 | --———————————————————————————————————————————————————————————————————————————————————————-- 222 | variables [has_add α] 223 | [has_sub_self_is_zero α] [has_add_sub_assoc α] 224 | 225 | /-- 226 | -/ 227 | def closed.partial_sum_translate 228 | [has_lt α] 229 | (abs : α → α) 230 | (seq) (k) 231 | : is_cauchy abs (partial_sum (translate seq k)) → is_cauchy abs (partial_sum seq) := 232 | begin 233 | intros cauchy_condition ε εpos, 234 | 235 | let cauchy := cauchy_condition _ εpos, 236 | 237 | existsi k + cauchy.index, 238 | 239 | intros _ le, 240 | 241 | let index_ineq := nat.le_sub_left_of_add_le le, 242 | 243 | rw partial_sum.sub_as_translate seq le, 244 | rw ← translate.combine, 245 | rw ← nat.sub_sub, 246 | rw ← partial_sum.sub_as_translate (translate seq _) index_ineq, 247 | 248 | refine cauchy.boundedness _ index_ineq, 249 | end 250 | 251 | --———————————————————————————————————————————————————————————————————————————————————————-- 252 | variables [preorder α] [has_add_nonneg α] 253 | 254 | section comparison --————————————————————————————————————————————————————————————————————-- 255 | variables [has_add_le_add α] 256 | 257 | variables [has_zero β] [has_add β] [has_sub β] 258 | [has_add_sub_assoc β] [has_sub_self_is_zero β] 259 | 260 | variables (abs : α → α) 261 | (ge_zero_to_abs : Π z, 0 ≤ z → abs z = z) 262 | 263 | variables (abs_βα : β → α) 264 | (abs_βα_zero : abs_βα 0 = 0) 265 | (abs_βα_add : Π x y, abs_βα (x + y) ≤ abs_βα x + abs_βα y) 266 | (abs_βα_ge_zero : Π x, 0 ≤ abs_βα x) 267 | 268 | include ge_zero_to_abs abs_βα abs_βα_zero abs_βα_add abs_βα_ge_zero 269 | 270 | /-- 271 | -/ 272 | def comparison 273 | (a b) (le : abs_βα ∘ b ≤ a) 274 | 275 | : is_cauchy abs (partial_sum a) → is_cauchy abs_βα (partial_sum b) := 276 | 277 | begin 278 | intros cauchy_condition ε εpos, 279 | 280 | let cauchy := cauchy_condition _ εpos, 281 | 282 | existsi cauchy.index, 283 | 284 | intros _ le_j, 285 | 286 | refine lt_of_le_of_lt _ (cauchy.boundedness _ le_j), 287 | 288 | rw partial_sum.sub_as_translate a le_j, 289 | rw partial_sum.sub_as_translate b le_j, 290 | rw triangle_equality abs ge_zero_to_abs _ _ _, 291 | 292 | refine le_trans 293 | (triangle_inequality _ abs_βα_zero abs_βα_add _ _) 294 | (partial_sum.monotonicity (translate.monotonicity le _) _), 295 | 296 | refine λ _, le_trans (abs_βα_ge_zero _) (le _), 297 | end 298 | 299 | /-- 300 | -/ 301 | def closed.inclusion 302 | (seq) 303 | 304 | : is_cauchy abs (partial_sum (abs_βα ∘ seq)) → is_cauchy abs_βα (partial_sum seq) := 305 | 306 | begin 307 | refine comparison _ 308 | ge_zero_to_abs abs_βα abs_βα_zero abs_βα_add abs_βα_ge_zero _ _ 309 | (λ _, le_refl _), 310 | end 311 | 312 | end comparison --————————————————————————————————————————————————————————————————————————-- 313 | 314 | --———————————————————————————————————————————————————————————————————————————————————————-- 315 | variables [has_zero_right_add_cancel α] [has_add_le_add α] [has_le_sub_add_le α] 316 | [has_le_add_of_nonneg_of_le α] 317 | 318 | /-- 319 | -/ 320 | def closed.subsequence_partial_sum.ineq 321 | (seq : nat → α) 322 | 323 | (nonneg φ sinc_φ i j) 324 | 325 | : i ≤ j → partial_sum (seq ∘ φ) j - partial_sum (seq ∘ φ) i 326 | ≤ partial_sum seq (φ j) - partial_sum seq (φ i) := 327 | 328 | begin 329 | let strong_inc_φ := strictly_increasing.as_increasing_strong _ sinc_φ, 330 | 331 | intros i_le_j, 332 | 333 | rw partial_sum.sub_as_translate (seq ∘ φ) i_le_j, 334 | rw partial_sum.sub_as_translate seq (strong_inc_φ _ _ i_le_j), 335 | 336 | induction j with _ hj, 337 | cases i_le_j, 338 | rw [nat.sub_self, nat.sub_self, partial_sum, partial_sum], 339 | 340 | cases nat.of_le_succ i_le_j, 341 | rw nat.succ_sub h, 342 | 343 | refine le_trans 344 | (has_add_le_add.le (le_refl _) (hj h)) (has_le_sub_add_le.le _), 345 | 346 | rw partial_sum.sub_as_translate 347 | (translate seq _) (nat.sub_le_sub_right (le_of_lt (sinc_φ _)) _), 348 | 349 | rw translate.combine, 350 | rw nat.add_sub_of_le (strong_inc_φ _ _ h), 351 | rw nat.sub_sub_sub_cancel_right (strong_inc_φ _ _ h), 352 | rw translate, 353 | rw nat.add_sub_of_le h, 354 | 355 | refine le_trans _ 356 | (partial_sum.double_monotonicity _ 1 _ _ 357 | (translate.preserve_nonneg _ nonneg _) 358 | (λ _, le_refl _) (nat.le_sub_left_of_add_le (sinc_φ _))), 359 | 360 | rw [partial_sum, partial_sum, translate], 361 | rw has_zero_right_add_cancel.eq, 362 | rw nat.add_zero, 363 | rw [h, nat.sub_self, partial_sum], 364 | 365 | refine partial_sum.preserve_nonneg _ 366 | (translate.preserve_nonneg _ nonneg _) _, 367 | end 368 | 369 | /-- 370 | -/ 371 | def closed.subsequence_partial_sum 372 | (abs : α → α) 373 | (abs_mono : Π x y, 0 ≤ x → x ≤ y → abs x ≤ abs y) 374 | 375 | (seq nonneg) 376 | 377 | (φ sinc_φ) 378 | 379 | : is_cauchy abs (partial_sum seq) → is_cauchy abs (partial_sum (seq ∘ φ)) := 380 | 381 | begin 382 | intros cauchy_condition ε εpos, 383 | 384 | let ge_index := strictly_increasing.ge_index _ sinc_φ, 385 | let cauchy := cauchy_condition ε εpos, 386 | 387 | existsi cauchy.index, 388 | 389 | intros _ le_j, 390 | 391 | let strong_inc := strictly_increasing.as_increasing_strong _ sinc_φ _ _ le_j, 392 | 393 | refine lt_of_le_of_lt 394 | (le_trans 395 | (abs_mono _ _ 396 | (partial_sum.lower_differences.bottom _ 397 | (nonneg_compose_preserve _ _ nonneg) le_j) 398 | (closed.subsequence_partial_sum.ineq _ nonneg _ sinc_φ _ _ le_j)) 399 | (abs_mono _ _ 400 | (partial_sum.lower_differences.bottom _ nonneg strong_inc) 401 | (partial_sum.lower_differences _ nonneg (ge_index _) strong_inc))) 402 | (cauchy.boundedness _ (le_trans le_j (ge_index _))), 403 | end 404 | 405 | /-- 406 | -/ 407 | def closed.scaled_sequence_partial_sum 408 | (abs : α → α) 409 | (abs_mono) 410 | 411 | (seq nonneg) 412 | 413 | (N Npos) 414 | 415 | : is_cauchy abs (partial_sum seq) → is_cauchy abs (partial_sum (λ n, seq (N * n))) 416 | 417 | := closed.subsequence_partial_sum _ 418 | abs_mono _ nonneg _ (λ _, nat.lt_add_of_pos_right Npos) 419 | 420 | end is_cauchy --—————————————————————————————————————————————————————————————————————————-- 421 | 422 | namespace condensation --————————————————————————————————————————————————————————————————-- 423 | variables [preorder α] [has_zero α] [has_one α] [has_sub α] [has_add α] [has_mul α] 424 | [has_sub_self_is_zero α] [has_add_sub_assoc α] 425 | [has_sub_add_sub_cancel α] [has_add_nonneg α] [has_add_le_add α] 426 | [has_le_add_of_nonneg_of_le α] 427 | 428 | /-- 429 | -/ 430 | def shape_sum_comparison 431 | (abs : α → α) 432 | (ge_zero_to_abs : Π z, 0 ≤ z → abs z = z) 433 | 434 | (seq nonneg) 435 | 436 | (φ sinc_φ) 437 | 438 | : is_cauchy abs (partial_sum (shape_sum seq φ)) 439 | → is_cauchy abs (partial_sum (translate seq (φ 0))) := 440 | 441 | begin 442 | intros cauchy_condition ε εpos, 443 | 444 | let translate_nonneg := translate.preserve_nonneg _ nonneg _, 445 | let strong_inc := strictly_increasing.as_increasing_strong _ sinc_φ, 446 | let cauchy := cauchy_condition _ εpos, 447 | 448 | existsi φ cauchy.index - φ 0, 449 | 450 | intros _ le_j, 451 | 452 | let I_le_ju0 453 | := le_trans 454 | (strictly_increasing.ge_index _ sinc_φ _) 455 | (nat.le_add_of_sub_le_right le_j), 456 | 457 | rw partial_sum.sub_as_translate (translate seq _) le_j, 458 | rw translate.combine, 459 | rw nat.add_sub_of_le (strong_inc _ _ (nat.zero_le _)), 460 | rw nat.neg_right_swap (strong_inc _ _ (nat.zero_le _)), 461 | rw triangle_equality abs ge_zero_to_abs _ translate_nonneg _, 462 | 463 | let condition := cauchy.boundedness _ I_le_ju0, 464 | 465 | rw partial_sum.sub_as_translate (shape_sum seq _) I_le_ju0 at condition, 466 | rw shape_sum.unfold seq _ sinc_φ I_le_ju0 at condition, 467 | rw triangle_equality abs ge_zero_to_abs _ translate_nonneg _ at condition, 468 | 469 | refine lt_of_le_of_lt 470 | (partial_sum.index_monotonicity _ translate_nonneg 471 | (nat.sub_le_sub_right (strictly_increasing.ge_index _ sinc_φ _) _)) 472 | condition, 473 | end 474 | 475 | --———————————————————————————————————————————————————————————————————————————————————————-- 476 | variables [has_lift_t nat α] [has_lift_zero_same nat α] [has_lift_one_same nat α] 477 | [has_lift_add_comm nat α] [has_zero_mul_is_zero α] [has_left_unit α] 478 | [has_right_add_distributivity α] 479 | 480 | variables (abs : α → α) 481 | (abs_zero : abs 0 = 0) 482 | (abs_ge_zero : Π x, 0 ≤ abs x) 483 | (abs_add : Π x y, abs (x + y) ≤ abs x + abs y) 484 | (ge_zero_to_abs : Π z, 0 ≤ z → abs z = z) 485 | 486 | variables (seq : nat → α) 487 | (nonneg : 0 ≤ seq) 488 | (non_inc : non_increasing seq) 489 | 490 | include abs abs_zero abs_ge_zero abs_add ge_zero_to_abs seq nonneg non_inc 491 | 492 | /-- 493 | -/ 494 | def cauchy_schlomilch_test 495 | (φ) (sinc_φ : strictly_increasing φ) 496 | 497 | : is_cauchy abs (partial_sum (λ n, ↑(nat.successive_difference φ n) * seq (φ n))) 498 | → is_cauchy abs (partial_sum seq) := 499 | 500 | begin 501 | intros cauchy, 502 | 503 | let comparison 504 | := is_cauchy.comparison _ 505 | ge_zero_to_abs abs abs_zero abs_add abs_ge_zero _ _ _, 506 | 507 | refine is_cauchy.closed.partial_sum_translate _ _ _ 508 | (shape_sum_comparison _ ge_zero_to_abs _ nonneg _ sinc_φ (comparison cauchy)), 509 | 510 | intros _, 511 | 512 | rw function.comp_app, 513 | rw shape_sum, 514 | rw partial_sum.sub_as_translate seq (le_of_lt (sinc_φ _)), 515 | rw partial_sum.from_mul, 516 | 517 | refine le_trans 518 | (triangle_inequality _ abs_zero abs_add _ _) (partial_sum.monotonicity _ _), 519 | 520 | intros _, 521 | 522 | rw function.comp_app, 523 | rw translate, 524 | rw ge_zero_to_abs _ (nonneg _), 525 | 526 | refine non_increasing.as_non_increasing_strong _ non_inc _ _, 527 | end 528 | 529 | /-- 530 | -/ 531 | def cauchy_test 532 | : is_cauchy abs (partial_sum (λ n, ↑(2 ^ n) * seq (2 ^ n - 1))) 533 | → is_cauchy abs (partial_sum seq) := 534 | 535 | begin 536 | let result 537 | := cauchy_schlomilch_test _ 538 | abs_zero abs_ge_zero abs_add ge_zero_to_abs _ nonneg non_inc _ _, 539 | 540 | rw (_ : nat.successive_difference (λ n, 2 ^ n - 1) = pow 2) at result, 541 | 542 | refine result, 543 | refine funext _, 544 | 545 | intros _, 546 | 547 | rw nat.successive_difference, 548 | rw nat.sub_sub, 549 | rw ← nat.add_sub_assoc (nat.pow_two_ge_one _), 550 | rw nat.add_sub_cancel_left, 551 | rw (nat.sub_eq_iff_eq_add _).2 _, 552 | 553 | refine nat.le_add_left _ _, 554 | refine nat.mul_two _, 555 | 556 | intros _, 557 | 558 | refine nat.sub_mono_left_strict (nat.pow_two_ge_one _) (nat.pow_two_monotonic _), 559 | end 560 | 561 | end condensation --——————————————————————————————————————————————————————————————————————-- 562 | 563 | namespace geometric --———————————————————————————————————————————————————————————————————-- 564 | variables [has_zero α] [has_one α] [has_add α] [has_mul α] [has_sub α] [has_inv α] 565 | [has_mul_assoc α] [has_zero_right_add_cancel α] [has_right_unit α] 566 | [has_sub_ne_zero_of_ne α] [has_right_sub_distributivity α] 567 | [has_sub_self_is_zero α] [has_inv_mul_right_cancel_self α] 568 | [has_left_sub_distributivity α] [has_add_sub_exchange α] 569 | [has_right_add_distributivity α] 570 | 571 | section series_definitions --————————————————————————————————————————————————————————————-- 572 | local notation a `^` n := nat.power a n 573 | 574 | /-- 575 | -/ 576 | def series.formula 577 | (x : α) (x_ne_1 : x ≠ 1) 578 | 579 | (n) 580 | 581 | : partial_sum (nat.power x) n = (1 - x ^ n) * (1 - x)⁻¹ := 582 | 583 | begin 584 | induction n with n hn, 585 | rw partial_sum, 586 | rw nat.power, 587 | rw has_right_sub_distributivity.eq, 588 | rw has_sub_self_is_zero.eq, 589 | 590 | rw partial_sum, 591 | rw nat.power, 592 | rw hn, 593 | 594 | rw (_ : x ^ n + (1 - x ^ n) * (1 - x)⁻¹ 595 | = x ^ n * (1 - x) * (1 - x)⁻¹ + (1 - x ^ n) * (1 - x)⁻¹), 596 | 597 | rw ← has_right_add_distributivity.eq, 598 | rw has_left_sub_distributivity.eq, 599 | rw has_right_unit.eq, 600 | rw has_add_sub_exchange.eq, 601 | rw has_sub_self_is_zero.eq, 602 | rw has_zero_right_add_cancel.eq, 603 | rw has_mul_assoc.eq, 604 | rw has_inv_mul_right_cancel_self.eq _ 605 | (has_sub_ne_zero_of_ne.ne x_ne_1.symm), 606 | 607 | rw has_right_unit.eq, 608 | end 609 | 610 | end series_definitions --————————————————————————————————————————————————————————————————-- 611 | 612 | section series_is_cauchy --——————————————————————————————————————————————————————————————-- 613 | 614 | /-- 615 | -/ 616 | def series.is_cauchy 617 | [has_lift_t nat α] 618 | [has_lift_add_comm nat α] 619 | [has_lift_zero_same nat α] 620 | [has_lift_one_same nat α] 621 | 622 | [preorder α] 623 | [has_add_lt_add α] 624 | [has_left_add_distributivity α] 625 | [has_sub_add_sub_cancel α] 626 | [has_sub_sub α] 627 | [has_mul_zero_is_zero α] 628 | [has_left_unit α] 629 | [has_inv_right_mul_lt_pos α] 630 | [has_left_mul_inv_lt_neg α] 631 | [has_zero_left_add_cancel α] 632 | [has_zero_lt_one α] 633 | [has_mul_pos α] 634 | [has_sub_pos α] 635 | 636 | (abs : α → α) 637 | (abs_one : abs 1 = 1) 638 | (abs_inv : Π a, abs (a⁻¹) = (abs a)⁻¹) 639 | (abs_sub : Π x y, abs (x - y) = abs (y - x)) 640 | (abs_add : Π x y, abs (x + y) ≤ abs x + abs y) 641 | (abs_mul : Π x y, abs (x * y) = abs x * abs y) 642 | (ge_zero_to_abs : Π a, 0 ≤ a → abs a = a) 643 | 644 | (ℯ : ExpLog α α) 645 | 646 | (half : Half α) 647 | 648 | (ceil : LiftCeil α) 649 | 650 | (x : α) (xpos : 0 < x) (x_lt_one : x < 1) 651 | 652 | : is_cauchy abs (partial_sum (ℯ.nat_pow x xpos)) := 653 | 654 | begin 655 | refine is_cauchy.from_convergent abs abs_sub abs_add half _ (1 - x)⁻¹ _, 656 | 657 | intros ε εpos, 658 | 659 | have abs_x_pos : 0 < abs x, 660 | rw ge_zero_to_abs _ (le_of_lt xpos), 661 | refine xpos, 662 | 663 | have abs_x_lt_one : abs x < 1, 664 | rw ge_zero_to_abs _ (le_of_lt xpos), 665 | refine x_lt_one, 666 | 667 | let one_minus_x_pos 668 | := has_sub_pos.lt x_lt_one, 669 | 670 | let ε_mul_one_minus_x 671 | := has_mul_pos.lt εpos one_minus_x_pos, 672 | 673 | existsi (ceil.map (ℯ.log _ ε_mul_one_minus_x * (ℯ.log _ abs_x_pos)⁻¹)).succ, 674 | 675 | intros n le_n, 676 | 677 | rw ← ℯ.nat_pow_to_nat_power, 678 | rw series.formula _ (ne_of_lt x_lt_one), 679 | rw has_right_sub_distributivity.eq, 680 | rw has_left_unit.eq, 681 | rw has_sub_sub.eq, 682 | rw has_sub_self_is_zero.eq, 683 | rw has_zero_left_add_cancel.eq, 684 | rw abs_mul, 685 | rw abs_inv, 686 | rw ge_zero_to_abs _ (le_of_lt one_minus_x_pos), 687 | rw nat.power.mul_commute _ abs_one abs_mul, 688 | 689 | refine has_inv_right_mul_lt_pos.lt one_minus_x_pos _, 690 | 691 | rw ℯ.nat_pow_to_nat_power, 692 | rw ← ℯ.log_inverted _ ε_mul_one_minus_x, 693 | 694 | refine ℯ.exp_monotonic (has_left_mul_inv_lt_neg.lt 695 | (ℯ.log_lt_one_is_lt_zero abs_x_pos abs_x_lt_one) (ceil.lift_lt le_n)), 696 | end 697 | 698 | end series_is_cauchy --——————————————————————————————————————————————————————————————————-- 699 | end geometric --—————————————————————————————————————————————————————————————————————————-- 700 | 701 | end riemann_hypothesis --————————————————————————————————————————————————————————————————-- 702 | -------------------------------------------------------------------------------- /src/basic.lean: -------------------------------------------------------------------------------- 1 | /- ------------------------------------------------------------------------- -| 2 | | @project: riemann_hypothesis | 3 | | @file: basic.lean | 4 | | @authors: Brandon H. Gomes, Alex Kontorovich | 5 | | @affil: Rutgers University | 6 | |- ------------------------------------------------------------------------- -/ 7 | 8 | /-! 9 | -/ 10 | 11 | namespace riemann_hypothesis --——————————————————————————————————————————————————————————-- 12 | variables {α : Type*} {β : Type*} 13 | 14 | /-- 15 | -/ 16 | def const (b : β) 17 | := λ _ : α, b 18 | notation `↓`:max b:max := const b 19 | 20 | section pointwise_classes --—————————————————————————————————————————————————————————————-- 21 | 22 | /-- 23 | -/ 24 | instance pointwise.has_le [has_le β] : has_le (α → β) 25 | := ⟨λ f g, Π x, f x ≤ g x⟩ 26 | 27 | /-- 28 | -/ 29 | instance pointwise.has_zero [has_zero β] : has_zero (α → β) 30 | := ⟨↓0⟩ 31 | 32 | end pointwise_classes --—————————————————————————————————————————————————————————————————-- 33 | 34 | namespace algebra --—————————————————————————————————————————————————————————————————————-- 35 | variables (α) (β) 36 | 37 | /-- 38 | -/ 39 | class has_left_add_distributivity [has_add α] [has_mul α] 40 | := (eq : Π x y z : α, x * (y + z) = x * y + x * z) 41 | 42 | /-- 43 | -/ 44 | class has_right_add_distributivity [has_add α] [has_mul α] 45 | := (eq : Π x y z : α, (y + z) * x = y * x + z * x) 46 | 47 | /-- 48 | -/ 49 | class has_left_sub_distributivity [has_sub α] [has_mul α] 50 | := (eq : Π x y z : α, x * (y - z) = x * y - x * z) 51 | 52 | /-- 53 | -/ 54 | class has_right_sub_distributivity [has_sub α] [has_mul α] 55 | := (eq : Π x y z : α, (y - z) * x = y * x - z * x) 56 | 57 | /-- 58 | -/ 59 | class has_lift_add_comm [has_lift_t α β] [has_add α] [has_add β] 60 | := (eq : Π x y : α, (↑(x + y) : β) = ↑x + ↑y) 61 | 62 | /-- 63 | -/ 64 | class has_lift_sub_comm [has_lift_t α β] [has_sub α] [has_sub β] 65 | := (eq : Π x y : α, (↑(x - y) : β) = ↑x - ↑y) 66 | 67 | /-- 68 | -/ 69 | class has_lift_mul_comm [has_lift_t α β] [has_mul α] [has_mul β] 70 | := (eq : Π x y : α, (↑(x * y) : β) = ↑x * ↑y) 71 | 72 | /-- 73 | -/ 74 | class has_lift_inv_comm [has_lift_t α β] [has_inv α] [has_inv β] 75 | := (eq : Π a : α, (↑(a⁻¹) : β) = (↑a)⁻¹) 76 | 77 | /-- 78 | -/ 79 | class has_right_unit [has_one α] [has_mul α] 80 | := (eq : Π a : α, a * 1 = a) 81 | 82 | /-- 83 | -/ 84 | class has_left_unit [has_one α] [has_mul α] 85 | := (eq : Π a : α, 1 * a = a) 86 | 87 | /-- 88 | -/ 89 | class has_add_le_add [has_le α] [has_add α] 90 | := (le : Π {a b c d : α}, a ≤ b → c ≤ d → a + c ≤ b + d) 91 | 92 | /-- 93 | -/ 94 | class has_add_lt_add [has_lt α] [has_add α] 95 | := (lt : Π {a b c d : α}, a < b → c < d → a + c < b + d) 96 | 97 | /-- 98 | -/ 99 | class has_le_add_of_nonneg_of_le [has_le α] [has_zero α] [has_add α] 100 | := (le : Π {a b c : α}, 0 ≤ a → b ≤ c → b ≤ a + c) 101 | 102 | /-- 103 | -/ 104 | class has_lt_add_of_le_of_pos [has_le α] [has_lt α] [has_zero α] [has_add α] 105 | := (lt : Π {a b c : α}, 0 < a → b ≤ c → b < a + c) 106 | 107 | /-- 108 | -/ 109 | class has_add_nonneg [has_le α] [has_zero α] [has_add α] 110 | := (le : Π {a b : α}, 0 ≤ a → 0 ≤ b → 0 ≤ a + b) 111 | 112 | /-- 113 | -/ 114 | class has_zero_mul_is_zero [has_zero α] [has_mul α] 115 | := (eq : Π a : α, 0 * a = 0) 116 | 117 | /-- 118 | -/ 119 | class has_mul_zero_is_zero [has_zero α] [has_mul α] 120 | := (eq : Π a : α, a * 0 = 0) 121 | 122 | /-- 123 | -/ 124 | class has_lift_zero_same [has_lift_t α β] [has_zero α] [has_zero β] 125 | := (eq : ↑(0 : α) = (0 : β)) 126 | 127 | /-- 128 | -/ 129 | class has_lift_one_same [has_lift_t α β] [has_one α] [has_one β] 130 | := (eq : ↑(1 : α) = (1 : β)) 131 | 132 | /-- 133 | -/ 134 | class has_zero_right_add_cancel [has_zero α] [has_add α] 135 | := (eq : Π a : α, a + 0 = a) 136 | 137 | /-- 138 | -/ 139 | class has_zero_left_add_cancel [has_zero α] [has_add α] 140 | := (eq : Π a : α, 0 + a = a) 141 | 142 | /-- 143 | -/ 144 | class has_sub_self_is_zero [has_zero α] [has_sub α] 145 | := (eq : Π a : α, a - a = 0) 146 | 147 | /-- 148 | -/ 149 | class has_mul_assoc [has_mul α] 150 | := (eq : Π a b c : α, (a * b) * c = a * (b * c)) 151 | 152 | /-- 153 | -/ 154 | class has_add_sub_assoc [has_add α] [has_sub α] 155 | := (eq : Π a b c : α, (a + b) - c = a + (b - c)) 156 | 157 | /-- 158 | -/ 159 | class has_le_sub_add_le [has_le α] [has_sub α] [has_add α] 160 | := (le : Π {a b c : α}, a ≤ c - b → a + b ≤ c) 161 | 162 | /-- 163 | -/ 164 | class has_le_pos_mul_preserves_right [has_lt α] [has_le α] [has_zero α] [has_mul α] 165 | := (le : Π {a b c : α}, 0 < c → a ≤ b → a * c ≤ b * c) 166 | 167 | /-- 168 | -/ 169 | class has_le_pos_mul_preserves_left [has_lt α] [has_le α] [has_zero α] [has_mul α] 170 | := (le : Π {a b c : α}, 0 < c → a ≤ b → c * a ≤ c * b) 171 | 172 | /-- 173 | -/ 174 | class has_lt_pos_mul_preserves_right [has_lt α] [has_zero α] [has_mul α] 175 | := (lt : Π {a b c : α}, 0 < c → a < b → a * c < b * c) 176 | 177 | /-- 178 | -/ 179 | class has_le_nonneg_mul_preserves_left [has_lt α] [has_le α] [has_zero α] [has_mul α] 180 | := (le : Π {a b c : α}, 0 ≤ c → a ≤ b → c * a ≤ c * b) 181 | 182 | /-- 183 | -/ 184 | class has_le_nonneg_mul_preserves_right [has_lt α] [has_le α] [has_zero α] [has_mul α] 185 | := (le : Π {a b c : α}, 0 ≤ c → a ≤ b → a * c ≤ b * c) 186 | 187 | /-- 188 | -/ 189 | class has_lift_le_comm [has_lift_t α β] [has_le α] [has_le β] 190 | := (le : Π {x y : α}, x ≤ y → ↑x ≤ (↑y : β)) 191 | 192 | /-- 193 | -/ 194 | class has_lift_lt_comm [has_lift_t α β] [has_lt α] [has_lt β] 195 | := (lt : Π {x y : α}, x < y → ↑x < (↑y : β)) 196 | 197 | /-- 198 | -/ 199 | class has_lift_ne_comm [has_lift_t α β] 200 | := (ne : Π {x y : α}, x ≠ y → ↑x ≠ (↑y : β)) 201 | 202 | /-- 203 | -/ 204 | class has_sub_add_sub_cancel [has_sub α] [has_add α] 205 | := (eq : Π a b c : α, a - b + (b - c) = a - c) 206 | 207 | /-- 208 | -/ 209 | class has_double_sub_cancel [has_sub α] 210 | := (eq : Π a b : α, a - (a - b) = b) 211 | 212 | /-- 213 | -/ 214 | class has_inv_mul_right_cancel_self [has_zero α] [has_one α] [has_inv α] [has_mul α] 215 | := (eq : Π a : α, a ≠ 0 → a * a⁻¹ = 1) 216 | 217 | /-- 218 | -/ 219 | class has_inv_mul_left_cancel_self [has_zero α] [has_one α] [has_inv α] [has_mul α] 220 | := (eq : Π a : α, a ≠ 0 → a⁻¹ * a = 1) 221 | 222 | /-- 223 | -/ 224 | class has_add_sub_exchange [has_add α] [has_sub α] 225 | := (eq : Π a b c d : α, (a - b) + (c - d) = (c - b) + (a - d)) 226 | 227 | /-- 228 | -/ 229 | class has_zero_sub_is_neg [has_zero α] [has_neg α] [has_sub α] 230 | := (eq : Π a : α, 0 - a = -a) 231 | 232 | /-- 233 | -/ 234 | class has_inv_right_mul_lt_pos [has_lt α] [has_zero α] [has_mul α] [has_inv α] 235 | := (lt : Π {a b c : α}, 0 < b → a < c * b → a * b⁻¹ < c) 236 | 237 | /-- 238 | -/ 239 | class has_right_mul_inv_lt_pos [has_lt α] [has_zero α] [has_mul α] [has_inv α] 240 | := (lt : Π {a b c : α}, 0 < b → c < b⁻¹ * a → b * c < a) 241 | 242 | /-- 243 | -/ 244 | class has_left_mul_inv_lt_pos [has_lt α] [has_zero α] [has_mul α] [has_inv α] 245 | := (lt : Π {a b c : α}, 0 < b → c < a * b⁻¹ → c * b < a) 246 | 247 | /-- 248 | -/ 249 | class has_left_mul_inv_lt_neg [has_lt α] [has_zero α] [has_mul α] [has_inv α] 250 | := (lt : Π {a b c : α}, b < 0 → a * b⁻¹ < c → b * c < a) 251 | 252 | /-- 253 | -/ 254 | class has_sub_ne_zero_of_ne [has_zero α] [has_sub α] 255 | := (ne : Π {a b : α}, a ≠ b → a - b ≠ 0) 256 | 257 | /-- 258 | -/ 259 | class has_lt_sub_neg [has_lt α] [has_zero α] [has_sub α] 260 | := (lt : Π {a b : α}, a < b → a - b < 0) 261 | 262 | /-- 263 | -/ 264 | class has_zero_lt_one [has_lt α] [has_zero α] [has_one α] 265 | := (lt : 0 < (1 : α)) 266 | 267 | /-- 268 | -/ 269 | class has_pos_mul_neg_is_neg [has_lt α] [has_zero α] [has_mul α] 270 | := (lt : Π {a b : α}, 0 < a → b < 0 → a * b < 0) 271 | 272 | /-- 273 | -/ 274 | class has_nonneg_mul_nonneg_is_nonneg [has_le α] [has_zero α] [has_mul α] 275 | := (le : Π {a b : α}, 0 ≤ a → 0 ≤ b → 0 ≤ a * b) 276 | 277 | /-- 278 | -/ 279 | class has_squared_le_monotonic [has_le α] [has_zero α] [has_mul α] 280 | := (le : Π {a b : α}, 0 ≤ a → a ≤ b → a * a ≤ b * b) 281 | 282 | /-- 283 | -/ 284 | class has_sub_pos [has_lt α] [has_zero α] [has_sub α] 285 | := (lt : Π {a b : α}, a < b → 0 < b - a) 286 | 287 | /-- 288 | -/ 289 | class has_sub_sub [has_add α] [has_sub α] 290 | := (eq : Π a b c : α, a - (b - c) = (a - b) + c) 291 | 292 | /-- 293 | -/ 294 | class has_add_left_lt [has_lt α] [has_add α] 295 | := (lt : Π a b c : α, a < b → c + a < c + b) 296 | 297 | /-- 298 | -/ 299 | class has_left_inv_pos_lt [has_lt α] [has_zero α] [has_mul α] [has_inv α] 300 | := (lt : Π {a b c : α}, 0 < c → a < b → c⁻¹ * a < c⁻¹ * b) 301 | 302 | /-- 303 | -/ 304 | class has_right_inv_pos_lt [has_lt α] [has_zero α] [has_mul α] [has_inv α] 305 | := (lt : Π {a b c : α}, 0 < c → a < b → a * c⁻¹ < b * c⁻¹) 306 | 307 | /-- 308 | -/ 309 | class has_mul_pos [has_lt α] [has_zero α] [has_mul α] 310 | := (lt : Π {a b : α}, 0 < a → 0 < b → 0 < a * b) 311 | 312 | /-- 313 | -/ 314 | class has_inv_pos [has_lt α] [has_zero α] [has_inv α] 315 | := (lt : Π {a : α}, 0 < a → 0 < a⁻¹) 316 | 317 | /-- 318 | -/ 319 | class has_inv_reverses_le [has_le α] [has_inv α] 320 | := (le : Π {a b : α}, a ≤ b → b⁻¹ ≤ a⁻¹) 321 | 322 | /-- 323 | -/ 324 | class has_inv_reverses_lt [has_lt α] [has_inv α] 325 | := (lt : Π {a b : α}, a < b → b⁻¹ < a⁻¹) 326 | 327 | /-- 328 | -/ 329 | class has_inv_mul_reverse [has_inv α] [has_mul α] 330 | := (eq : Π a b : α, (a * b)⁻¹ = b⁻¹ * a⁻¹) 331 | 332 | /-- 333 | -/ 334 | structure Half [has_lt α] [has_zero α] [has_add α] 335 | := (map : α → α) 336 | (preserve_pos : Π {x}, 0 < x → 0 < map x) 337 | (doubled_inv : Π (x), map x + map x = x) 338 | 339 | /-- 340 | -/ 341 | structure LiftCeil [has_lift_t nat α] [has_lt α] 342 | := (map : α → nat) 343 | (lift_lt : Π {a n}, map a < n → a < ↑n) 344 | 345 | section lemmas --————————————————————————————————————————————————————————————————————————-- 346 | variables {α β} 347 | 348 | /-- 349 | -/ 350 | def inv_sub_inv_lemma 351 | [has_zero α] 352 | [has_one α] 353 | [has_inv α] 354 | [has_mul α] 355 | [has_sub α] 356 | [has_right_unit α] 357 | [has_left_unit α] 358 | [has_inv_mul_right_cancel_self α] 359 | [has_mul_assoc α] 360 | [has_right_sub_distributivity α] 361 | {a b : α} 362 | (a_ne_0 : a ≠ 0) 363 | : a⁻¹ - b⁻¹ = (1 - b⁻¹ * a) * a⁻¹ := 364 | begin 365 | rw has_right_sub_distributivity.eq, 366 | rw has_mul_assoc.eq, 367 | rw has_inv_mul_right_cancel_self.eq _ a_ne_0, 368 | rw has_left_unit.eq, 369 | rw has_right_unit.eq, 370 | end 371 | 372 | /-- 373 | -/ 374 | def inv_sub_inv_lemma' 375 | [has_zero α] 376 | [has_one α] 377 | [has_inv α] 378 | [has_mul α] 379 | [has_sub α] 380 | [has_right_unit α] 381 | [has_left_unit α] 382 | [has_inv_mul_left_cancel_self α] 383 | [has_mul_assoc α] 384 | [has_left_sub_distributivity α] 385 | {a b : α} 386 | (a_ne_0 : a ≠ 0) 387 | : a⁻¹ - b⁻¹ = a⁻¹ * (1 - a * b⁻¹) := 388 | begin 389 | rw has_left_sub_distributivity.eq, 390 | rw ← has_mul_assoc.eq, 391 | rw has_inv_mul_left_cancel_self.eq _ a_ne_0, 392 | rw has_left_unit.eq, 393 | rw has_right_unit.eq, 394 | end 395 | 396 | /-- 397 | -/ 398 | def mul_inv_add_one_lemma 399 | [has_lift_t nat α] 400 | [has_zero α] 401 | [has_one α] 402 | [has_sub α] 403 | [has_mul α] 404 | [has_inv α] 405 | [has_left_unit α] 406 | [has_inv_mul_right_cancel_self α] 407 | [has_right_sub_distributivity α] 408 | [has_lift_zero_same nat α] 409 | [has_lift_one_same nat α] 410 | [has_lift_sub_comm nat α] 411 | [has_lift_ne_comm nat α] 412 | (n : nat) 413 | : (↑n : α) * (↑n.succ)⁻¹ = 1 - (↑n.succ)⁻¹ := 414 | begin 415 | rw ← has_left_unit.eq (↑n.succ : α)⁻¹, 416 | 417 | have succ_non_zero : ↑n.succ ≠ (0 : α), 418 | rw (_ : 0 = (↑0 : α)), 419 | refine has_lift_ne_comm.ne (nat.succ_ne_zero _), 420 | rw has_lift_zero_same.eq, 421 | 422 | rw ← has_inv_mul_right_cancel_self.eq _ succ_non_zero, 423 | rw ← has_right_sub_distributivity.eq, 424 | rw has_inv_mul_right_cancel_self.eq _ succ_non_zero, 425 | rw has_left_unit.eq, 426 | 427 | rw (_ : 1 = (↑1 : α)), 428 | 429 | rw ← has_lift_sub_comm.eq, 430 | rw nat.succ_sub_one, 431 | rw has_lift_one_same.eq, 432 | end 433 | 434 | /-- 435 | -/ 436 | def two_mul_lemma 437 | [has_one α] 438 | [has_add α] 439 | [has_mul α] 440 | [has_right_add_distributivity α] 441 | [has_left_unit α] 442 | (a : α) 443 | : 2 * a = a + a := 444 | begin 445 | refine (has_right_add_distributivity.eq _ _ _).trans _, 446 | rw has_left_unit.eq, 447 | end 448 | 449 | /-- 450 | -/ 451 | def two_mul_lemma' 452 | [has_one α] 453 | [has_add α] 454 | [has_mul α] 455 | [has_left_add_distributivity α] 456 | [has_right_unit α] 457 | (a : α) 458 | : a * 2 = a + a := 459 | begin 460 | refine (has_left_add_distributivity.eq _ _ _).trans _, 461 | rw has_right_unit.eq, 462 | end 463 | 464 | /-- 465 | -/ 466 | def two_squares_is_four_lemma 467 | [has_one α] 468 | 469 | [has_add α] [has_mul α] 470 | 471 | [has_left_unit α] 472 | 473 | [has_left_add_distributivity α] [has_right_add_distributivity α] 474 | 475 | [has_mul_assoc α] 476 | 477 | (a : α) 478 | 479 | : 4 * (a * a) = (a + a) * (a + a) := 480 | 481 | begin 482 | rw has_left_add_distributivity.eq, 483 | rw has_right_add_distributivity.eq, 484 | rw ← two_mul_lemma, 485 | rw ← two_mul_lemma, 486 | rw ← has_mul_assoc.eq, 487 | rw ← has_mul_assoc.eq, 488 | rw two_mul_lemma, 489 | rw has_mul_assoc.eq, 490 | 491 | refine rfl, 492 | end 493 | 494 | /-- 495 | -/ 496 | def two_squares_is_four_lemma' 497 | [has_one α] 498 | 499 | [has_add α] [has_mul α] 500 | 501 | [has_right_unit α] 502 | 503 | [has_left_add_distributivity α] [has_right_add_distributivity α] 504 | 505 | [has_mul_assoc α] 506 | 507 | (a : α) 508 | 509 | : (a * a) * 4 = (a + a) * (a + a) := 510 | 511 | begin 512 | rw has_right_add_distributivity.eq, 513 | rw has_left_add_distributivity.eq, 514 | rw ← two_mul_lemma', 515 | rw ← two_mul_lemma', 516 | rw has_mul_assoc.eq, 517 | rw has_mul_assoc.eq, 518 | rw two_mul_lemma', 519 | rw has_mul_assoc.eq, 520 | 521 | refine rfl, 522 | end 523 | 524 | /-- 525 | -/ 526 | def nat_mul_commute_lemma 527 | [has_zero α] 528 | [has_one α] 529 | [has_add α] 530 | [has_mul α] 531 | 532 | [has_zero_mul_is_zero α] 533 | [has_mul_zero_is_zero α] 534 | 535 | [has_right_unit α] 536 | [has_left_unit α] 537 | 538 | [has_left_add_distributivity α] 539 | [has_right_add_distributivity α] 540 | 541 | [has_lift_t nat α] 542 | [has_lift_zero_same nat α] 543 | [has_lift_one_same nat α] 544 | [has_lift_add_comm nat α] 545 | 546 | (a : α) (n : nat) 547 | 548 | : a * ↑n = ↑n * a := 549 | 550 | begin 551 | induction n with n hn, 552 | rw has_lift_zero_same.eq, 553 | rw has_zero_mul_is_zero.eq, 554 | rw has_mul_zero_is_zero.eq, 555 | rw nat.succ_eq_add_one, 556 | rw has_lift_add_comm.eq, 557 | rw has_left_add_distributivity.eq, 558 | rw has_right_add_distributivity.eq, 559 | rw hn, 560 | rw has_lift_one_same.eq, 561 | rw has_left_unit.eq, 562 | rw has_right_unit.eq, 563 | end 564 | 565 | section lifted_lemmas --—————————————————————————————————————————————————————————————————-- 566 | variables (α β) 567 | 568 | /-- 569 | -/ 570 | def zero_is_lifted_zero_lemma 571 | [has_zero α] [has_zero β] [has_lift_t α β] [has_lift_zero_same α β] 572 | : (0 : β) = ↑(0 : α) 573 | := by rw has_lift_zero_same.eq 574 | 575 | --———————————————————————————————————————————————————————————————————————————————————————-- 576 | variables [has_one α] [has_one β] [has_lift_t α β] [has_lift_one_same α β] 577 | 578 | /-- 579 | -/ 580 | def one_is_lifted_one_lemma 581 | : (1 : β) = ↑(1 : α) 582 | := by rw has_lift_one_same.eq 583 | 584 | --———————————————————————————————————————————————————————————————————————————————————————-- 585 | variables [has_add α] [has_add β] [has_lift_add_comm α β] 586 | 587 | /-- 588 | -/ 589 | def two_is_lifted_two_lemma : (2 : β) = ↑(2 : α) := 590 | begin 591 | rw (_ : (2 : β) = ↑(1 : α) + ↑(1 : α)), 592 | rw ← has_lift_add_comm.eq, 593 | refine rfl, 594 | rw has_lift_one_same.eq, 595 | refine rfl, 596 | end 597 | 598 | /-- 599 | -/ 600 | def three_is_lifted_three_lemma : (3 : β) = ↑(3 : α) := 601 | begin 602 | rw (_ : (3 : β) = ↑(1 : α) + ↑(1 : α) + ↑(1 : α)), 603 | rw [← has_lift_add_comm.eq, ← has_lift_add_comm.eq], 604 | refine rfl, 605 | rw has_lift_one_same.eq, 606 | refine rfl, 607 | end 608 | 609 | /-- 610 | -/ 611 | def four_is_lifted_four_lemma : (4 : β) = ↑(4 : α) := 612 | begin 613 | rw (_ : (4 : β) = ↑(1 : α) + ↑(1 : α) + (↑(1 : α) + ↑(1 : α))), 614 | rw [← has_lift_add_comm.eq, ← has_lift_add_comm.eq], 615 | refine rfl, 616 | rw has_lift_one_same.eq, 617 | refine rfl, 618 | end 619 | 620 | end lifted_lemmas --—————————————————————————————————————————————————————————————————————-- 621 | end lemmas --————————————————————————————————————————————————————————————————————————————-- 622 | end algebra --———————————————————————————————————————————————————————————————————————————-- 623 | 624 | open algebra 625 | 626 | namespace nat --—————————————————————————————————————————————————————————————————————————-- 627 | 628 | /-- 629 | -/ 630 | def of_le_succ {n m : nat} (n_le_m_succ : n ≤ m.succ) : n ≤ m ∨ n = m.succ 631 | := (lt_or_eq_of_le n_le_m_succ).imp nat.le_of_lt_succ id 632 | 633 | /-- 634 | -/ 635 | def sub_sub_sub_cancel_right {a b c} (c_le_b : c ≤ b) : a - c - (b - c) = a - b 636 | := by rw [nat.sub_sub, ← nat.add_sub_assoc c_le_b, nat.add_sub_cancel_left] 637 | 638 | /-- 639 | -/ 640 | def le_sub_right_of_add_le {m n k} : m + k ≤ n → m ≤ n - k := 641 | begin 642 | intros h, 643 | rw ← nat.add_sub_cancel m k, 644 | refine nat.sub_le_sub_right h _, 645 | end 646 | 647 | /-- 648 | -/ 649 | def le_sub_left_of_add_le {k m n} (h : k + m ≤ n) : m ≤ n - k 650 | := le_sub_right_of_add_le (by { rw ← nat.add_comm, refine h }) 651 | 652 | /-- 653 | -/ 654 | def le_add_of_sub_le_right {k m n} : n - k ≤ m → n ≤ m + k := 655 | begin 656 | intros h, 657 | rw ← nat.add_sub_cancel m k at h, 658 | refine (nat.sub_le_sub_right_iff _ _ _ (nat.le_add_left _ _)).mp h, 659 | end 660 | 661 | /-- 662 | -/ 663 | def add_lt_add_of_le_of_lt {a b c d} (h₁ : a ≤ b) (h₂ : c < d) : a + c < b + d 664 | := lt_of_le_of_lt (nat.add_le_add_right h₁ c) (nat.add_lt_add_left h₂ b) 665 | 666 | /-- 667 | -/ 668 | def lt_add_of_le_of_pos {a b c} (b_le_c : b ≤ c) (zero_lt_a : 0 < a) : b < c + a 669 | := nat.add_zero b ▸ nat.add_lt_add_of_le_of_lt b_le_c zero_lt_a 670 | 671 | /-- 672 | -/ 673 | def neg_right_swap {a b c} (c_le_b : c ≤ b) : a - (b - c) = (a + c) - b := 674 | begin 675 | rw ← nat.add_sub_cancel a _, 676 | rw nat.sub_sub_sub_cancel_right c_le_b, 677 | rw nat.add_sub_assoc (le_refl _), 678 | rw nat.sub_self, 679 | rw nat.add_zero, 680 | end 681 | 682 | /-- 683 | -/ 684 | def sub_mono_left_strict {x y z : nat} (z_le_x : z ≤ x) (x_lt_y : x < y) 685 | : x - z < y - z := 686 | begin 687 | refine @nat.lt_of_add_lt_add_left z _ _ _, 688 | rw nat.add_sub_of_le (le_trans z_le_x (le_of_lt x_lt_y)), 689 | rw nat.add_sub_of_le z_le_x, 690 | refine x_lt_y, 691 | end 692 | 693 | /-- 694 | -/ 695 | def mul_two (n) : n * 2 = n + n := 696 | begin 697 | refine (nat.left_distrib _ _ _).trans _, 698 | rw nat.mul_one, 699 | end 700 | 701 | /-- 702 | -/ 703 | def pow_two_ge_one (n : nat) : 1 ≤ 2 ^ n := 704 | begin 705 | induction n with n hn, 706 | refine le_refl _, 707 | refine le_trans hn (nat.le_add_left _ _), 708 | end 709 | 710 | /-- 711 | -/ 712 | def pow_two_monotonic (n : nat) : 2 ^ n < 2 ^ n.succ 713 | := lt_add_of_le_of_pos (nat.le_add_left _ _) (pow_two_ge_one _) 714 | 715 | /-- 716 | -/ 717 | def smallest_positive_even (n : nat) 718 | : 2 ≤ 2 * n.succ := 719 | begin 720 | induction n with n hn, 721 | rw nat.mul_one, 722 | refine le_trans hn (nat.le.intro rfl), 723 | end 724 | 725 | /-- 726 | -/ 727 | def successive_difference (u : nat → nat) (n : nat) 728 | := u n.succ - u n 729 | 730 | /-- 731 | -/ 732 | def power [has_one α] [has_mul α] (a : α) : nat → α 733 | | (nat.zero ) := 1 734 | | (nat.succ n) := power n * a 735 | 736 | namespace power --———————————————————————————————————————————————————————————————————————-- 737 | variables [has_one α] [has_mul α] 738 | 739 | /-- 740 | -/ 741 | def mul_commute 742 | [has_one β] [has_mul β] 743 | (map : α → β) 744 | (map_one : map 1 = 1) 745 | (map_mul : Π x y, map (x * y) = map x * map y) 746 | (a : α) (n) 747 | : map (power a n) = power (map a) n := 748 | begin 749 | induction n with n hn, 750 | rw [power, power], 751 | rw map_one, 752 | rw [power, power], 753 | rw map_mul, 754 | rw hn, 755 | end 756 | 757 | end power --—————————————————————————————————————————————————————————————————————————————-- 758 | 759 | namespace lift --————————————————————————————————————————————————————————————————————————-- 760 | variables (α) 761 | 762 | /-- 763 | -/ 764 | def succ_pos 765 | [has_lt α] 766 | [has_zero α] 767 | [has_lift_t nat α] 768 | [has_lift_zero_same nat α] 769 | [has_lift_lt_comm nat α] 770 | (n : nat) 771 | : 0 < (↑n.succ : α) := 772 | begin 773 | rw zero_is_lifted_zero_lemma nat α, 774 | refine has_lift_lt_comm.lt (nat.succ_pos _), 775 | end 776 | 777 | /-- 778 | -/ 779 | def succ_nonzero 780 | [preorder α] 781 | [has_zero α] 782 | [has_lift_t nat α] 783 | [has_lift_zero_same nat α] 784 | [has_lift_lt_comm nat α] 785 | (n : nat) 786 | : (↑n.succ : α) ≠ 0 787 | := (ne_of_gt (nat.lift.succ_pos α _)) 788 | 789 | /-- 790 | -/ 791 | def zero_lt_one 792 | [has_lt α] 793 | [has_zero α] 794 | [has_one α] 795 | [has_lift_t nat α] 796 | [has_lift_zero_same nat α] 797 | [has_lift_one_same nat α] 798 | [has_lift_lt_comm nat α] 799 | : (0 : α) < 1 := 800 | begin 801 | rw one_is_lifted_one_lemma nat α, 802 | refine nat.lift.succ_pos α _, 803 | end 804 | 805 | /-- 806 | -/ 807 | instance zero_lt_one_instance 808 | [has_lt α] 809 | [has_zero α] 810 | [has_one α] 811 | [has_lift_t nat α] 812 | [has_lift_zero_same nat α] 813 | [has_lift_one_same nat α] 814 | [has_lift_lt_comm nat α] 815 | : has_zero_lt_one α 816 | := ⟨zero_lt_one α⟩ 817 | 818 | end lift --——————————————————————————————————————————————————————————————————————————————-- 819 | end nat --———————————————————————————————————————————————————————————————————————————————-- 820 | 821 | section sequences --—————————————————————————————————————————————————————————————————————-- 822 | 823 | /-- 824 | -/ 825 | def strictly_increasing 826 | [has_lt α] 827 | (seq : nat → α) 828 | := Π n, seq n < seq n.succ 829 | 830 | /-- 831 | -/ 832 | def increasing 833 | [has_le α] 834 | (seq : nat → α) 835 | := Π n, seq n ≤ seq n.succ 836 | 837 | /-- 838 | -/ 839 | def strictly_increasing.as_increasing 840 | [preorder α] 841 | (seq : nat → α) 842 | : strictly_increasing seq → increasing seq := 843 | begin 844 | intros sinc _, 845 | refine le_of_lt (sinc _), 846 | end 847 | 848 | /-- 849 | -/ 850 | def increasing_strong 851 | [has_le α] 852 | (seq : nat → α) 853 | := Π i j, i ≤ j → seq i ≤ seq j 854 | 855 | /-- 856 | -/ 857 | def increasing.as_increasing_strong 858 | [preorder α] 859 | (seq : nat → α) 860 | : increasing seq → increasing_strong seq := 861 | begin 862 | intros inc i j i_le_j, 863 | induction j with j hj, 864 | cases i_le_j, 865 | refine le_refl _, 866 | cases nat.of_le_succ i_le_j, 867 | refine le_trans (hj h) (inc _), 868 | rw h, 869 | end 870 | 871 | /-- 872 | -/ 873 | def strictly_increasing.as_increasing_strong 874 | [preorder α] 875 | (seq : nat → α) 876 | : strictly_increasing seq → increasing_strong seq 877 | := λ s, increasing.as_increasing_strong _ (strictly_increasing.as_increasing _ s) 878 | 879 | /-- 880 | -/ 881 | def non_increasing 882 | [has_le α] 883 | (seq : nat → α) 884 | := Π n, seq (nat.succ n) ≤ seq n 885 | 886 | /-- 887 | -/ 888 | def non_increasing_strong 889 | [has_le α] 890 | (seq : nat → α) (k) 891 | := Π n, seq (n + k) ≤ seq n 892 | 893 | /-- 894 | -/ 895 | def non_increasing.as_non_increasing_strong 896 | [preorder α] 897 | (seq : nat → α) 898 | : non_increasing seq → Π k, non_increasing_strong seq k := 899 | begin 900 | intros noninc k _, 901 | induction k with k hk, 902 | refine le_refl _, 903 | refine le_trans (noninc _) hk, 904 | end 905 | 906 | /-- 907 | -/ 908 | def strictly_increasing.ge_index 909 | (seq) (sinc : strictly_increasing seq) 910 | (k) 911 | : k ≤ seq k := 912 | begin 913 | induction k with _ hk, 914 | refine nat.zero_le _, 915 | rw nat.succ_eq_add_one, 916 | refine le_trans (nat.add_le_add hk (le_refl _)) (sinc _), 917 | end 918 | 919 | /-- 920 | -/ 921 | def nonneg_compose_preserve 922 | [has_zero α] [has_le α] 923 | (seq : nat → α) (φ : nat → nat) 924 | : 0 ≤ seq → 0 ≤ seq ∘ φ 925 | := λ p _, p (φ _) 926 | 927 | /-- 928 | -/ 929 | def translate 930 | (seq : nat → α) 931 | (k) 932 | (n) 933 | := seq (k + n) 934 | 935 | /-- 936 | -/ 937 | def translate.preserve_nonneg 938 | [has_zero α] [has_le α] 939 | (seq : nat → α) 940 | : 0 ≤ seq → 0 ≤ translate seq 941 | := λ p _ _, p _ 942 | 943 | /-- 944 | -/ 945 | def translate.monotonicity 946 | [has_le α] 947 | {a b : nat → α} 948 | : a ≤ b → translate a ≤ translate b 949 | := λ p _ _, p _ 950 | 951 | /-- 952 | -/ 953 | def translate.combine 954 | (seq : nat → α) 955 | (i j) 956 | : translate (translate seq i) j = translate seq (i + j) 957 | := funext (λ _, by rw [translate, translate, translate, nat.add_assoc]) 958 | 959 | /-- 960 | -/ 961 | def translate.compose_commute 962 | (seq : nat → α) 963 | (f : α → β) 964 | (n k) 965 | : f (translate seq n k) = translate (f ∘ seq) n k 966 | := by rw [translate, translate] 967 | 968 | /-- 969 | -/ 970 | def translate.compose_commute.funext 971 | (seq : nat → α) 972 | (f : α → β) 973 | (n) 974 | : f ∘ (translate seq n) = translate (f ∘ seq) n 975 | := funext (translate.compose_commute seq f n) 976 | 977 | end sequences --—————————————————————————————————————————————————————————————————————————-- 978 | 979 | section series --————————————————————————————————————————————————————————————————————————-- 980 | variables [has_zero α] [has_add α] 981 | 982 | /-- 983 | -/ 984 | def partial_sum (seq : nat → α) : nat → α 985 | | (nat.zero ) := 0 986 | | (nat.succ n) := seq n + partial_sum n 987 | 988 | /-- 989 | -/ 990 | def partial_sum.preserve_nonneg 991 | [preorder α] [has_add_nonneg α] 992 | 993 | (seq : nat → α) 994 | 995 | : 0 ≤ seq → 0 ≤ partial_sum seq := 996 | 997 | begin 998 | intros nonneg k, 999 | induction k with k hk, 1000 | refine le_refl _, 1001 | refine has_add_nonneg.le (nonneg _) hk, 1002 | end 1003 | 1004 | /-- 1005 | -/ 1006 | def partial_sum.left_mul_commute 1007 | [has_mul α] [has_mul_zero_is_zero α] [has_left_add_distributivity α] 1008 | (seq : nat → α) 1009 | (C) 1010 | : partial_sum (λ k, C * seq k) = λ n, C * partial_sum seq n := 1011 | begin 1012 | refine funext _, 1013 | intros n, 1014 | induction n with n hn, 1015 | rw partial_sum, 1016 | rw partial_sum, 1017 | rw has_mul_zero_is_zero.eq, 1018 | rw partial_sum, 1019 | rw partial_sum, 1020 | rw hn, 1021 | rw has_left_add_distributivity.eq, 1022 | end 1023 | 1024 | /-- 1025 | -/ 1026 | def partial_sum.right_mul_commute 1027 | [has_mul α] [has_zero_mul_is_zero α] [has_right_add_distributivity α] 1028 | (seq : nat → α) 1029 | (C) 1030 | : partial_sum (λ k, seq k * C) = λ n, partial_sum seq n * C := 1031 | begin 1032 | refine funext _, 1033 | intros n, 1034 | induction n with n hn, 1035 | rw partial_sum, 1036 | rw partial_sum, 1037 | rw has_zero_mul_is_zero.eq, 1038 | rw partial_sum, 1039 | rw partial_sum, 1040 | rw hn, 1041 | rw has_right_add_distributivity.eq, 1042 | end 1043 | 1044 | /-- 1045 | -/ 1046 | def partial_sum.from_mul 1047 | [has_one α] 1048 | [has_mul α] 1049 | 1050 | [has_zero_mul_is_zero α] 1051 | [has_left_unit α] 1052 | [has_right_add_distributivity α] 1053 | 1054 | [has_lift_t nat α] 1055 | [has_lift_zero_same nat α] 1056 | [has_lift_one_same nat α] 1057 | [has_lift_add_comm nat α] 1058 | 1059 | (a : α) 1060 | (n : nat) 1061 | 1062 | : ↑n * a = partial_sum ↓a n := 1063 | 1064 | begin 1065 | induction n with n hn, 1066 | rw partial_sum, 1067 | rw has_lift_zero_same.eq, 1068 | rw has_zero_mul_is_zero.eq, 1069 | rw partial_sum, 1070 | rw nat.succ_eq_add_one, 1071 | rw nat.add_comm, 1072 | rw has_lift_add_comm.eq, 1073 | rw has_right_add_distributivity.eq, 1074 | rw has_lift_one_same.eq, 1075 | rw has_left_unit.eq, 1076 | rw hn, 1077 | rw const, 1078 | end 1079 | 1080 | /-- 1081 | -/ 1082 | def partial_sum.from_mul' 1083 | [has_one α] 1084 | [has_mul α] 1085 | 1086 | [has_mul_zero_is_zero α] 1087 | [has_right_unit α] 1088 | [has_left_add_distributivity α] 1089 | 1090 | [has_lift_t nat α] 1091 | [has_lift_zero_same nat α] 1092 | [has_lift_one_same nat α] 1093 | [has_lift_add_comm nat α] 1094 | 1095 | (a : α) 1096 | (n : nat) 1097 | 1098 | : a * ↑n = partial_sum ↓a n := 1099 | 1100 | begin 1101 | induction n with n hn, 1102 | rw partial_sum, 1103 | rw has_lift_zero_same.eq, 1104 | rw has_mul_zero_is_zero.eq, 1105 | rw partial_sum, 1106 | rw nat.succ_eq_add_one, 1107 | rw nat.add_comm, 1108 | rw has_lift_add_comm.eq, 1109 | rw has_left_add_distributivity.eq, 1110 | rw has_lift_one_same.eq, 1111 | rw has_right_unit.eq, 1112 | rw hn, 1113 | rw const, 1114 | end 1115 | 1116 | /-- 1117 | -/ 1118 | def partial_sum.monotonicity 1119 | [preorder α] [has_add_le_add α] 1120 | {a b : nat → α} 1121 | : a ≤ b → partial_sum a ≤ partial_sum b := 1122 | begin 1123 | intros a_le_b n, 1124 | induction n with _ hn, 1125 | refine le_refl _, 1126 | refine has_add_le_add.le (a_le_b _) hn, 1127 | end 1128 | 1129 | /-- 1130 | -/ 1131 | def partial_sum.index_monotonicity 1132 | [preorder α] [has_le_add_of_nonneg_of_le α] 1133 | 1134 | (seq : nat → α) (nonneg : 0 ≤ seq) 1135 | 1136 | {m n} 1137 | 1138 | : m ≤ n → partial_sum seq m ≤ partial_sum seq n := 1139 | 1140 | begin 1141 | intros m_le_n, 1142 | induction n with n hn, 1143 | cases m_le_n, 1144 | refine le_refl _, 1145 | cases nat.of_le_succ m_le_n, 1146 | refine has_le_add_of_nonneg_of_le.le (nonneg _) (hn h), 1147 | rw ← h, 1148 | end 1149 | 1150 | /-- 1151 | -/ 1152 | def partial_sum.double_monotonicity 1153 | [preorder α] [has_le_add_of_nonneg_of_le α] [has_add_le_add α] 1154 | 1155 | (a : nat → α) (na) 1156 | (b : nat → α) (nb) 1157 | 1158 | : 0 ≤ a → a ≤ b → na ≤ nb → partial_sum a na ≤ partial_sum b nb := 1159 | 1160 | begin 1161 | intros zero_le_a a_le_b na_le_nb, 1162 | induction nb with _ hnb, 1163 | cases na_le_nb, 1164 | refine le_refl _, 1165 | cases nat.of_le_succ na_le_nb, 1166 | refine has_le_add_of_nonneg_of_le.le 1167 | (le_trans (zero_le_a _) (a_le_b _)) (hnb h), 1168 | rw h, 1169 | refine has_add_le_add.le 1170 | (a_le_b _) (partial_sum.monotonicity a_le_b _), 1171 | end 1172 | 1173 | /-- 1174 | -/ 1175 | def partial_sum.sub_as_translate 1176 | [has_sub α] [has_sub_self_is_zero α] [has_add_sub_assoc α] 1177 | 1178 | (seq : nat → α) 1179 | 1180 | {m n} (m_le_n : m ≤ n) 1181 | 1182 | : partial_sum seq n - partial_sum seq m = partial_sum (translate seq m) (n - m) := 1183 | 1184 | begin 1185 | induction n with n hn, 1186 | cases m_le_n, 1187 | refine has_sub_self_is_zero.eq _, 1188 | cases m_le_n with _ m_le_n, 1189 | rw has_sub_self_is_zero.eq, 1190 | rw nat.sub_self, 1191 | rw partial_sum, 1192 | rw partial_sum, 1193 | rw has_add_sub_assoc.eq, 1194 | rw hn m_le_n, 1195 | rw nat.succ_sub m_le_n, 1196 | rw partial_sum, 1197 | rw translate, 1198 | rw nat.add_sub_of_le m_le_n, 1199 | end 1200 | 1201 | /-- 1202 | -/ 1203 | def partial_sum.lower_differences.bottom 1204 | [has_sub α] 1205 | [has_add_sub_assoc α] 1206 | [has_sub_self_is_zero α] 1207 | 1208 | [preorder α] 1209 | [has_le_add_of_nonneg_of_le α] 1210 | 1211 | (seq : nat → α) (nonneg : 0 ≤ seq) 1212 | 1213 | {m n} (m_le_n : m ≤ n) 1214 | 1215 | : 0 ≤ partial_sum seq n - partial_sum seq m := 1216 | 1217 | begin 1218 | induction n with n hn, 1219 | cases m_le_n, 1220 | rw has_sub_self_is_zero.eq, 1221 | cases nat.of_le_succ m_le_n, 1222 | rw partial_sum, 1223 | rw has_add_sub_assoc.eq, 1224 | refine has_le_add_of_nonneg_of_le.le (nonneg _) (hn h), 1225 | rw ← h, 1226 | rw has_sub_self_is_zero.eq, 1227 | end 1228 | 1229 | /-- 1230 | -/ 1231 | def partial_sum.lower_differences 1232 | [has_sub α] 1233 | [has_sub_self_is_zero α] 1234 | [has_add_sub_assoc α] 1235 | 1236 | [preorder α] 1237 | [has_add_le_add α] 1238 | [has_le_add_of_nonneg_of_le α] 1239 | 1240 | (seq : nat → α) (nonneg : 0 ≤ seq) 1241 | 1242 | {k m n} (k_le_m : k ≤ m) (m_le_n : m ≤ n) 1243 | 1244 | : partial_sum seq n - partial_sum seq m ≤ partial_sum seq n - partial_sum seq k := 1245 | 1246 | begin 1247 | induction n with n hn, 1248 | cases m_le_n, 1249 | cases k_le_m, 1250 | refine le_refl _, 1251 | cases nat.of_le_succ m_le_n, 1252 | rw partial_sum, 1253 | rw has_add_sub_assoc.eq, 1254 | rw has_add_sub_assoc.eq, 1255 | refine has_add_le_add.le (le_refl _) (hn h), 1256 | rw ← h, 1257 | rw has_sub_self_is_zero.eq, 1258 | refine partial_sum.lower_differences.bottom _ nonneg k_le_m, 1259 | end 1260 | 1261 | --———————————————————————————————————————————————————————————————————————————————————————-- 1262 | variables [has_sub α] 1263 | 1264 | /-- 1265 | -/ 1266 | def shape_sum (seq : nat → α) (φ : nat → nat) (n : nat) 1267 | := partial_sum seq (φ n.succ) - partial_sum seq (φ n) 1268 | 1269 | /-- 1270 | -/ 1271 | def shape_sum.unfold 1272 | [has_sub_self_is_zero α] 1273 | [has_add_sub_assoc α] 1274 | [has_sub_add_sub_cancel α] 1275 | 1276 | (seq : nat → α) 1277 | 1278 | (φ) (sinc_φ : strictly_increasing φ) 1279 | 1280 | {m n} (m_le_n : m ≤ n) 1281 | 1282 | : partial_sum (translate (shape_sum seq φ) m) (n - m) 1283 | = partial_sum (translate seq (φ m)) (φ n - φ m) := 1284 | 1285 | begin 1286 | let strong_inc := strictly_increasing.as_increasing_strong _ sinc_φ, 1287 | induction n with n hn, 1288 | cases m_le_n, 1289 | rw [nat.sub_self, nat.sub_self, partial_sum, partial_sum], 1290 | cases nat.of_le_succ m_le_n, 1291 | rw nat.succ_sub h, 1292 | rw partial_sum, 1293 | rw hn h, 1294 | rw translate, 1295 | rw nat.add_sub_of_le h, 1296 | rw shape_sum, 1297 | rw ← partial_sum.sub_as_translate seq (strong_inc _ _ h), 1298 | rw ← partial_sum.sub_as_translate seq (strong_inc _ _ m_le_n), 1299 | rw has_sub_add_sub_cancel.eq, 1300 | rw h, 1301 | rw [nat.sub_self, nat.sub_self, partial_sum, partial_sum], 1302 | end 1303 | 1304 | end series --————————————————————————————————————————————————————————————————————————————-- 1305 | 1306 | section absolute_value --————————————————————————————————————————————————————————————————-- 1307 | variables [has_zero α] [has_add α] 1308 | 1309 | /-- 1310 | -/ 1311 | def triangle_inequality 1312 | [has_zero β] [has_add β] [preorder β] [has_add_le_add β] 1313 | 1314 | (abs : α → β) 1315 | (abs_zero : abs 0 = 0) 1316 | (abs_triangle : Π x y, abs (x + y) ≤ abs x + abs y) 1317 | 1318 | (seq) (n) 1319 | 1320 | : abs (partial_sum seq n) ≤ partial_sum (abs ∘ seq) n := 1321 | 1322 | begin 1323 | induction n with _ hn, 1324 | rw [partial_sum, partial_sum], 1325 | rw abs_zero, 1326 | refine le_trans (abs_triangle _ _) (has_add_le_add.le (le_refl _) hn), 1327 | end 1328 | 1329 | /-- 1330 | -/ 1331 | def triangle_equality 1332 | [preorder α] [has_add_nonneg α] 1333 | 1334 | (abs : α → α) 1335 | (nonneg_to_abs : Π z, 0 ≤ z → abs z = z) 1336 | 1337 | (seq nonneg) (n) 1338 | 1339 | : abs (partial_sum seq n) = partial_sum seq n 1340 | 1341 | := nonneg_to_abs _ (partial_sum.preserve_nonneg _ nonneg _) 1342 | 1343 | end absolute_value --————————————————————————————————————————————————————————————————————-- 1344 | 1345 | end riemann_hypothesis --————————————————————————————————————————————————————————————————-- 1346 | --------------------------------------------------------------------------------