ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- NumberField.integralBasis_apply
@[simp]
theorem integralBasis_apply (i : Free.ChooseBasisIndex ℤ (𝓞 K)) :
    integralBasis K i = algebraMap (𝓞 K) K (RingOfIntegers.basis K i) 
Arguments: (K : Type u_1) [Field K] [nf : NumberField K] (i : Module.Free.ChooseBasisIndex ℤ (NumberField.RingOfIntegers K))
Goal: (NumberField.integralBasis K) i = (algebraMap (NumberField.RingOfIntegers K) K) ((NumberField.RingOfIntegers.basis K) i)
-- NumberField.integralBasis_repr_apply
@[simp]
theorem integralBasis_repr_apply (x : (𝓞 K)) (i : Free.ChooseBasisIndex ℤ (𝓞 K)) :
    (integralBasis K).repr (algebraMap _ _ x) i =
      (algebraMap ℤ ℚ) ((RingOfIntegers.basis K).repr x i) 
Arguments: (K : Type u_1) [Field K] [nf : NumberField K] (x : NumberField.RingOfIntegers K) (i : Module.Free.ChooseBasisIndex ℤ (NumberField.RingOfIntegers K))
Goal: ((NumberField.integralBasis K).repr ((algebraMap (NumberField.RingOfIntegers K) K) x)) i =
  (algebraMap ℤ ℚ) (((NumberField.RingOfIntegers.basis K).repr x) i)
-- NumberField.mem_span_integralBasis
theorem mem_span_integralBasis {x : K} :
    x ∈ Submodule.span ℤ (Set.range (integralBasis K)) ↔ x ∈ (algebraMap (𝓞 K) K).range 
Arguments: (K : Type u_1) [Field K] [nf : NumberField K] {x : K}
Goal: x ∈ Submodule.span ℤ (Set.range ⇑(NumberField.integralBasis K)) ↔
  x ∈ (algebraMap (NumberField.RingOfIntegers K) K).range
-- NumberField.RingOfIntegers.rank
theorem RingOfIntegers.rank : FiniteDimensional.finrank ℤ (𝓞 K) = FiniteDimensional.finrank ℚ K 
Arguments: (K : Type u_1) [Field K] [nf : NumberField K]
Goal: FiniteDimensional.finrank ℤ (NumberField.RingOfIntegers K) = FiniteDimensional.finrank ℚ K
-- Rat.MulRingNorm.eq_on_nat_iff_eq_on_Int
lemma eq_on_nat_iff_eq_on_Int : (∀ n : ℕ , f n = g n) ↔ (∀ n : ℤ , f n = g n) 
Arguments: {f g : MulRingNorm ℚ}
Goal: (∀ (n : ℕ), f ↑n = g ↑n) ↔ ∀ (n : ℤ), f ↑n = g ↑n
-- Rat.MulRingNorm.eq_on_nat_iff_eq
lemma eq_on_nat_iff_eq : (∀ n : ℕ , f n = g n) ↔ f = g 
Arguments: {f g : MulRingNorm ℚ}
Goal: (∀ (n : ℕ), f ↑n = g ↑n) ↔ f = g
-- Rat.MulRingNorm.equiv_on_nat_iff_equiv
lemma equiv_on_nat_iff_equiv : (∃ c : ℝ, 0 < c ∧ (∀ n : ℕ , (f n) ^ c = g n)) ↔
    f.equiv g 
Arguments: {f g : MulRingNorm ℚ}
Goal: (∃ c, 0 < c ∧ ∀ (n : ℕ), f ↑n ^ c = g ↑n) ↔ f.equiv g
-- Rat.MulRingNorm.mulRingNorm_eq_padic_norm
@[simp] lemma mulRingNorm_eq_padic_norm (p : ℕ) [Fact p.Prime] (r : ℚ) :
  mulRingNorm_padic p r = padicNorm p r 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] (r : ℚ)
Goal: (Rat.MulRingNorm.mulRingNorm_padic p) r = ↑(padicNorm p r)
-- Rat.MulRingNorm.exists_minimal_nat_zero_lt_mulRingNorm_lt_one
lemma exists_minimal_nat_zero_lt_mulRingNorm_lt_one : ∃ p : ℕ, (0 < f p ∧ f p < 1) ∧
    ∀ m : ℕ, 0 < f m ∧ f m < 1 → p ≤ m 
