ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- LSeries.convolution_one_eq_convolution_zeta
lemma LSeries.convolution_one_eq_convolution_zeta {R : Type*} [Semiring R] (f : ℕ → R) :
    f ⍟ (1 : ℕ → R) = f ⍟ ((ArithmeticFunction.zeta ·) : ℕ → R) 
Arguments: {R : Type u_1} [Semiring R] (f : ℕ → R)
Goal: f ⍟ 1 = f ⍟ fun x => ↑(ArithmeticFunction.zeta x)
-- DirichletCharacter.mul_convolution_distrib
lemma mul_convolution_distrib {R : Type*} [CommSemiring R] {n : ℕ} (χ : DirichletCharacter R n)
    (f g : ℕ → R) :
    (((χ ·) : ℕ → R) * f) ⍟ (((χ ·) : ℕ → R) * g) = ((χ ·) : ℕ → R) * (f ⍟ g) 
Arguments: {R : Type u_1} [CommSemiring R] {n : ℕ} (χ : DirichletCharacter R n) (f g : ℕ → R)
Goal: (fun x => χ ↑x) * f ⍟ ((fun x => χ ↑x) * g) = (fun x => χ ↑x) * (f ⍟ g)
-- DirichletCharacter.mul_delta
lemma mul_delta {n : ℕ} (χ : DirichletCharacter ℂ n) : ↗χ * δ = δ 
Arguments: {n : ℕ} (χ : DirichletCharacter ℂ n)
Goal: (fun n_1 => χ ↑n_1) * δ = δ
-- DirichletCharacter.delta_mul
lemma delta_mul {n : ℕ} (χ : DirichletCharacter ℂ n) : δ * ↗χ = δ 
Arguments: {n : ℕ} (χ : DirichletCharacter ℂ n)
Goal: (δ * fun n_1 => χ ↑n_1) = δ
-- DirichletCharacter.convolution_mul_moebius
lemma convolution_mul_moebius {n : ℕ} (χ : DirichletCharacter ℂ n) : ↗χ ⍟ (↗χ * ↗μ) = δ 
Arguments: {n : ℕ} (χ : DirichletCharacter ℂ n)
Goal: (fun n_1 => χ ↑n_1) ⍟ ((fun n_1 => χ ↑n_1) * fun n => ↑(ArithmeticFunction.moebius n)) = δ
-- DirichletCharacter.modZero_eq_delta
lemma modZero_eq_delta {χ : DirichletCharacter ℂ 0} : ↗χ = δ 
Arguments: {χ : DirichletCharacter ℂ 0}
Goal: (fun n => χ ↑n) = δ
-- DirichletCharacter.modOne_eq_one
lemma modOne_eq_one {R : Type*} [CommSemiring R] {χ : DirichletCharacter R 1} :
    ((χ ·) : ℕ → R) = 1 
Arguments: {R : Type u_1} [CommSemiring R] {χ : DirichletCharacter R 1}
Goal: (fun x => χ ↑x) = 1
-- DirichletCharacter.LSeries_modOne_eq
lemma LSeries_modOne_eq : L ↗χ₁ = L 1 
Goal: (L fun n => 1 ↑n) = L 1
-- DirichletCharacter.not_LSeriesSummable_at_one
lemma not_LSeriesSummable_at_one {N : ℕ} (hN : N ≠ 0) (χ : DirichletCharacter ℂ N) :
    ¬ LSeriesSummable ↗χ 1 
Arguments: {N : ℕ} (hN : N ≠ 0) (χ : DirichletCharacter ℂ N)
Goal: ¬LSeriesSummable (fun n => χ ↑n) 1
-- DirichletCharacter.LSeriesSummable_of_one_lt_re
lemma LSeriesSummable_of_one_lt_re {N : ℕ} (χ : DirichletCharacter ℂ N) {s : ℂ} (hs : 1 < s.re) :
    LSeriesSummable ↗χ s 
Arguments: {N : ℕ} (χ : DirichletCharacter ℂ N) {s : ℂ} (hs : 1 < s.re)
Goal: LSeriesSummable (fun n => χ ↑n) s
-- DirichletCharacter.LSeriesSummable_iff
lemma LSeriesSummable_iff {N : ℕ} (hN : N ≠ 0) (χ : DirichletCharacter ℂ N) {s : ℂ} :
    LSeriesSummable ↗χ s ↔ 1 < s.re 
Arguments: {N : ℕ} (hN : N ≠ 0) (χ : DirichletCharacter ℂ N) {s : ℂ}
Goal: LSeriesSummable (fun n => χ ↑n) s ↔ 1 < s.re
-- DirichletCharacter.absicssaOfAbsConv_eq_one
lemma absicssaOfAbsConv_eq_one {N : ℕ} (hn : N ≠ 0) (χ : DirichletCharacter ℂ N) :
    abscissaOfAbsConv ↗χ = 1 
Arguments: {N : ℕ} (hn : N ≠ 0) (χ : DirichletCharacter ℂ N)
Goal: (LSeries.abscissaOfAbsConv fun n => χ ↑n) = 1
-- DirichletCharacter.LSeriesSummable_mul
lemma LSeriesSummable_mul {N : ℕ} (χ : DirichletCharacter ℂ N) {f : ℕ → ℂ} {s : ℂ}
    (h : LSeriesSummable f s) :
    LSeriesSummable (↗χ * f) s 