Arguments: {f : MulRingNorm ℚ} (hf_nontriv : f ≠ 1) (bdd : ∀ (n : ℕ), f ↑n ≤ 1)
Goal: ∃ p, (0 < f ↑p ∧ f ↑p < 1) ∧ ∀ (m : ℕ), 0 < f ↑m ∧ f ↑m < 1 → p ≤ m
-- Rat.MulRingNorm.is_prime_of_minimal_nat_zero_lt_mulRingNorm_lt_one
lemma is_prime_of_minimal_nat_zero_lt_mulRingNorm_lt_one : p.Prime 
Arguments: {f : MulRingNorm ℚ} {p : ℕ} (hp0 : 0 < f ↑p) (hp1 : f ↑p < 1) (hmin : ∀ (m : ℕ), 0 < f ↑m ∧ f ↑m < 1 → p ≤ m)
Goal: Nat.Prime p
-- Rat.MulRingNorm.mulRingNorm_eq_one_of_not_dvd
lemma mulRingNorm_eq_one_of_not_dvd {m : ℕ} (hpm : ¬ p ∣ m) : f m = 1 
Arguments: {f : MulRingNorm ℚ} (bdd : ∀ (n : ℕ), f ↑n ≤ 1) {p : ℕ} (hp0 : 0 < f ↑p) (hp1 : f ↑p < 1) (hmin : ∀ (m : ℕ), 0 < f ↑m ∧ f ↑m < 1 → p ≤ m) {m : ℕ} (hpm : ¬p ∣ m)
Goal: f ↑m = 1
-- Rat.MulRingNorm.exists_pos_mulRingNorm_eq_pow_neg
lemma exists_pos_mulRingNorm_eq_pow_neg : ∃ t : ℝ, 0 < t ∧ f p = p ^ (-t) 
Arguments: {f : MulRingNorm ℚ} {p : ℕ} (hp0 : 0 < f ↑p) (hp1 : f ↑p < 1) (hmin : ∀ (m : ℕ), 0 < f ↑m ∧ f ↑m < 1 → p ≤ m)
Goal: ∃ t, 0 < t ∧ f ↑p = ↑p ^ (-t)
-- Rat.MulRingNorm.mulRingNorm_equiv_padic_of_bounded
theorem mulRingNorm_equiv_padic_of_bounded :
    ∃! p, ∃ (hp : Fact (p.Prime)), MulRingNorm.equiv f (mulRingNorm_padic p) 
Arguments: {f : MulRingNorm ℚ} (hf_nontriv : f ≠ 1) (bdd : ∀ (n : ℕ), f ↑n ≤ 1)
Goal: ∃! p, ∃ (hp : Fact (Nat.Prime p)), f.equiv (Rat.MulRingNorm.mulRingNorm_padic p)
-- Nat.coprime_of_probablePrime
theorem coprime_of_probablePrime {n b : ℕ} (h : ProbablePrime n b) (h₁ : 1 ≤ n) (h₂ : 1 ≤ b) :
    Nat.Coprime n b 
Arguments: {n b : ℕ} (h : n.ProbablePrime b) (h₁ : 1 ≤ n) (h₂ : 1 ≤ b)
Goal: n.Coprime b
-- Nat.probablePrime_iff_modEq
theorem probablePrime_iff_modEq (n : ℕ) {b : ℕ} (h : 1 ≤ b) :
    ProbablePrime n b ↔ b ^ (n - 1) ≡ 1 [MOD n] 
Arguments: (n : ℕ) {b : ℕ} (h : 1 ≤ b)
Goal: n.ProbablePrime b ↔ b ^ (n - 1) ≡ 1 [MOD n]
-- Nat.coprime_of_fermatPsp
theorem coprime_of_fermatPsp {n b : ℕ} (h : FermatPsp n b) (h₁ : 1 ≤ b) : Nat.Coprime n b 
Arguments: {n b : ℕ} (h : n.FermatPsp b) (h₁ : 1 ≤ b)
Goal: n.Coprime b
-- Nat.fermatPsp_base_one
theorem fermatPsp_base_one {n : ℕ} (h₁ : 1 < n) (h₂ : ¬n.Prime) : FermatPsp n 1 
Arguments: {n : ℕ} (h₁ : 1 < n) (h₂ : ¬Nat.Prime n)
Goal: n.FermatPsp 1
-- _private.Mathlib.NumberTheory.FermatPsp.0.Nat.a_id_helper
private theorem a_id_helper {a b : ℕ} (ha : 2 ≤ a) (hb : 2 ≤ b) : 2 ≤ (a ^ b - 1) / (a - 1) 
Arguments: {a b : ℕ} (ha : 2 ≤ a) (hb : 2 ≤ b)
Goal: 2 ≤ (a ^ b - 1) / (a - 1)
-- _private.Mathlib.NumberTheory.FermatPsp.0.Nat.b_id_helper
private theorem b_id_helper {a b : ℕ} (ha : 2 ≤ a) (hb : 2 < b) : 2 ≤ (a ^ b + 1) / (a + 1) 
Arguments: {a b : ℕ} (ha : 2 ≤ a) (hb : 2 < b)
Goal: 2 ≤ (a ^ b + 1) / (a + 1)
-- _private.Mathlib.NumberTheory.FermatPsp.0.Nat.AB_id_helper
private theorem AB_id_helper (b p : ℕ) (_ : 2 ≤ b) (hp : Odd p) :
    (b ^ p - 1) / (b - 1) * ((b ^ p + 1) / (b + 1)) = (b ^ (2 * p) - 1) / (b ^ 2 - 1) 
Arguments: (b p : ℕ)
Goal: 2 ≤ b → Odd p → (b ^ p - 1) / (b - 1) * ((b ^ p + 1) / (b + 1)) = (b ^ (2 * p) - 1) / (b ^ 2 - 1)
-- _private.Mathlib.NumberTheory.FermatPsp.0.Nat.bp_helper
private theorem bp_helper {b p : ℕ} (hb : 0 < b) (hp : 1 ≤ p) :
    b ^ (2 * p) - 1 - (b ^ 2 - 1) = b * (b ^ (p - 1) - 1) * (b ^ p + b) 