Arguments: {N : ℕ} (χ : DirichletCharacter ℂ N) {f : ℕ → ℂ} {s : ℂ} (h : LSeriesSummable f s)
Goal: LSeriesSummable ((fun n => χ ↑n) * f) s
-- DirichletCharacter.LSeries.mul_mu_eq_one
lemma LSeries.mul_mu_eq_one {N : ℕ} (χ : DirichletCharacter ℂ N) {s : ℂ}
    (hs : 1 < s.re) : L ↗χ s * L (↗χ * ↗μ) s = 1 
Arguments: {N : ℕ} (χ : DirichletCharacter ℂ N) {s : ℂ} (hs : 1 < s.re)
Goal: L (fun n => χ ↑n) s * L ((fun n => χ ↑n) * fun n => ↑(ArithmeticFunction.moebius n)) s = 1
-- DirichletCharacter.LSeries_ne_zero_of_one_lt_re
lemma LSeries_ne_zero_of_one_lt_re {N : ℕ} (χ : DirichletCharacter ℂ N) {s : ℂ} (hs : 1 < s.re) :
    L ↗χ s ≠ 0 
Arguments: {N : ℕ} (χ : DirichletCharacter ℂ N) {s : ℂ} (hs : 1 < s.re)
Goal: L (fun n => χ ↑n) s ≠ 0
-- LSeries.abscissaOfAbsConv_one
lemma LSeries.abscissaOfAbsConv_one : abscissaOfAbsConv 1 = 1 
Goal: LSeries.abscissaOfAbsConv 1 = 1
-- LSeriesSummable_one_iff
theorem LSeriesSummable_one_iff {s : ℂ} : LSeriesSummable 1 s ↔ 1 < s.re 
Arguments: {s : ℂ}
Goal: LSeriesSummable 1 s ↔ 1 < s.re
-- ArithmeticFunction.LSeries_zeta_eq
lemma LSeries_zeta_eq : L ↗ζ = L 1 
Goal: (L fun n => ↑(ArithmeticFunction.zeta n)) = L 1
-- ArithmeticFunction.LSeriesSummable_zeta_iff
theorem LSeriesSummable_zeta_iff {s : ℂ} : LSeriesSummable (ζ ·) s ↔ 1 < s.re 
Arguments: {s : ℂ}
Goal: LSeriesSummable (fun x => ↑(ArithmeticFunction.zeta x)) s ↔ 1 < s.re
-- ArithmeticFunction.abscissaOfAbsConv_zeta
lemma abscissaOfAbsConv_zeta : abscissaOfAbsConv ↗ζ = 1 
Goal: (LSeries.abscissaOfAbsConv fun n => ↑(ArithmeticFunction.zeta n)) = 1
-- ArithmeticFunction.LSeries_zeta_eq_riemannZeta
lemma LSeries_zeta_eq_riemannZeta {s : ℂ} (hs : 1 < s.re) : L ↗ζ s = riemannZeta s 
Arguments: {s : ℂ} (hs : 1 < s.re)
Goal: L (fun n => ↑(ArithmeticFunction.zeta n)) s = riemannZeta s
-- ArithmeticFunction.LSeriesHasSum_zeta
lemma LSeriesHasSum_zeta {s : ℂ} (hs : 1 < s.re) : LSeriesHasSum ↗ζ s (riemannZeta s) 
Arguments: {s : ℂ} (hs : 1 < s.re)
Goal: LSeriesHasSum (fun n => ↑(ArithmeticFunction.zeta n)) s (riemannZeta s)
-- ArithmeticFunction.LSeries_zeta_mul_Lseries_moebius
lemma LSeries_zeta_mul_Lseries_moebius {s : ℂ} (hs : 1 < s.re) : L ↗ζ s * L ↗μ s = 1 
Arguments: {s : ℂ} (hs : 1 < s.re)
Goal: L (fun n => ↑(ArithmeticFunction.zeta n)) s * L (fun n => ↑(ArithmeticFunction.moebius n)) s = 1
-- ArithmeticFunction.LSeries_zeta_ne_zero_of_one_lt_re
lemma LSeries_zeta_ne_zero_of_one_lt_re {s : ℂ} (hs : 1 < s.re) : L ↗ζ s ≠ 0 
Arguments: {s : ℂ} (hs : 1 < s.re)
Goal: L (fun n => ↑(ArithmeticFunction.zeta n)) s ≠ 0
-- LSeries_one_eq_riemannZeta
lemma LSeries_one_eq_riemannZeta {s : ℂ} (hs : 1 < s.re) : L 1 s = riemannZeta s 
Arguments: {s : ℂ} (hs : 1 < s.re)
Goal: L 1 s = riemannZeta s
-- LSeriesHasSum_one
lemma LSeriesHasSum_one {s : ℂ} (hs : 1 < s.re) : LSeriesHasSum 1 s (riemannZeta s) 
Arguments: {s : ℂ} (hs : 1 < s.re)
Goal: LSeriesHasSum 1 s (riemannZeta s)
-- LSeries_one_mul_Lseries_moebius
lemma LSeries_one_mul_Lseries_moebius {s : ℂ} (hs : 1 < s.re) : L 1 s * L ↗μ s = 1 
Arguments: {s : ℂ} (hs : 1 < s.re)
Goal: L 1 s * L (fun n => ↑(ArithmeticFunction.moebius n)) s = 1
-- LSeries_one_ne_zero_of_one_lt_re
lemma LSeries_one_ne_zero_of_one_lt_re {s : ℂ} (hs : 1 < s.re) : L 1 s ≠ 0 
Arguments: {s : ℂ} (hs : 1 < s.re)
Goal: L 1 s ≠ 0
-- riemannZeta_ne_zero_of_one_lt_re
lemma riemannZeta_ne_zero_of_one_lt_re {s : ℂ} (hs : 1 < s.re) : riemannZeta s ≠ 0 
Arguments: {s : ℂ} (hs : 1 < s.re)
Goal: riemannZeta s ≠ 0
-- ArithmeticFunction.convolution_vonMangoldt_zeta
lemma convolution_vonMangoldt_zeta : ↗Λ ⍟ ↗ζ = ↗Complex.log 
Goal: ((fun n => ↑(ArithmeticFunction.vonMangoldt n)) ⍟ fun n => ↑(ArithmeticFunction.zeta n)) = fun n => Complex.log ↑n
-- ArithmeticFunction.convolution_vonMangoldt_const_one
lemma convolution_vonMangoldt_const_one : ↗Λ ⍟ 1 = ↗Complex.log 
Goal: (fun n => ↑(ArithmeticFunction.vonMangoldt n)) ⍟ 1 = fun n => Complex.log ↑n
-- ArithmeticFunction.LSeriesSummable_vonMangoldt
lemma LSeriesSummable_vonMangoldt {s : ℂ} (hs : 1 < s.re) : LSeriesSummable ↗Λ s 
Arguments: {s : ℂ} (hs : 1 < s.re)
Goal: LSeriesSummable (fun n => ↑(ArithmeticFunction.vonMangoldt n)) s
-- DirichletCharacter.convolution_twist_vonMangoldt
lemma convolution_twist_vonMangoldt {N : ℕ} (χ : DirichletCharacter ℂ N) :
    (↗χ * ↗Λ) ⍟ ↗χ = ↗χ * ↗Complex.log 