Arguments: {b p : ℕ} (hb : 0 < b) (hp : 1 ≤ p)
Goal: b ^ (2 * p) - 1 - (b ^ 2 - 1) = b * (b ^ (p - 1) - 1) * (b ^ p + b)
-- _private.Mathlib.NumberTheory.FermatPsp.0.Nat.psp_from_prime_psp
private theorem psp_from_prime_psp {b : ℕ} (b_ge_two : 2 ≤ b) {p : ℕ} (p_prime : p.Prime)
    (p_gt_two : 2 < p) (not_dvd : ¬p ∣ b * (b ^ 2 - 1)) : FermatPsp (psp_from_prime b p) b 
Arguments: {b : ℕ} (b_ge_two : 2 ≤ b) {p : ℕ} (p_prime : Nat.Prime p) (p_gt_two : 2 < p) (not_dvd : ¬p ∣ b * (b ^ 2 - 1))
Goal: (Nat.psp_from_prime b p).FermatPsp b
-- _private.Mathlib.NumberTheory.FermatPsp.0.Nat.psp_from_prime_gt_p
private theorem psp_from_prime_gt_p {b : ℕ} (b_ge_two : 2 ≤ b) {p : ℕ} (p_prime : p.Prime)
    (p_gt_two : 2 < p) : p < psp_from_prime b p 
Arguments: {b : ℕ} (b_ge_two : 2 ≤ b) {p : ℕ} (p_prime : Nat.Prime p) (p_gt_two : 2 < p)
Goal: p < Nat.psp_from_prime b p
-- Nat.exists_infinite_pseudoprimes
theorem exists_infinite_pseudoprimes {b : ℕ} (h : 1 ≤ b) (m : ℕ) :
    ∃ n : ℕ, FermatPsp n b ∧ m ≤ n 
Arguments: {b : ℕ} (h : 1 ≤ b) (m : ℕ)
Goal: ∃ n, n.FermatPsp b ∧ m ≤ n
-- Nat.frequently_atTop_fermatPsp
theorem frequently_atTop_fermatPsp {b : ℕ} (h : 1 ≤ b) : ∃ᶠ n in Filter.atTop, FermatPsp n b 
Arguments: {b : ℕ} (h : 1 ≤ b)
Goal: ∃ᶠ (n : ℕ) in Filter.atTop, n.FermatPsp b
-- Nat.infinite_setOf_pseudoprimes
theorem infinite_setOf_pseudoprimes {b : ℕ} (h : 1 ≤ b) :
    Set.Infinite { n : ℕ | FermatPsp n b } 
Arguments: {b : ℕ} (h : 1 ≤ b)
Goal: {n | n.FermatPsp b}.Infinite
-- NumberField.classNumber_eq_one_iff
theorem classNumber_eq_one_iff : classNumber K = 1 ↔ IsPrincipalIdealRing (𝓞 K) 
Arguments: {K : Type u_1} [Field K] [NumberField K]
Goal: NumberField.classNumber K = 1 ↔ IsPrincipalIdealRing (NumberField.RingOfIntegers K)
-- NumberField.exists_ideal_in_class_of_norm_le
theorem exists_ideal_in_class_of_norm_le (C : ClassGroup (𝓞 K)) :
    ∃ I : (Ideal (𝓞 K))⁰, ClassGroup.mk0 I = C ∧
      Ideal.absNorm (I : Ideal (𝓞 K)) ≤ (4 / π) ^ NrComplexPlaces K *
        ((finrank ℚ K).factorial / (finrank ℚ K) ^ (finrank ℚ K) * Real.sqrt |discr K|) 
Arguments: {K : Type u_1} [Field K] [NumberField K] (C : ClassGroup (NumberField.RingOfIntegers K))
Goal: ∃ I,
  ClassGroup.mk0 I = C ∧
    ↑(Ideal.absNorm ↑I) ≤
      (4 / Real.pi) ^ NumberField.InfinitePlace.NrComplexPlaces K *
        (↑(FiniteDimensional.finrank ℚ K).factorial / ↑(FiniteDimensional.finrank ℚ K) ^ FiniteDimensional.finrank ℚ K *
          √|↑(NumberField.discr K)|)
-- RingOfIntegers.isPrincipalIdealRing_of_abs_discr_lt
theorem _root_.RingOfIntegers.isPrincipalIdealRing_of_abs_discr_lt
    (h : |discr K| < (2 * (π / 4) ^ NrComplexPlaces K *
      ((finrank ℚ K) ^ (finrank ℚ K) / (finrank ℚ K).factorial)) ^ 2) :
    IsPrincipalIdealRing (𝓞 K) 
Arguments: {K : Type u_1} [Field K] [NumberField K] (h :
  ↑|NumberField.discr K| <
    (2 * (Real.pi / 4) ^ NumberField.InfinitePlace.NrComplexPlaces K *
        (↑(FiniteDimensional.finrank ℚ K) ^ FiniteDimensional.finrank ℚ K /
          ↑(FiniteDimensional.finrank ℚ K).factorial)) ^
      2)