Arguments: {N : ℕ} (χ : DirichletCharacter ℂ N)
Goal: (((fun n => χ ↑n) * fun n => ↑(ArithmeticFunction.vonMangoldt n)) ⍟ fun n => χ ↑n) =
  (fun n => χ ↑n) * fun n => Complex.log ↑n
-- DirichletCharacter.LSeriesSummable_twist_vonMangoldt
lemma LSeriesSummable_twist_vonMangoldt {N : ℕ} (χ : DirichletCharacter ℂ N) {s : ℂ}
    (hs : 1 < s.re) :
    LSeriesSummable (↗χ * ↗Λ) s 
Arguments: {N : ℕ} (χ : DirichletCharacter ℂ N) {s : ℂ} (hs : 1 < s.re)
Goal: LSeriesSummable ((fun n => χ ↑n) * fun n => ↑(ArithmeticFunction.vonMangoldt n)) s
-- DirichletCharacter.LSeries_twist_vonMangoldt_eq
lemma LSeries_twist_vonMangoldt_eq {N : ℕ} (χ : DirichletCharacter ℂ N) {s : ℂ} (hs : 1 < s.re) :
    L (↗χ * ↗Λ) s = - deriv (L ↗χ) s / L ↗χ s 
Arguments: {N : ℕ} (χ : DirichletCharacter ℂ N) {s : ℂ} (hs : 1 < s.re)
Goal: L ((fun n => χ ↑n) * fun n => ↑(ArithmeticFunction.vonMangoldt n)) s = -deriv (L fun n => χ ↑n) s / L (fun n => χ ↑n) s
-- ArithmeticFunction.LSeries_vonMangoldt_eq
lemma LSeries_vonMangoldt_eq {s : ℂ} (hs : 1 < s.re) : L ↗Λ s = - deriv (L 1) s / L 1 s 
Arguments: {s : ℂ} (hs : 1 < s.re)
Goal: L (fun n => ↑(ArithmeticFunction.vonMangoldt n)) s = -deriv (L 1) s / L 1 s
-- ArithmeticFunction.LSeries_vonMangoldt_eq_deriv_riemannZeta_div
lemma LSeries_vonMangoldt_eq_deriv_riemannZeta_div {s : ℂ} (hs : 1 < s.re) :
    L ↗Λ s = - deriv riemannZeta s / riemannZeta s 
Arguments: {s : ℂ} (hs : 1 < s.re)
Goal: L (fun n => ↑(ArithmeticFunction.vonMangoldt n)) s = -deriv riemannZeta s / riemannZeta s
-- Pell.isPell_norm
theorem isPell_norm : ∀ {b : ℤ√d}, IsPell b ↔ b * star b = 1
  
Arguments: {d : ℤ} {b : ℤ√d}
Goal: Pell.IsPell b ↔ b * star b = 1
-- Pell.isPell_iff_mem_unitary
theorem isPell_iff_mem_unitary : ∀ {b : ℤ√d}, IsPell b ↔ b ∈ unitary (ℤ√d)
  
Arguments: {d : ℤ} {b : ℤ√d}
Goal: Pell.IsPell b ↔ b ∈ unitary (ℤ√d)
-- Pell.isPell_mul
theorem isPell_mul {b c : ℤ√d} (hb : IsPell b) (hc : IsPell c) : IsPell (b * c) 
Arguments: {d : ℤ} {b c : ℤ√d} (hb : Pell.IsPell b) (hc : Pell.IsPell c)
Goal: Pell.IsPell (b * c)
-- Pell.isPell_star
theorem isPell_star : ∀ {b : ℤ√d}, IsPell b ↔ IsPell (star b)
  