Goal: IsPrincipalIdealRing (NumberField.RingOfIntegers K)
-- Rat.classNumber_eq
theorem classNumber_eq : NumberField.classNumber ℚ = 1 
Goal: NumberField.classNumber ℚ = 1
-- NumberField.basisOfFractionalIdeal_apply
theorem basisOfFractionalIdeal_apply (I : (FractionalIdeal (𝓞 K)⁰ K)ˣ)
    (i : Free.ChooseBasisIndex ℤ I) :
    basisOfFractionalIdeal K I i = fractionalIdealBasis K I.1 i 
Arguments: (K : Type u_1) [Field K] [NumberField K] (I : (FractionalIdeal (nonZeroDivisors (NumberField.RingOfIntegers K)) K)ˣ) (i : Module.Free.ChooseBasisIndex ℤ ↥↑↑I)
Goal: (NumberField.basisOfFractionalIdeal K I) i = ↑((NumberField.fractionalIdealBasis K ↑I) i)
-- NumberField.mem_span_basisOfFractionalIdeal
theorem mem_span_basisOfFractionalIdeal {I : (FractionalIdeal (𝓞 K)⁰ K)ˣ} {x : K} :
    x ∈ Submodule.span ℤ (Set.range (basisOfFractionalIdeal K I)) ↔ x ∈ (I : Set K) 
Arguments: (K : Type u_1) [Field K] [NumberField K] {I : (FractionalIdeal (nonZeroDivisors (NumberField.RingOfIntegers K)) K)ˣ} {x : K}
Goal: x ∈ Submodule.span ℤ (Set.range ⇑(NumberField.basisOfFractionalIdeal K I)) ↔ x ∈ ↑↑I
-- NumberField.fractionalIdeal_rank
theorem fractionalIdeal_rank (I : (FractionalIdeal (𝓞 K)⁰ K)ˣ) :
    finrank ℤ I = finrank ℤ (𝓞 K) 
Arguments: (K : Type u_1) [Field K] [NumberField K] (I : (FractionalIdeal (nonZeroDivisors (NumberField.RingOfIntegers K)) K)ˣ)
Goal: FiniteDimensional.finrank ℤ ↥↑↑I = FiniteDimensional.finrank ℤ (NumberField.RingOfIntegers K)
-- NumberField.det_basisOfFractionalIdeal_eq_absNorm
theorem det_basisOfFractionalIdeal_eq_absNorm  (I : (FractionalIdeal (𝓞 K)⁰ K)ˣ)
    (e : (Free.ChooseBasisIndex ℤ (𝓞 K)) ≃ (Free.ChooseBasisIndex ℤ I)) :
    |(integralBasis K).det ((basisOfFractionalIdeal K I).reindex e.symm)| =
      FractionalIdeal.absNorm I.1 
Arguments: (K : Type u_1) [Field K] [NumberField K] (I : (FractionalIdeal (nonZeroDivisors (NumberField.RingOfIntegers K)) K)ˣ) (e : Module.Free.ChooseBasisIndex ℤ (NumberField.RingOfIntegers K) ≃ Module.Free.ChooseBasisIndex ℤ ↥↑↑I)
Goal: |(NumberField.integralBasis K).det ⇑((NumberField.basisOfFractionalIdeal K I).reindex e.symm)| =
  FractionalIdeal.absNorm ↑I
-- NumberField.Units.regulator_ne_zero
theorem regulator_ne_zero : regulator K ≠ 0 
Arguments: (K : Type u_1) [Field K] [NumberField K]
Goal: NumberField.Units.regulator K ≠ 0
-- NumberField.Units.regulator_pos
theorem regulator_pos : 0 < regulator K 
Arguments: (K : Type u_1) [Field K] [NumberField K]
Goal: 0 < NumberField.Units.regulator K
-- NumberField.Units.regulator_eq_det'
theorem regulator_eq_det' (e : {w : InfinitePlace K // w ≠ w₀} ≃ Fin (rank K)) :
    regulator K = |(Matrix.of fun i ↦ (logEmbedding K) (fundSystem K (e i))).det| 