Arguments: {d : ℤ} {b : ℤ√d}
Goal: Pell.IsPell b ↔ Pell.IsPell (star b)
-- Pell.d_pos
@[simp]
theorem d_pos : 0 < d a1 
Arguments: {a : ℕ} (a1 : 1 < a)
Goal: 0 < Pell.d a1
-- Pell.pell_val
@[simp]
theorem pell_val (n : ℕ) : pell a1 n = (xn a1 n, yn a1 n) 
Arguments: {a : ℕ} (a1 : 1 < a) (n : ℕ)
Goal: Pell.pell a1 n = (Pell.xn a1 n, Pell.yn a1 n)
-- Pell.xn_zero
@[simp]
theorem xn_zero : xn a1 0 = 1 
Arguments: {a : ℕ} (a1 : 1 < a)
Goal: Pell.xn a1 0 = 1
-- Pell.yn_zero
@[simp]
theorem yn_zero : yn a1 0 = 0 
Arguments: {a : ℕ} (a1 : 1 < a)
Goal: Pell.yn a1 0 = 0
-- Pell.xn_succ
@[simp]
theorem xn_succ (n : ℕ) : xn a1 (n + 1) = xn a1 n * a + d a1 * yn a1 n 
Arguments: {a : ℕ} (a1 : 1 < a) (n : ℕ)
Goal: Pell.xn a1 (n + 1) = Pell.xn a1 n * a + Pell.d a1 * Pell.yn a1 n
-- Pell.yn_succ
@[simp]
theorem yn_succ (n : ℕ) : yn a1 (n + 1) = xn a1 n + yn a1 n * a 
Arguments: {a : ℕ} (a1 : 1 < a) (n : ℕ)
Goal: Pell.yn a1 (n + 1) = Pell.xn a1 n + Pell.yn a1 n * a
-- Pell.xn_one
theorem xn_one : xn a1 1 = a 
Arguments: {a : ℕ} (a1 : 1 < a)
Goal: Pell.xn a1 1 = a
-- Pell.yn_one
theorem yn_one : yn a1 1 = 1 
Arguments: {a : ℕ} (a1 : 1 < a)
Goal: Pell.yn a1 1 = 1
-- Pell.asq_pos
theorem asq_pos : 0 < a * a 
Arguments: {a : ℕ} (a1 : 1 < a)
Goal: 0 < a * a
-- Pell.dz_val
theorem dz_val : ↑(d a1) = az a * az a - 1 
Arguments: {a : ℕ} (a1 : 1 < a)
Goal: ↑(Pell.d a1) = Pell.az a * Pell.az a - 1
-- Pell.xz_succ
@[simp]
theorem xz_succ (n : ℕ) : (xz a1 (n + 1)) = xz a1 n * az a + d a1 * yz a1 n 
Arguments: {a : ℕ} (a1 : 1 < a) (n : ℕ)
Goal: Pell.xz a1 (n + 1) = Pell.xz a1 n * Pell.az a + ↑(Pell.d a1) * Pell.yz a1 n
-- Pell.yz_succ
@[simp]
theorem yz_succ (n : ℕ) : yz a1 (n + 1) = xz a1 n + yz a1 n * az a 
Arguments: {a : ℕ} (a1 : 1 < a) (n : ℕ)
Goal: Pell.yz a1 (n + 1) = Pell.xz a1 n + Pell.yz a1 n * Pell.az a
-- Pell.pellZd_re
@[simp]
theorem pellZd_re (n : ℕ) : (pellZd a1 n).re = xn a1 n 
Arguments: {a : ℕ} (a1 : 1 < a) (n : ℕ)
Goal: (Pell.pellZd a1 n).re = ↑(Pell.xn a1 n)
-- Pell.pellZd_im
@[simp]
theorem pellZd_im (n : ℕ) : (pellZd a1 n).im = yn a1 n 
Arguments: {a : ℕ} (a1 : 1 < a) (n : ℕ)
Goal: (Pell.pellZd a1 n).im = ↑(Pell.yn a1 n)
-- Pell.isPell_nat
theorem isPell_nat {x y : ℕ} : IsPell (⟨x, y⟩ : ℤ√(d a1)) ↔ x * x - d a1 * y * y = 1 
Arguments: {a : ℕ} (a1 : 1 < a) {x y : ℕ}
Goal: Pell.IsPell { re := ↑x, im := ↑y } ↔ x * x - Pell.d a1 * y * y = 1
-- Pell.pellZd_succ
@[simp]
theorem pellZd_succ (n : ℕ) : pellZd a1 (n + 1) = pellZd a1 n * ⟨a, 1⟩ 
Arguments: {a : ℕ} (a1 : 1 < a) (n : ℕ)
Goal: Pell.pellZd a1 (n + 1) = Pell.pellZd a1 n * { re := ↑a, im := 1 }
-- Pell.isPell_one
theorem isPell_one : IsPell (⟨a, 1⟩ : ℤ√(d a1)) 
Arguments: {a : ℕ} (a1 : 1 < a)
Goal: Pell.IsPell { re := ↑a, im := 1 }
-- Pell.isPell_pellZd
theorem isPell_pellZd : ∀ n : ℕ, IsPell (pellZd a1 n)
  
Arguments: {a : ℕ} (a1 : 1 < a) (n : ℕ)
Goal: Pell.IsPell (Pell.pellZd a1 n)
-- Pell.pell_eqz
@[simp]
theorem pell_eqz (n : ℕ) : xz a1 n * xz a1 n - d a1 * yz a1 n * yz a1 n = 1 
Arguments: {a : ℕ} (a1 : 1 < a) (n : ℕ)
Goal: Pell.xz a1 n * Pell.xz a1 n - ↑(Pell.d a1) * Pell.yz a1 n * Pell.yz a1 n = 1
-- Pell.pell_eq
@[simp]
theorem pell_eq (n : ℕ) : xn a1 n * xn a1 n - d a1 * yn a1 n * yn a1 n = 1 
Arguments: {a : ℕ} (a1 : 1 < a) (n : ℕ)
Goal: Pell.xn a1 n * Pell.xn a1 n - Pell.d a1 * Pell.yn a1 n * Pell.yn a1 n = 1
-- Pell.xn_ge_a_pow
theorem xn_ge_a_pow : ∀ n : ℕ, a ^ n ≤ xn a1 n
  
Arguments: {a : ℕ} (a1 : 1 < a) (n : ℕ)
Goal: a ^ n ≤ Pell.xn a1 n
-- Pell.n_lt_a_pow
theorem n_lt_a_pow : ∀ n : ℕ, n < a ^ n
  
Arguments: {a : ℕ} (a1 : 1 < a) (n : ℕ)
Goal: n < a ^ n
-- Pell.n_lt_xn
theorem n_lt_xn (n) : n < xn a1 n 
Arguments: {a : ℕ} (a1 : 1 < a) (n : ℕ)
Goal: n < Pell.xn a1 n
-- Pell.x_pos
theorem x_pos (n) : 0 < xn a1 n 
Arguments: {a : ℕ} (a1 : 1 < a) (n : ℕ)
Goal: 0 < Pell.xn a1 n
-- Pell.eq_pell_lem
theorem eq_pell_lem : ∀ (n) (b : ℤ√(d a1)), 1 ≤ b → IsPell b →
    b ≤ pellZd a1 n → ∃ n, b = pellZd a1 n
  
Arguments: {a : ℕ} (a1 : 1 < a) (n : ℕ) (b : ℤ√↑(Pell.d a1))
Goal: 1 ≤ b → Pell.IsPell b → b ≤ Pell.pellZd a1 n → ∃ n, b = Pell.pellZd a1 n
-- Pell.eq_pellZd
theorem eq_pellZd (b : ℤ√(d a1)) (b1 : 1 ≤ b) (hp : IsPell b) : ∃ n, b = pellZd a1 n 
Arguments: {a : ℕ} (a1 : 1 < a) (b : ℤ√↑(Pell.d a1)) (b1 : 1 ≤ b) (hp : Pell.IsPell b)
Goal: ∃ n, b = Pell.pellZd a1 n
-- Pell.eq_pell
theorem eq_pell {x y : ℕ} (hp : x * x - d a1 * y * y = 1) : ∃ n, x = xn a1 n ∧ y = yn a1 n 
Arguments: {a : ℕ} (a1 : 1 < a) {x y : ℕ} (hp : x * x - Pell.d a1 * y * y = 1)
Goal: ∃ n, x = Pell.xn a1 n ∧ y = Pell.yn a1 n
-- Pell.pellZd_add
theorem pellZd_add (m) : ∀ n, pellZd a1 (m + n) = pellZd a1 m * pellZd a1 n
  
Arguments: {a : ℕ} (a1 : 1 < a) (m n : ℕ)
Goal: Pell.pellZd a1 (m + n) = Pell.pellZd a1 m * Pell.pellZd a1 n
-- Pell.xn_add
theorem xn_add (m n) : xn a1 (m + n) = xn a1 m * xn a1 n + d a1 * yn a1 m * yn a1 n 
Arguments: {a : ℕ} (a1 : 1 < a) (m n : ℕ)
Goal: Pell.xn a1 (m + n) = Pell.xn a1 m * Pell.xn a1 n + Pell.d a1 * Pell.yn a1 m * Pell.yn a1 n
-- Pell.yn_add
theorem yn_add (m n) : yn a1 (m + n) = xn a1 m * yn a1 n + yn a1 m * xn a1 n 
Arguments: {a : ℕ} (a1 : 1 < a) (m n : ℕ)
Goal: Pell.yn a1 (m + n) = Pell.xn a1 m * Pell.yn a1 n + Pell.yn a1 m * Pell.xn a1 n
-- Pell.pellZd_sub
theorem pellZd_sub {m n} (h : n ≤ m) : pellZd a1 (m - n) = pellZd a1 m * star (pellZd a1 n) 
Arguments: {a : ℕ} (a1 : 1 < a) {m n : ℕ} (h : n ≤ m)
Goal: Pell.pellZd a1 (m - n) = Pell.pellZd a1 m * star (Pell.pellZd a1 n)
-- Pell.xz_sub
theorem xz_sub {m n} (h : n ≤ m) :
    xz a1 (m - n) = xz a1 m * xz a1 n - d a1 * yz a1 m * yz a1 n 
Arguments: {a : ℕ} (a1 : 1 < a) {m n : ℕ} (h : n ≤ m)
Goal: Pell.xz a1 (m - n) = Pell.xz a1 m * Pell.xz a1 n - ↑(Pell.d a1) * Pell.yz a1 m * Pell.yz a1 n
-- Pell.yz_sub
theorem yz_sub {m n} (h : n ≤ m) : yz a1 (m - n) = xz a1 n * yz a1 m - xz a1 m * yz a1 n 
Arguments: {a : ℕ} (a1 : 1 < a) {m n : ℕ} (h : n ≤ m)
Goal: Pell.yz a1 (m - n) = Pell.xz a1 n * Pell.yz a1 m - Pell.xz a1 m * Pell.yz a1 n
-- Pell.xy_coprime
theorem xy_coprime (n) : (xn a1 n).Coprime (yn a1 n) 
Arguments: {a : ℕ} (a1 : 1 < a) (n : ℕ)
Goal: (Pell.xn a1 n).Coprime (Pell.yn a1 n)
-- Pell.strictMono_y
theorem strictMono_y : StrictMono (yn a1)
  
Arguments: {a : ℕ} (a1 : 1 < a)
Goal: StrictMono (Pell.yn a1)
-- Pell.strictMono_x
theorem strictMono_x : StrictMono (xn a1)
  