Arguments: (K : Type u_1) [Field K] [NumberField K] (e : { w // w ≠ NumberField.Units.dirichletUnitTheorem.w₀ } ≃ Fin (NumberField.Units.rank K))
Goal: NumberField.Units.regulator K =
  |(Matrix.of fun i => (NumberField.Units.logEmbedding K) (NumberField.Units.fundSystem K (e i))).det|
-- NumberField.Units.abs_det_eq_abs_det
theorem abs_det_eq_abs_det (u : Fin (rank K) → (𝓞 K)ˣ)
    {w₁ w₂ : InfinitePlace K} (e₁ : {w // w ≠ w₁} ≃ Fin (rank K))
    (e₂ : {w // w ≠ w₂} ≃ Fin (rank K)) :
    |(Matrix.of fun i w : {w // w ≠ w₁} ↦ (mult w.val : ℝ) * (w.val (u (e₁ i) : K)).log).det| =
    |(Matrix.of fun i w : {w // w ≠ w₂} ↦ (mult w.val : ℝ) * (w.val (u (e₂ i) : K)).log).det| 
Arguments: (K : Type u_1) [Field K] [NumberField K] (u : Fin (NumberField.Units.rank K) → (𝓞 K)ˣ) {w₁ w₂ : NumberField.InfinitePlace K} (e₁ : { w // w ≠ w₁ } ≃ Fin (NumberField.Units.rank K)) (e₂ : { w // w ≠ w₂ } ≃ Fin (NumberField.Units.rank K))
Goal: |(Matrix.of fun i w => ↑(↑w).mult * Real.log (↑w ((algebraMap (𝓞 K) K) ↑(u (e₁ i))))).det| =
  |(Matrix.of fun i w => ↑(↑w).mult * Real.log (↑w ((algebraMap (𝓞 K) K) ↑(u (e₂ i))))).det|
-- NumberField.Units.regulator_eq_det
theorem regulator_eq_det (w' : InfinitePlace K) (e : {w // w ≠ w'} ≃ Fin (rank K)) :
    regulator K =
      |(Matrix.of fun i w : {w // w ≠ w'} ↦ (mult w.val : ℝ) *
        Real.log (w.val (fundSystem K (e i) : K))).det| 
Arguments: (K : Type u_1) [Field K] [NumberField K] (w' : NumberField.InfinitePlace K) (e : { w // w ≠ w' } ≃ Fin (NumberField.Units.rank K))
Goal: NumberField.Units.regulator K =
  |(Matrix.of fun i w => ↑(↑w).mult * Real.log (↑w ((algebraMap (𝓞 K) K) ↑(NumberField.Units.fundSystem K (e i))))).det|
-- Real.exists_int_int_abs_mul_sub_le
theorem exists_int_int_abs_mul_sub_le (ξ : ℝ) {n : ℕ} (n_pos : 0 < n) :
    ∃ j k : ℤ, 0 < k ∧ k ≤ n ∧ |↑k * ξ - j| ≤ 1 / (n + 1) 
Arguments: (ξ : ℝ) {n : ℕ} (n_pos : 0 < n)
Goal: ∃ j k, 0 < k ∧ k ≤ ↑n ∧ |↑k * ξ - ↑j| ≤ 1 / (↑n + 1)
-- Real.exists_nat_abs_mul_sub_round_le
theorem exists_nat_abs_mul_sub_round_le (ξ : ℝ) {n : ℕ} (n_pos : 0 < n) :
    ∃ k : ℕ, 0 < k ∧ k ≤ n ∧ |↑k * ξ - round (↑k * ξ)| ≤ 1 / (n + 1) 
Arguments: (ξ : ℝ) {n : ℕ} (n_pos : 0 < n)
Goal: ∃ k, 0 < k ∧ k ≤ n ∧ |↑k * ξ - ↑(round (↑k * ξ))| ≤ 1 / (↑n + 1)
-- Real.exists_rat_abs_sub_le_and_den_le
theorem exists_rat_abs_sub_le_and_den_le (ξ : ℝ) {n : ℕ} (n_pos : 0 < n) :
    ∃ q : ℚ, |ξ - q| ≤ 1 / ((n + 1) * q.den) ∧ q.den ≤ n 
Arguments: (ξ : ℝ) {n : ℕ} (n_pos : 0 < n)
Goal: ∃ q, |ξ - ↑q| ≤ 1 / ((↑n + 1) * ↑q.den) ∧ q.den ≤ n
-- Real.exists_rat_abs_sub_lt_and_lt_of_irrational
theorem exists_rat_abs_sub_lt_and_lt_of_irrational {ξ : ℝ} (hξ : Irrational ξ) (q : ℚ) :
    ∃ q' : ℚ, |ξ - q'| < 1 / (q'.den : ℝ) ^ 2 ∧ |ξ - q'| < |ξ - q| 
Arguments: {ξ : ℝ} (hξ : Irrational ξ) (q : ℚ)
Goal: ∃ q', |ξ - ↑q'| < 1 / ↑q'.den ^ 2 ∧ |ξ - ↑q'| < |ξ - ↑q|
-- Real.infinite_rat_abs_sub_lt_one_div_den_sq_of_irrational
theorem infinite_rat_abs_sub_lt_one_div_den_sq_of_irrational {ξ : ℝ} (hξ : Irrational ξ) :
    {q : ℚ | |ξ - q| < 1 / (q.den : ℝ) ^ 2}.Infinite 
Arguments: {ξ : ℝ} (hξ : Irrational ξ)
Goal: {q | |ξ - ↑q| < 1 / ↑q.den ^ 2}.Infinite
-- Rat.den_le_and_le_num_le_of_sub_lt_one_div_den_sq
theorem den_le_and_le_num_le_of_sub_lt_one_div_den_sq {ξ q : ℚ}
    (h : |ξ - q| < 1 / (q.den : ℚ) ^ 2) :
    q.den ≤ ξ.den ∧ ⌈ξ * q.den⌉ - 1 ≤ q.num ∧ q.num ≤ ⌊ξ * q.den⌋ + 1 
Arguments: {ξ q : ℚ} (h : |ξ - q| < 1 / ↑q.den ^ 2)
Goal: q.den ≤ ξ.den ∧ ⌈ξ * ↑q.den⌉ - 1 ≤ q.num ∧ q.num ≤ ⌊ξ * ↑q.den⌋ + 1
-- Rat.finite_rat_abs_sub_lt_one_div_den_sq
theorem finite_rat_abs_sub_lt_one_div_den_sq (ξ : ℚ) :
    {q : ℚ | |ξ - q| < 1 / (q.den : ℚ) ^ 2}.Finite 
Arguments: (ξ : ℚ)
Goal: {q | |ξ - q| < 1 / ↑q.den ^ 2}.Finite
-- Real.infinite_rat_abs_sub_lt_one_div_den_sq_iff_irrational
theorem Real.infinite_rat_abs_sub_lt_one_div_den_sq_iff_irrational (ξ : ℝ) :
    {q : ℚ | |ξ - q| < 1 / (q.den : ℝ) ^ 2}.Infinite ↔ Irrational ξ 
Arguments: (ξ : ℝ)
Goal: {q | |ξ - ↑q| < 1 / ↑q.den ^ 2}.Infinite ↔ Irrational ξ
-- Real.convergent_zero
@[simp]
theorem convergent_zero (ξ : ℝ) : ξ.convergent 0 = ⌊ξ⌋ 
Arguments: (ξ : ℝ)
Goal: ξ.convergent 0 = ↑⌊ξ⌋
-- Real.convergent_succ
@[simp]
theorem convergent_succ (ξ : ℝ) (n : ℕ) :
    ξ.convergent (n + 1) = ⌊ξ⌋ + ((fract ξ)⁻¹.convergent n)⁻¹ 
Arguments: (ξ : ℝ) (n : ℕ)
Goal: ξ.convergent (n + 1) = ↑⌊ξ⌋ + ((Int.fract ξ)⁻¹.convergent n)⁻¹
-- Real.convergent_of_zero
@[simp]
theorem convergent_of_zero (n : ℕ) : convergent 0 n = 0 
Arguments: (n : ℕ)
Goal: Real.convergent 0 n = 0
-- Real.convergent_of_int
@[simp]
theorem convergent_of_int {ξ : ℤ} (n : ℕ) : convergent ξ n = ξ 
Arguments: {ξ : ℤ} (n : ℕ)
Goal: (↑ξ).convergent n = ↑ξ
-- Real.convs_eq_convergent
theorem convs_eq_convergent (ξ : ℝ) (n : ℕ) :
    (GenContFract.of ξ).convs n = ξ.convergent n 
Arguments: (ξ : ℝ) (n : ℕ)
Goal: (GenContFract.of ξ).convs n = ↑(ξ.convergent n)
-- _private.Mathlib.NumberTheory.DiophantineApproximation.0.Real.aux₀
private theorem aux₀ {v : ℤ} (hv : 0 < v) : (0 : ℝ) < v ∧ (0 : ℝ) < 2 * v - 1 
Arguments: {v : ℤ} (hv : 0 < v)
Goal: 0 < ↑v ∧ 0 < 2 * ↑v - 1
-- _private.Mathlib.NumberTheory.DiophantineApproximation.0.Real.aux₁
private theorem aux₁ : 0 < fract ξ 
Arguments: {ξ : ℝ} {u v : ℤ} (hv : 2 ≤ v) (h : Real.ContfracLegendre.Ass ξ u v)
Goal: 0 < Int.fract ξ
-- _private.Mathlib.NumberTheory.DiophantineApproximation.0.Real.aux₂
private theorem aux₂ : 0 < u - ⌊ξ⌋ * v ∧ u - ⌊ξ⌋ * v < v 
Arguments: {ξ : ℝ} {u v : ℤ} (hv : 2 ≤ v) (h : Real.ContfracLegendre.Ass ξ u v)
Goal: 0 < u - ⌊ξ⌋ * v ∧ u - ⌊ξ⌋ * v < v
-- _private.Mathlib.NumberTheory.DiophantineApproximation.0.Real.aux₃
private theorem aux₃ :
    |(fract ξ)⁻¹ - v / (u - ⌊ξ⌋ * v)| < (((u : ℝ) - ⌊ξ⌋ * v) * (2 * (u - ⌊ξ⌋ * v) - 1))⁻¹ 
Arguments: {ξ : ℝ} {u v : ℤ} (hv : 2 ≤ v) (h : Real.ContfracLegendre.Ass ξ u v)
Goal: |(Int.fract ξ)⁻¹ - ↑v / (↑u - ↑⌊ξ⌋ * ↑v)| < ((↑u - ↑⌊ξ⌋ * ↑v) * (2 * (↑u - ↑⌊ξ⌋ * ↑v) - 1))⁻¹
-- _private.Mathlib.NumberTheory.DiophantineApproximation.0.Real.invariant
private theorem invariant : ContfracLegendre.Ass (fract ξ)⁻¹ v (u - ⌊ξ⌋ * v) 
Arguments: {ξ : ℝ} {u v : ℤ} (hv : 2 ≤ v) (h : Real.ContfracLegendre.Ass ξ u v)
Goal: Real.ContfracLegendre.Ass (Int.fract ξ)⁻¹ v (u - ⌊ξ⌋ * v)
-- Real.exists_rat_eq_convergent'
theorem exists_rat_eq_convergent' {v : ℕ} (h' : ContfracLegendre.Ass ξ u v) :
    ∃ n, (u / v : ℚ) = ξ.convergent n 
Arguments: {ξ : ℝ} {u : ℤ} {v : ℕ} (h' : Real.ContfracLegendre.Ass ξ u ↑v)
Goal: ∃ n, ↑u / ↑v = ξ.convergent n
-- Real.exists_rat_eq_convergent
theorem exists_rat_eq_convergent {q : ℚ} (h : |ξ - q| < 1 / (2 * (q.den : ℝ) ^ 2)) :
    ∃ n, q = ξ.convergent n 
Arguments: {ξ : ℝ} {q : ℚ} (h : |ξ - ↑q| < 1 / (2 * ↑q.den ^ 2))
Goal: ∃ n, q = ξ.convergent n
-- Real.exists_convs_eq_rat
theorem exists_convs_eq_rat {q : ℚ}
    (h : |ξ - q| < 1 / (2 * (q.den : ℝ) ^ 2)) : ∃ n, (GenContFract.of ξ).convs n = q 
Arguments: {ξ : ℝ} {q : ℚ} (h : |ξ - ↑q| < 1 / (2 * ↑q.den ^ 2))
Goal: ∃ n, (GenContFract.of ξ).convs n = ↑q
-- summable_riemannZetaSummand
lemma summable_riemannZetaSummand (hs : 1 < s.re) :
    Summable (fun n ↦ ‖riemannZetaSummandHom (ne_zero_of_one_lt_re hs) n‖) 
Arguments: {s : ℂ} (hs : 1 < s.re)
Goal: Summable fun n => ‖(riemannZetaSummandHom ⋯) n‖
-- tsum_riemannZetaSummand
lemma tsum_riemannZetaSummand (hs : 1 < s.re) :
    ∑' (n : ℕ), riemannZetaSummandHom (ne_zero_of_one_lt_re hs) n = riemannZeta s 
Arguments: {s : ℂ} (hs : 1 < s.re)
Goal: ∑' (n : ℕ), (riemannZetaSummandHom ⋯) n = riemannZeta s
-- summable_dirichletSummand
lemma summable_dirichletSummand {N : ℕ} (χ : DirichletCharacter ℂ N) (hs : 1 < s.re) :
    Summable (fun n ↦ ‖dirichletSummandHom χ (ne_zero_of_one_lt_re hs) n‖) 
Arguments: {s : ℂ} {N : ℕ} (χ : DirichletCharacter ℂ N) (hs : 1 < s.re)
Goal: Summable fun n => ‖(dirichletSummandHom χ ⋯) n‖
-- tsum_dirichletSummand
lemma tsum_dirichletSummand {N : ℕ} (χ : DirichletCharacter ℂ N) (hs : 1 < s.re) :
    ∑' (n : ℕ), dirichletSummandHom χ (ne_zero_of_one_lt_re hs) n = L ↗χ s 
Arguments: {s : ℂ} {N : ℕ} (χ : DirichletCharacter ℂ N) (hs : 1 < s.re)
Goal: ∑' (n : ℕ), (dirichletSummandHom χ ⋯) n = L (fun n => χ ↑n) s
-- riemannZeta_eulerProduct_hasProd
theorem riemannZeta_eulerProduct_hasProd (hs : 1 < s.re) :
    HasProd (fun p : Primes ↦ (1 - (p : ℂ) ^ (-s))⁻¹) (riemannZeta s) 
Arguments: {s : ℂ} (hs : 1 < s.re)
Goal: HasProd (fun p => (1 - ↑↑p ^ (-s))⁻¹) (riemannZeta s)
-- riemannZeta_eulerProduct_tprod
theorem riemannZeta_eulerProduct_tprod (hs : 1 < s.re) :
    ∏' p : Primes, (1 - (p : ℂ) ^ (-s))⁻¹ = riemannZeta s 
Arguments: {s : ℂ} (hs : 1 < s.re)
Goal: ∏' (p : Nat.Primes), (1 - ↑↑p ^ (-s))⁻¹ = riemannZeta s
-- riemannZeta_eulerProduct
theorem riemannZeta_eulerProduct (hs : 1 < s.re) :
    Tendsto (fun n : ℕ ↦ ∏ p ∈ primesBelow n, (1 - (p : ℂ) ^ (-s))⁻¹) atTop
      (𝓝 (riemannZeta s)) 
Arguments: {s : ℂ} (hs : 1 < s.re)
Goal: Filter.Tendsto (fun n => ∏ p ∈ n.primesBelow, (1 - ↑p ^ (-s))⁻¹) Filter.atTop (𝓝 (riemannZeta s))
-- dirichletLSeries_eulerProduct_hasProd
theorem dirichletLSeries_eulerProduct_hasProd {N : ℕ} (χ : DirichletCharacter ℂ N)
    (hs : 1 < s.re) :
    HasProd (fun p : Primes ↦ (1 - χ p * (p : ℂ) ^ (-s))⁻¹) (L ↗χ s) 
Arguments: {s : ℂ} {N : ℕ} (χ : DirichletCharacter ℂ N) (hs : 1 < s.re)
Goal: HasProd (fun p => (1 - χ ↑↑p * ↑↑p ^ (-s))⁻¹) (L (fun n => χ ↑n) s)
-- dirichletLSeries_eulerProduct_tprod
theorem dirichletLSeries_eulerProduct_tprod {N : ℕ} (χ : DirichletCharacter ℂ N)
    (hs : 1 < s.re) :
    ∏' p : Primes, (1 - χ p * (p : ℂ) ^ (-s))⁻¹ = L ↗χ s 
Arguments: {s : ℂ} {N : ℕ} (χ : DirichletCharacter ℂ N) (hs : 1 < s.re)
Goal: ∏' (p : Nat.Primes), (1 - χ ↑↑p * ↑↑p ^ (-s))⁻¹ = L (fun n => χ ↑n) s
-- dirichletLSeries_eulerProduct
theorem dirichletLSeries_eulerProduct {N : ℕ} (χ : DirichletCharacter ℂ N) (hs : 1 < s.re) :
    Tendsto (fun n : ℕ ↦ ∏ p ∈ primesBelow n, (1 - χ p * (p : ℂ) ^ (-s))⁻¹) atTop
      (𝓝 (L ↗χ s)) 
Arguments: {s : ℂ} {N : ℕ} (χ : DirichletCharacter ℂ N) (hs : 1 < s.re)
Goal: Filter.Tendsto (fun n => ∏ p ∈ n.primesBelow, (1 - χ ↑p * ↑p ^ (-s))⁻¹) Filter.atTop (𝓝 (L (fun n => χ ↑n) s))
-- ZMod.wilsons_lemma
@[simp]
theorem wilsons_lemma : ((p - 1)! : ZMod p) = -1 
Arguments: (p : ℕ) [Fact (Nat.Prime p)]
Goal: ↑(p - 1)! = -1
-- ZMod.prod_Ico_one_prime
@[simp]
theorem prod_Ico_one_prime : ∏ x ∈ Ico 1 p, (x : ZMod p) = -1 
Arguments: (p : ℕ) [Fact (Nat.Prime p)]
Goal: ∏ x ∈ Finset.Ico 1 p, ↑x = -1
-- Nat.prime_of_fac_equiv_neg_one
theorem prime_of_fac_equiv_neg_one (h : ((n - 1)! : ZMod n) = -1) (h1 : n ≠ 1) : Prime n 
Arguments: {n : ℕ} (h : ↑(n - 1)! = -1) (h1 : n ≠ 1)
Goal: Nat.Prime n
-- Nat.prime_iff_fac_equiv_neg_one
theorem prime_iff_fac_equiv_neg_one (h : n ≠ 1) : Prime n ↔ ((n - 1)! : ZMod n) = -1 
Arguments: {n : ℕ} (h : n ≠ 1)
Goal: Nat.Prime n ↔ ↑(n - 1)! = -1
-- Algebra.coe_norm_int
theorem Algebra.coe_norm_int : (Algebra.norm ℤ x : ℚ) = Algebra.norm ℚ (x : K) 
Arguments: {K : Type u_1} [Field K] [NumberField K] (x : 𝓞 K)
Goal: ↑((Algebra.norm ℤ) x) = (Algebra.norm ℚ) ↑x
-- Algebra.coe_trace_int
theorem Algebra.coe_trace_int : (Algebra.trace ℤ _ x : ℚ) = Algebra.trace ℚ K (x : K) 
Arguments: {K : Type u_1} [Field K] [NumberField K] (x : 𝓞 K)
Goal: ↑((Algebra.trace ℤ (𝓞 K)) x) = (Algebra.trace ℚ K) ↑x
-- RingOfIntegers.coe_norm
@[simp] lemma coe_norm [Algebra.IsSeparable K L] (x : 𝓞 L) :
  norm K x = Algebra.norm K (x : L) 
Arguments: {L : Type u_1} (K : Type u_2) [Field K] [Field L] [Algebra K L] [FiniteDimensional K L] [Algebra.IsSeparable K L] (x : 𝓞 L)
Goal: ↑((RingOfIntegers.norm K) x) = (Algebra.norm K) ↑x
-- RingOfIntegers.coe_algebraMap_norm
theorem coe_algebraMap_norm [Algebra.IsSeparable K L] (x : 𝓞 L) :
    (algebraMap (𝓞 K) (𝓞 L) (norm K x) : L) = algebraMap K L (Algebra.norm K (x : L)) 
Arguments: {L : Type u_1} (K : Type u_2) [Field K] [Field L] [Algebra K L] [FiniteDimensional K L] [Algebra.IsSeparable K L] (x : 𝓞 L)
Goal: ↑((algebraMap (𝓞 K) (𝓞 L)) ((RingOfIntegers.norm K) x)) = (algebraMap K L) ((Algebra.norm K) ↑x)
-- RingOfIntegers.algebraMap_norm_algebraMap
theorem algebraMap_norm_algebraMap [Algebra.IsSeparable K L] (x : 𝓞 K) :
    algebraMap _ K (norm K (algebraMap (𝓞 K) (𝓞 L) x)) =
      Algebra.norm K (algebraMap K L (algebraMap _ _ x)) 
Arguments: {L : Type u_1} (K : Type u_2) [Field K] [Field L] [Algebra K L] [FiniteDimensional K L] [Algebra.IsSeparable K L] (x : 𝓞 K)
Goal: (algebraMap (𝓞 K) K) ((RingOfIntegers.norm K) ((algebraMap (𝓞 K) (𝓞 L)) x)) =
  (Algebra.norm K) ((algebraMap K L) ((algebraMap (𝓞 K) K) x))