Arguments: {a : ℕ} (a1 : 1 < a)
Goal: StrictMono (Pell.xn a1)
-- Pell.yn_ge_n
theorem yn_ge_n : ∀ n, n ≤ yn a1 n
  
Arguments: {a : ℕ} (a1 : 1 < a) (n : ℕ)
Goal: n ≤ Pell.yn a1 n
-- Pell.y_mul_dvd
theorem y_mul_dvd (n) : ∀ k, yn a1 n ∣ yn a1 (n * k)
  
Arguments: {a : ℕ} (a1 : 1 < a) (n k : ℕ)
Goal: Pell.yn a1 n ∣ Pell.yn a1 (n * k)
-- Pell.y_dvd_iff
theorem y_dvd_iff (m n) : yn a1 m ∣ yn a1 n ↔ m ∣ n 
Arguments: {a : ℕ} (a1 : 1 < a) (m n : ℕ)
Goal: Pell.yn a1 m ∣ Pell.yn a1 n ↔ m ∣ n
-- Pell.xy_modEq_yn
theorem xy_modEq_yn (n) :
    ∀ k, xn a1 (n * k) ≡ xn a1 n ^ k [MOD yn a1 n ^ 2] ∧ yn a1 (n * k) ≡
        k * xn a1 n ^ (k - 1) * yn a1 n [MOD yn a1 n ^ 3]
  
Arguments: {a : ℕ} (a1 : 1 < a) (n k : ℕ)
Goal: Pell.xn a1 (n * k) ≡ Pell.xn a1 n ^ k [MOD Pell.yn a1 n ^ 2] ∧
  Pell.yn a1 (n * k) ≡ k * Pell.xn a1 n ^ (k - 1) * Pell.yn a1 n [MOD Pell.yn a1 n ^ 3]
-- Pell.ysq_dvd_yy
theorem ysq_dvd_yy (n) : yn a1 n * yn a1 n ∣ yn a1 (n * yn a1 n) 
Arguments: {a : ℕ} (a1 : 1 < a) (n : ℕ)
Goal: Pell.yn a1 n * Pell.yn a1 n ∣ Pell.yn a1 (n * Pell.yn a1 n)
-- Pell.dvd_of_ysq_dvd
theorem dvd_of_ysq_dvd {n t} (h : yn a1 n * yn a1 n ∣ yn a1 t) : yn a1 n ∣ t 
Arguments: {a : ℕ} (a1 : 1 < a) {n t : ℕ} (h : Pell.yn a1 n * Pell.yn a1 n ∣ Pell.yn a1 t)
Goal: Pell.yn a1 n ∣ t
-- Pell.pellZd_succ_succ
theorem pellZd_succ_succ (n) :
    pellZd a1 (n + 2) + pellZd a1 n = (2 * a : ℕ) * pellZd a1 (n + 1) 
Arguments: {a : ℕ} (a1 : 1 < a) (n : ℕ)
Goal: Pell.pellZd a1 (n + 2) + Pell.pellZd a1 n = ↑(2 * a) * Pell.pellZd a1 (n + 1)
-- Pell.xy_succ_succ
theorem xy_succ_succ (n) :
    xn a1 (n + 2) + xn a1 n =
      2 * a * xn a1 (n + 1) ∧ yn a1 (n + 2) + yn a1 n = 2 * a * yn a1 (n + 1) 
Arguments: {a : ℕ} (a1 : 1 < a) (n : ℕ)
Goal: Pell.xn a1 (n + 2) + Pell.xn a1 n = 2 * a * Pell.xn a1 (n + 1) ∧
  Pell.yn a1 (n + 2) + Pell.yn a1 n = 2 * a * Pell.yn a1 (n + 1)
-- Pell.xn_succ_succ
theorem xn_succ_succ (n) : xn a1 (n + 2) + xn a1 n = 2 * a * xn a1 (n + 1) 
Arguments: {a : ℕ} (a1 : 1 < a) (n : ℕ)
Goal: Pell.xn a1 (n + 2) + Pell.xn a1 n = 2 * a * Pell.xn a1 (n + 1)
-- Pell.yn_succ_succ
theorem yn_succ_succ (n) : yn a1 (n + 2) + yn a1 n = 2 * a * yn a1 (n + 1) 
Arguments: {a : ℕ} (a1 : 1 < a) (n : ℕ)
Goal: Pell.yn a1 (n + 2) + Pell.yn a1 n = 2 * a * Pell.yn a1 (n + 1)
-- Pell.xz_succ_succ
theorem xz_succ_succ (n) : xz a1 (n + 2) = (2 * a : ℕ) * xz a1 (n + 1) - xz a1 n 
Arguments: {a : ℕ} (a1 : 1 < a) (n : ℕ)
Goal: Pell.xz a1 (n + 2) = ↑(2 * a) * Pell.xz a1 (n + 1) - Pell.xz a1 n
-- Pell.yz_succ_succ
theorem yz_succ_succ (n) : yz a1 (n + 2) = (2 * a : ℕ) * yz a1 (n + 1) - yz a1 n 
Arguments: {a : ℕ} (a1 : 1 < a) (n : ℕ)
Goal: Pell.yz a1 (n + 2) = ↑(2 * a) * Pell.yz a1 (n + 1) - Pell.yz a1 n
-- Pell.yn_modEq_a_sub_one
theorem yn_modEq_a_sub_one : ∀ n, yn a1 n ≡ n [MOD a - 1]
  
Arguments: {a : ℕ} (a1 : 1 < a) (n : ℕ)
Goal: Pell.yn a1 n ≡ n [MOD a - 1]
-- Pell.yn_modEq_two
theorem yn_modEq_two : ∀ n, yn a1 n ≡ n [MOD 2]
  
Arguments: {a : ℕ} (a1 : 1 < a) (n : ℕ)
Goal: Pell.yn a1 n ≡ n [MOD 2]
-- Pell.x_sub_y_dvd_pow_lem
theorem x_sub_y_dvd_pow_lem (y2 y1 y0 yn1 yn0 xn1 xn0 ay a2 : ℤ) :
    (a2 * yn1 - yn0) * ay + y2 - (a2 * xn1 - xn0) =
      y2 - a2 * y1 + y0 + a2 * (yn1 * ay + y1 - xn1) - (yn0 * ay + y0 - xn0) 
Arguments: (y2 y1 y0 yn1 yn0 xn1 xn0 ay a2 : ℤ)
Goal: (a2 * yn1 - yn0) * ay + y2 - (a2 * xn1 - xn0) = y2 - a2 * y1 + y0 + a2 * (yn1 * ay + y1 - xn1) - (yn0 * ay + y0 - xn0)
-- Pell.x_sub_y_dvd_pow
theorem x_sub_y_dvd_pow (y : ℕ) :
    ∀ n, (2 * a * y - y * y - 1 : ℤ) ∣ yz a1 n * (a - y) + ↑(y ^ n) - xz a1 n
  
Arguments: {a : ℕ} (a1 : 1 < a) (y n : ℕ)
Goal: 2 * ↑a * ↑y - ↑y * ↑y - 1 ∣ Pell.yz a1 n * (↑a - ↑y) + ↑(y ^ n) - Pell.xz a1 n
-- Pell.xn_modEq_x2n_add_lem
theorem xn_modEq_x2n_add_lem (n j) : xn a1 n ∣ d a1 * yn a1 n * (yn a1 n * xn a1 j) + xn a1 j 
Arguments: {a : ℕ} (a1 : 1 < a) (n j : ℕ)
Goal: Pell.xn a1 n ∣ Pell.d a1 * Pell.yn a1 n * (Pell.yn a1 n * Pell.xn a1 j) + Pell.xn a1 j
-- Pell.xn_modEq_x2n_add
theorem xn_modEq_x2n_add (n j) : xn a1 (2 * n + j) + xn a1 j ≡ 0 [MOD xn a1 n] 
Arguments: {a : ℕ} (a1 : 1 < a) (n j : ℕ)
Goal: Pell.xn a1 (2 * n + j) + Pell.xn a1 j ≡ 0 [MOD Pell.xn a1 n]
-- Pell.xn_modEq_x2n_sub_lem
theorem xn_modEq_x2n_sub_lem {n j} (h : j ≤ n) : xn a1 (2 * n - j) + xn a1 j ≡ 0 [MOD xn a1 n] 
Arguments: {a : ℕ} (a1 : 1 < a) {n j : ℕ} (h : j ≤ n)
Goal: Pell.xn a1 (2 * n - j) + Pell.xn a1 j ≡ 0 [MOD Pell.xn a1 n]
-- Pell.xn_modEq_x2n_sub
theorem xn_modEq_x2n_sub {n j} (h : j ≤ 2 * n) : xn a1 (2 * n - j) + xn a1 j ≡ 0 [MOD xn a1 n] 
Arguments: {a : ℕ} (a1 : 1 < a) {n j : ℕ} (h : j ≤ 2 * n)
Goal: Pell.xn a1 (2 * n - j) + Pell.xn a1 j ≡ 0 [MOD Pell.xn a1 n]
-- Pell.xn_modEq_x4n_add
theorem xn_modEq_x4n_add (n j) : xn a1 (4 * n + j) ≡ xn a1 j [MOD xn a1 n] 
Arguments: {a : ℕ} (a1 : 1 < a) (n j : ℕ)
Goal: Pell.xn a1 (4 * n + j) ≡ Pell.xn a1 j [MOD Pell.xn a1 n]
-- Pell.xn_modEq_x4n_sub
theorem xn_modEq_x4n_sub {n j} (h : j ≤ 2 * n) : xn a1 (4 * n - j) ≡ xn a1 j [MOD xn a1 n] 
Arguments: {a : ℕ} (a1 : 1 < a) {n j : ℕ} (h : j ≤ 2 * n)
Goal: Pell.xn a1 (4 * n - j) ≡ Pell.xn a1 j [MOD Pell.xn a1 n]
-- Pell.eq_of_xn_modEq_lem1
theorem eq_of_xn_modEq_lem1 {i n} : ∀ {j}, i < j → j < n → xn a1 i % xn a1 n < xn a1 j % xn a1 n
  
Arguments: {a : ℕ} (a1 : 1 < a) {i n j : ℕ}
Goal: i < j → j < n → Pell.xn a1 i % Pell.xn a1 n < Pell.xn a1 j % Pell.xn a1 n
-- Pell.eq_of_xn_modEq_lem2
theorem eq_of_xn_modEq_lem2 {n} (h : 2 * xn a1 n = xn a1 (n + 1)) : a = 2 ∧ n = 0 
Arguments: {a : ℕ} (a1 : 1 < a) {n : ℕ} (h : 2 * Pell.xn a1 n = Pell.xn a1 (n + 1))
Goal: a = 2 ∧ n = 0
-- Pell.eq_of_xn_modEq_lem3
theorem eq_of_xn_modEq_lem3 {i n} (npos : 0 < n) :
    ∀ {j}, i < j → j ≤ 2 * n → j ≠ n → ¬(a = 2 ∧ n = 1 ∧ i = 0 ∧ j = 2) →
        xn a1 i % xn a1 n < xn a1 j % xn a1 n
  
Arguments: {a : ℕ} (a1 : 1 < a) {i n : ℕ} (npos : 0 < n) {j : ℕ}
Goal: i < j → j ≤ 2 * n → j ≠ n → ¬(a = 2 ∧ n = 1 ∧ i = 0 ∧ j = 2) → Pell.xn a1 i % Pell.xn a1 n < Pell.xn a1 j % Pell.xn a1 n
-- Pell.eq_of_xn_modEq_le
theorem eq_of_xn_modEq_le {i j n} (ij : i ≤ j) (j2n : j ≤ 2 * n)
    (h : xn a1 i ≡ xn a1 j [MOD xn a1 n])
    (ntriv : ¬(a = 2 ∧ n = 1 ∧ i = 0 ∧ j = 2)) : i = j 
Arguments: {a : ℕ} (a1 : 1 < a) {i j n : ℕ} (ij : i ≤ j) (j2n : j ≤ 2 * n) (h : Pell.xn a1 i ≡ Pell.xn a1 j [MOD Pell.xn a1 n]) (ntriv : ¬(a = 2 ∧ n = 1 ∧ i = 0 ∧ j = 2))
Goal: i = j
-- Pell.eq_of_xn_modEq
theorem eq_of_xn_modEq {i j n} (i2n : i ≤ 2 * n) (j2n : j ≤ 2 * n)
    (h : xn a1 i ≡ xn a1 j [MOD xn a1 n])
    (ntriv : a = 2 → n = 1 → (i = 0 → j ≠ 2) ∧ (i = 2 → j ≠ 0)) : i = j 
Arguments: {a : ℕ} (a1 : 1 < a) {i j n : ℕ} (i2n : i ≤ 2 * n) (j2n : j ≤ 2 * n) (h : Pell.xn a1 i ≡ Pell.xn a1 j [MOD Pell.xn a1 n]) (ntriv : a = 2 → n = 1 → (i = 0 → j ≠ 2) ∧ (i = 2 → j ≠ 0))
Goal: i = j
-- Pell.eq_of_xn_modEq'
theorem eq_of_xn_modEq' {i j n} (ipos : 0 < i) (hin : i ≤ n) (j4n : j ≤ 4 * n)
    (h : xn a1 j ≡ xn a1 i [MOD xn a1 n]) : j = i ∨ j + i = 4 * n 
Arguments: {a : ℕ} (a1 : 1 < a) {i j n : ℕ} (ipos : 0 < i) (hin : i ≤ n) (j4n : j ≤ 4 * n) (h : Pell.xn a1 j ≡ Pell.xn a1 i [MOD Pell.xn a1 n])
Goal: j = i ∨ j + i = 4 * n
-- Pell.modEq_of_xn_modEq
theorem modEq_of_xn_modEq {i j n} (ipos : 0 < i) (hin : i ≤ n)
    (h : xn a1 j ≡ xn a1 i [MOD xn a1 n]) :
    j ≡ i [MOD 4 * n] ∨ j + i ≡ 0 [MOD 4 * n] 
Arguments: {a : ℕ} (a1 : 1 < a) {i j n : ℕ} (ipos : 0 < i) (hin : i ≤ n) (h : Pell.xn a1 j ≡ Pell.xn a1 i [MOD Pell.xn a1 n])
Goal: j ≡ i [MOD 4 * n] ∨ j + i ≡ 0 [MOD 4 * n]
-- Pell.xy_modEq_of_modEq
theorem xy_modEq_of_modEq {a b c} (a1 : 1 < a) (b1 : 1 < b) (h : a ≡ b [MOD c]) :
    ∀ n, xn a1 n ≡ xn b1 n [MOD c] ∧ yn a1 n ≡ yn b1 n [MOD c]
  
Arguments: {a b c : ℕ} (a1 : 1 < a) (b1 : 1 < b) (h : a ≡ b [MOD c]) (n : ℕ)
Goal: Pell.xn a1 n ≡ Pell.xn b1 n [MOD c] ∧ Pell.yn a1 n ≡ Pell.yn b1 n [MOD c]
-- Pell.matiyasevic
theorem matiyasevic {a k x y} :
    (∃ a1 : 1 < a, xn a1 k = x ∧ yn a1 k = y) ↔
      1 < a ∧ k ≤ y ∧ (x = 1 ∧ y = 0 ∨
        ∃ u v s t b : ℕ,
          x * x - (a * a - 1) * y * y = 1 ∧ u * u - (a * a - 1) * v * v = 1 ∧
          s * s - (b * b - 1) * t * t = 1 ∧ 1 < b ∧ b ≡ 1 [MOD 4 * y] ∧
          b ≡ a [MOD u] ∧ 0 < v ∧ y * y ∣ v ∧ s ≡ x [MOD u] ∧ t ≡ k [MOD 4 * y]) 
Arguments: {a k x y : ℕ}
Goal: (∃ (a1 : 1 < a), Pell.xn a1 k = x ∧ Pell.yn a1 k = y) ↔
  1 < a ∧
    k ≤ y ∧
      (x = 1 ∧ y = 0 ∨
        ∃ u v s t b,
          x * x - (a * a - 1) * y * y = 1 ∧
            u * u - (a * a - 1) * v * v = 1 ∧
              s * s - (b * b - 1) * t * t = 1 ∧
                1 < b ∧ b ≡ 1 [MOD 4 * y] ∧ b ≡ a [MOD u] ∧ 0 < v ∧ y * y ∣ v ∧ s ≡ x [MOD u] ∧ t ≡ k [MOD 4 * y])