ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/NumberTheory/FrobeniusNumber.lean

full_name: FrobeniusNumber
code: /-- A natural number `n` is the **Frobenius number** of a set of natural numbers `s` if it is an
upper bound on the complement of the additive submonoid generated by `s`.
In other words, it is the largest number that can not be expressed as a sum of numbers in `s`. -/
def FrobeniusNumber (n : ℕ) (s : Set ℕ) : Prop 
goal: Prop

full_name: frobeniusNumber_pair
code: /-- The **Chicken McNugget theorem** stating that the Frobenius number
  of positive numbers `m` and `n` is `m * n - m - n`. -/
theorem frobeniusNumber_pair (cop : Coprime m n) (hm : 1 < m) (hn : 1 < n) :
    FrobeniusNumber (m * n - m - n) {m, n} 
goal: FrobeniusNumber (m * n - m - n) {m, n}
File: Mathlib/NumberTheory/ModularForms/Identities.lean

full_name: SlashInvariantForm.vAdd_width_periodic
code: theorem vAdd_width_periodic (N : ℕ) (k n : ℤ) (f : SlashInvariantForm (Gamma N) k) (z : ℍ) :
    f (((N * n) : ℝ) +ᵥ z) = f z 
goal: f (↑N * ↑n +ᵥ z) = f z

full_name: SlashInvariantForm.T_zpow_width_invariant
code: theorem T_zpow_width_invariant (N : ℕ) (k n : ℤ) (f : SlashInvariantForm (Gamma N) k) (z : ℍ) :
    f (((ModularGroup.T ^ (N * n))) • z) = f z 
goal: f (ModularGroup.T ^ (↑N * n) • z) = f z
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/Manifold.lean

full_name: mdifferentiable_jacobiTheta
code: theorem mdifferentiable_jacobiTheta : MDifferentiable 𝓘(ℂ) 𝓘(ℂ) (jacobiTheta ∘ (↑) : ℍ → ℂ) 
goal: MDifferentiable 𝓘(ℂ, ℂ) 𝓘(ℂ, ℂ) (jacobiTheta ∘ UpperHalfPlane.coe)
File: Mathlib/NumberTheory/Liouville/Residual.lean

full_name: setOf_liouville_eq_iInter_iUnion
code: theorem setOf_liouville_eq_iInter_iUnion :
    { x | Liouville x } =
      ⋂ n : ℕ, ⋃ (a : ℤ) (b : ℤ) (_ : 1 < b),
      ball ((a : ℝ) / b) (1 / (b : ℝ) ^ n) \ {(a : ℝ) / b} 
goal: {x | Liouville x} = ⋂ n, ⋃ a, ⋃ b, ⋃ (_ : 1 < b), Metric.ball (↑a / ↑b) (1 / ↑b ^ n) \ {↑a / ↑b}

full_name: IsGδ.setOf_liouville
code: theorem IsGδ.setOf_liouville : IsGδ { x | Liouville x } 
goal: IsGδ {x | Liouville x}

full_name: setOf_liouville_eq_irrational_inter_iInter_iUnion
code: theorem setOf_liouville_eq_irrational_inter_iInter_iUnion :
    { x | Liouville x } =
      { x | Irrational x } ∩ ⋂ n : ℕ, ⋃ (a : ℤ) (b : ℤ) (hb : 1 < b),
      ball (a / b) (1 / (b : ℝ) ^ n) 
goal: {x | Liouville x} = {x | Irrational x} ∩ ⋂ n, ⋃ a, ⋃ b, ⋃ (_ : 1 < b), Metric.ball (↑a / ↑b) (1 / ↑b ^ n)

full_name: eventually_residual_liouville
code: /-- The set of Liouville numbers is a residual set. -/
theorem eventually_residual_liouville : ∀ᶠ x in residual ℝ, Liouville x 
goal: ∀ᶠ (x : ℝ) in residual ℝ, Liouville x

full_name: dense_liouville
code: /-- The set of Liouville numbers in dense. -/
theorem dense_liouville : Dense { x | Liouville x } 
goal: Dense {x | Liouville x}
File: Mathlib/NumberTheory/SumPrimeReciprocals.lean

full_name: Nat.roughNumbersUpTo_card_le'
code: /-- The cardinality of the set of `k`-rough numbers `≤ N` is bounded by `N` times the sum
of `1/p` over the primes `k ≤ p ≤ N`. -/
-- This needs `Mathlib.Analysis.RCLike.Basic`, so we put it here
-- instead of in `Mathlib.NumberTheory.SmoothNumbers`.
lemma Nat.roughNumbersUpTo_card_le' (N k : ℕ) :
    (roughNumbersUpTo N k).card ≤
      N * (N.succ.primesBelow \ k.primesBelow).sum (fun p ↦ (1 : ℝ) / p) 
goal: ↑(N.roughNumbersUpTo k).card ≤ ↑N * ∑ p ∈ N.succ.primesBelow \ k.primesBelow, 1 / ↑p

full_name: one_half_le_sum_primes_ge_one_div
code: /-- The sum over primes `k ≤ p ≤ 4^(π(k-1)+1)` over `1/p` (as a real number) is at least `1/2`. -/
lemma one_half_le_sum_primes_ge_one_div (k : ℕ) :
    1 / 2 ≤ ∑ p ∈ (4 ^ (k.primesBelow.card + 1)).succ.primesBelow \ k.primesBelow,
      (1 / p : ℝ) 
goal: 1 / 2 ≤ ∑ p ∈ (4 ^ (k.primesBelow.card + 1)).succ.primesBelow \ k.primesBelow, 1 / ↑p

full_name: not_summable_one_div_on_primes
code: /-- The sum over the reciprocals of the primes diverges. -/
theorem not_summable_one_div_on_primes :
    ¬ Summable (indicator {p | p.Prime} (fun n : ℕ ↦ (1 : ℝ) / n)) 
goal: ¬Summable ({p | Nat.Prime p}.indicator fun n => 1 / ↑n)

full_name: Nat.Primes.not_summable_one_div
code: /-- The sum over the reciprocals of the primes diverges. -/
theorem Nat.Primes.not_summable_one_div : ¬ Summable (fun p : Nat.Primes ↦ (1 / p : ℝ)) 
goal: ¬Summable fun p => 1 / ↑↑p

full_name: Nat.Primes.summable_rpow
code: /-- The series over `p^r` for primes `p` converges if and only if `r < -1`. -/
theorem Nat.Primes.summable_rpow {r : ℝ} :
    Summable (fun p : Nat.Primes ↦ (p : ℝ) ^ r) ↔ r < -1 
goal: (Summable fun p => ↑↑p ^ r) ↔ r < -1
File: Mathlib/NumberTheory/ModularForms/EisensteinSeries/Basic.lean

full_name: ModularForm.eisensteinSeries_MF
code: /-- This defines Eisenstein series as modular forms of weight `k`, level `Γ(N)` and congruence
condition given by `a: Fin 2 → ZMod N`. -/
def eisensteinSeries_MF {k : ℤ} {N : ℕ+} (hk : 3 ≤ k) (a : Fin 2 → ZMod N) :
    ModularForm (Gamma N) k 
goal: ModularForm (CongruenceSubgroup.Gamma ↑N) k
File: Mathlib/NumberTheory/DirichletCharacter/GaussSum.lean

full_name: gaussSum_aux_of_mulShift
code: lemma gaussSum_aux_of_mulShift (χ : DirichletCharacter R N) {d : ℕ}
    (hd : d ∣ N) (he : e.mulShift d = 1) {u : (ZMod N)ˣ} (hu : ZMod.unitsMap hd u = 1) :
    χ u * gaussSum χ e = gaussSum χ e 
goal: χ ↑u * gaussSum χ e = gaussSum χ e

full_name: factorsThrough_of_gaussSum_ne_zero
code: /-- If `gaussSum χ e ≠ 0`, and `d` is such that `e.mulShift d = 1`, then `χ` must factor through
`d`. (This will be used to show that Gauss sums vanish when `χ` is primitive and `e` is not.) -/
lemma factorsThrough_of_gaussSum_ne_zero [IsDomain R] {χ : DirichletCharacter R N} {d : ℕ}
    (hd : d ∣ N) (he : e.mulShift d = 1) (h_ne : gaussSum χ e ≠ 0) :
    χ.FactorsThrough d 
goal: χ.FactorsThrough d

full_name: gaussSum_eq_zero_of_isPrimitive_of_not_isPrimitive
code: /-- If `χ` is primitive, but `e` is not, then `gaussSum χ e = 0`. -/
lemma gaussSum_eq_zero_of_isPrimitive_of_not_isPrimitive [IsDomain R]
    {χ : DirichletCharacter R N} (hχ : IsPrimitive χ) (he : ¬IsPrimitive e) :
    gaussSum χ e = 0 
goal: gaussSum χ e = 0

full_name: gaussSum_mulShift_of_isPrimitive
code: /-- If `χ` is a primitive character, then the function `a ↦ gaussSum χ (e.mulShift a)`, for any
fixed additive character `e`, is a constant multiple of `χ⁻¹`. -/
lemma gaussSum_mulShift_of_isPrimitive [IsDomain R] {χ : DirichletCharacter R N}
    (hχ : IsPrimitive χ) (a : ZMod N) :
    gaussSum χ (e.mulShift a) = χ⁻¹ a * gaussSum χ e 
goal: gaussSum χ (e.mulShift a) = χ⁻¹ a * gaussSum χ e
File: Mathlib/NumberTheory/ModularForms/EisensteinSeries/IsBoundedAtImInfty.lean

full_name: EisensteinSeries.summable_norm_eisSummand
code: lemma summable_norm_eisSummand {k : ℤ} (hk : 3 ≤ k) (z : ℍ) :
    Summable fun (x : Fin 2 → ℤ) ↦ ‖(eisSummand k x z)‖ 
goal: Summable fun x => ‖EisensteinSeries.eisSummand k x z‖

full_name: EisensteinSeries.abs_le_tsum_abs
code: /-- The absolute value of the restricted sum is less than the full sum of the absolute values. -/
lemma abs_le_tsum_abs (N : ℕ) (a : Fin 2 → ZMod N) (k : ℤ) (hk : 3 ≤ k) (z : ℍ) :
    Complex.abs (eisensteinSeries a k z) ≤ ∑' (x : Fin 2 → ℤ), Complex.abs (eisSummand k x z) 
goal: Complex.abs (eisensteinSeries a k z) ≤ ∑' (x : Fin 2 → ℤ), Complex.abs (EisensteinSeries.eisSummand k x z)

full_name: EisensteinSeries.isBoundedAtImInfty_eisensteinSeries_SIF
code: /-- Eisenstein series are bounded at infinity. -/
theorem isBoundedAtImInfty_eisensteinSeries_SIF {N : ℕ+} (a : Fin 2 → ZMod N) {k : ℤ} (hk : 3 ≤ k)
    (A : SL(2, ℤ)) : IsBoundedAtImInfty ((eisensteinSeries_SIF a k).toFun ∣[k] A) 
goal: UpperHalfPlane.IsBoundedAtImInfty ((EisensteinSeries.eisensteinSeries_SIF a k).toFun ∣[k] A)
File: Mathlib/NumberTheory/ModularForms/EisensteinSeries/MDifferentiable.lean

full_name: EisensteinSeries.div_linear_zpow_differentiableOn
code: /-- Auxilary lemma showing that for any `k : ℤ` the function `z → 1/(c*z+d)^k` is
differentiable on `{z : ℂ | 0 < z.im}`. -/
lemma div_linear_zpow_differentiableOn (k : ℤ) (a : Fin 2 → ℤ) :
    DifferentiableOn ℂ (fun z : ℂ => (a 0 * z + a 1) ^ (-k)) {z : ℂ | 0 < z.im} 
goal: DifferentiableOn ℂ (fun z => (↑(a 0) * z + ↑(a 1)) ^ (-k)) {z | 0 < z.im}

full_name: EisensteinSeries.eisSummand_extension_differentiableOn
code: /-- Auxilary lemma showing that for any `k : ℤ` and `(a : Fin 2 → ℤ)`
the extension of `eisSummand` is differentiable on `{z : ℂ | 0 < z.im}`.-/
lemma eisSummand_extension_differentiableOn (k : ℤ) (a : Fin 2 → ℤ) :
    DifferentiableOn ℂ (↑ₕeisSummand k a) {z : ℂ | 0 < z.im} 
goal: DifferentiableOn ℂ (EisensteinSeries.eisSummand k a ∘ ↑UpperHalfPlane.ofComplex) {z | 0 < z.im}

full_name: EisensteinSeries.eisensteinSeries_SIF_MDifferentiable
code: /-- Eisenstein series are MDifferentiable (i.e. holomorphic functions from `ℍ → ℂ`). -/
theorem eisensteinSeries_SIF_MDifferentiable {k : ℤ} {N : ℕ} (hk : 3 ≤ k) (a : Fin 2 → ZMod N) :
    MDifferentiable 𝓘(ℂ) 𝓘(ℂ) (eisensteinSeries_SIF a k) 
goal: MDifferentiable 𝓘(ℂ, ℂ) 𝓘(ℂ, ℂ) ⇑(EisensteinSeries.eisensteinSeries_SIF a k)
File: Mathlib/NumberTheory/Liouville/Measure.lean

full_name: setOf_liouvilleWith_subset_aux
code: theorem setOf_liouvilleWith_subset_aux :
    { x : ℝ | ∃ p > 2, LiouvilleWith p x } ⊆
      ⋃ m : ℤ, (· + (m : ℝ)) ⁻¹' ⋃ n > (0 : ℕ),
        { x : ℝ | ∃ᶠ b : ℕ in atTop, ∃ a ∈ Finset.Icc (0 : ℤ) b,
          |x - (a : ℤ) / b| < 1 / (b : ℝ) ^ (2 + 1 / n : ℝ) } 
goal: {x | ∃ p > 2, LiouvilleWith p x} ⊆
  ⋃ m,
    (fun x => x + ↑m) ⁻¹'
      ⋃ n, ⋃ (_ : n > 0), {x | ∃ᶠ (b : ℕ) in Filter.atTop, ∃ a ∈ Finset.Icc 0 ↑b, |x - ↑a / ↑b| < 1 / ↑b ^ (2 + 1 / ↑n)}

full_name: volume_iUnion_setOf_liouvilleWith
code: /-- The set of numbers satisfying the Liouville condition with some exponent `p > 2` has Lebesgue
measure zero. -/
@[simp]
theorem volume_iUnion_setOf_liouvilleWith :
    volume (⋃ (p : ℝ) (_hp : 2 < p), { x : ℝ | LiouvilleWith p x }) = 0 
goal: MeasureTheory.volume (⋃ p, ⋃ (_ : 2 < p), {x | LiouvilleWith p x}) = 0

full_name: ae_not_liouvilleWith
code: theorem ae_not_liouvilleWith : ∀ᵐ x, ∀ p > (2 : ℝ), ¬LiouvilleWith p x 
goal: ∀ᵐ (x : ℝ), ∀ p > 2, ¬LiouvilleWith p x

full_name: ae_not_liouville
code: theorem ae_not_liouville : ∀ᵐ x, ¬Liouville x 
goal: ∀ᵐ (x : ℝ), ¬Liouville x

full_name: volume_setOf_liouville
code: /-- The set of Liouville numbers has Lebesgue measure zero. -/
@[simp]
theorem volume_setOf_liouville : volume { x : ℝ | Liouville x } = 0 
goal: MeasureTheory.volume {x | Liouville x} = 0

full_name: Real.disjoint_residual_ae
code: /-- The filters `residual ℝ` and `ae volume` are disjoint. This means that there exists a residual
set of Lebesgue measure zero (e.g., the set of Liouville numbers). -/
theorem Real.disjoint_residual_ae : Disjoint (residual ℝ) (ae volume) 
goal: Disjoint (residual ℝ) (MeasureTheory.ae MeasureTheory.volume)
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/OneVariable.lean

full_name: jacobiTheta
code: /-- Jacobi's one-variable theta function `∑' (n : ℤ), exp (π * I * n ^ 2 * τ)`. -/
noncomputable def jacobiTheta (τ : ℂ) : ℂ 
goal: ℂ

full_name: jacobiTheta_eq_jacobiTheta₂
code: lemma jacobiTheta_eq_jacobiTheta₂ (τ : ℂ) : jacobiTheta τ = jacobiTheta₂ 0 τ 
goal: jacobiTheta τ = jacobiTheta₂ 0 τ

full_name: jacobiTheta_two_add
code: theorem jacobiTheta_two_add (τ : ℂ) : jacobiTheta (2 + τ) = jacobiTheta τ 
goal: jacobiTheta (2 + τ) = jacobiTheta τ

full_name: jacobiTheta_T_sq_smul
code: theorem jacobiTheta_T_sq_smul (τ : ℍ) : jacobiTheta (ModularGroup.T ^ 2 • τ :) = jacobiTheta τ 
goal: jacobiTheta ↑(ModularGroup.T ^ 2 • τ) = jacobiTheta ↑τ

full_name: jacobiTheta_S_smul
code: theorem jacobiTheta_S_smul (τ : ℍ) :
    jacobiTheta ↑(ModularGroup.S • τ) = (-I * τ) ^ (1 / 2 : ℂ) * jacobiTheta τ 
goal: jacobiTheta ↑(ModularGroup.S • τ) = (-Complex.I * ↑τ) ^ (1 / 2) * jacobiTheta ↑τ

full_name: norm_exp_mul_sq_le
code: theorem norm_exp_mul_sq_le {τ : ℂ} (hτ : 0 < τ.im) (n : ℤ) :
    ‖cexp (π * I * (n : ℂ) ^ 2 * τ)‖ ≤ rexp (-π * τ.im) ^ n.natAbs 
goal: ‖cexp (↑π * Complex.I * ↑n ^ 2 * τ)‖ ≤ rexp (-π * τ.im) ^ n.natAbs

full_name: hasSum_nat_jacobiTheta
code: theorem hasSum_nat_jacobiTheta {τ : ℂ} (hτ : 0 < im τ) :
    HasSum (fun n : ℕ => cexp (π * I * ((n : ℂ) + 1) ^ 2 * τ)) ((jacobiTheta τ - 1) / 2) 
goal: HasSum (fun n => cexp (↑π * Complex.I * (↑n + 1) ^ 2 * τ)) ((jacobiTheta τ - 1) / 2)

full_name: jacobiTheta_eq_tsum_nat
code: theorem jacobiTheta_eq_tsum_nat {τ : ℂ} (hτ : 0 < im τ) :
    jacobiTheta τ = ↑1 + ↑2 * ∑' n : ℕ, cexp (π * I * ((n : ℂ) + 1) ^ 2 * τ) 
goal: jacobiTheta τ = 1 + 2 * ∑' (n : ℕ), cexp (↑π * Complex.I * (↑n + 1) ^ 2 * τ)

full_name: norm_jacobiTheta_sub_one_le
code: /-- An explicit upper bound for `‖jacobiTheta τ - 1‖`. -/
theorem norm_jacobiTheta_sub_one_le {τ : ℂ} (hτ : 0 < im τ) :
    ‖jacobiTheta τ - 1‖ ≤ 2 / (1 - rexp (-π * τ.im)) * rexp (-π * τ.im) 
goal: ‖jacobiTheta τ - 1‖ ≤ 2 / (1 - rexp (-π * τ.im)) * rexp (-π * τ.im)

full_name: isBigO_at_im_infty_jacobiTheta_sub_one
code: /-- The norm of `jacobiTheta τ - 1` decays exponentially as `im τ → ∞`. -/
theorem isBigO_at_im_infty_jacobiTheta_sub_one :
    (fun τ => jacobiTheta τ - 1) =O[comap im atTop] fun τ => rexp (-π * τ.im) 
goal: (fun τ => jacobiTheta τ - 1) =O[Filter.comap Complex.im Filter.atTop] fun τ => rexp (-π * τ.im)

full_name: differentiableAt_jacobiTheta
code: theorem differentiableAt_jacobiTheta {τ : ℂ} (hτ : 0 < im τ) :
    DifferentiableAt ℂ jacobiTheta τ 
goal: DifferentiableAt ℂ jacobiTheta τ

full_name: continuousAt_jacobiTheta
code: theorem continuousAt_jacobiTheta {τ : ℂ} (hτ : 0 < im τ) : ContinuousAt jacobiTheta τ 
goal: ContinuousAt jacobiTheta τ
File: Mathlib/NumberTheory/LegendreSymbol/QuadraticReciprocity.lean

full_name: legendreSym.at_two
code: /-- `legendreSym p 2` is given by `χ₈ p`. -/
theorem at_two : legendreSym p 2 = χ₈ p 
goal: legendreSym p 2 = ZMod.χ₈ ↑p

full_name: legendreSym.at_neg_two
code: /-- `legendreSym p (-2)` is given by `χ₈' p`. -/
theorem at_neg_two : legendreSym p (-2) = χ₈' p 
goal: legendreSym p (-2) = ZMod.χ₈' ↑p

full_name: ZMod.exists_sq_eq_two_iff
code: /-- `2` is a square modulo an odd prime `p` iff `p` is congruent to `1` or `7` mod `8`. -/
theorem exists_sq_eq_two_iff : IsSquare (2 : ZMod p) ↔ p % 8 = 1 ∨ p % 8 = 7 
goal: IsSquare 2 ↔ p % 8 = 1 ∨ p % 8 = 7

full_name: ZMod.exists_sq_eq_neg_two_iff
code: /-- `-2` is a square modulo an odd prime `p` iff `p` is congruent to `1` or `3` mod `8`. -/
theorem exists_sq_eq_neg_two_iff : IsSquare (-2 : ZMod p) ↔ p % 8 = 1 ∨ p % 8 = 3 
goal: IsSquare (-2) ↔ p % 8 = 1 ∨ p % 8 = 3

full_name: legendreSym.quadratic_reciprocity
code: /-- **The Law of Quadratic Reciprocity**: if `p` and `q` are distinct odd primes, then
`(q / p) * (p / q) = (-1)^((p-1)(q-1)/4)`. -/
theorem quadratic_reciprocity (hp : p ≠ 2) (hq : q ≠ 2) (hpq : p ≠ q) :
    legendreSym q p * legendreSym p q = (-1) ^ (p / 2 * (q / 2)) 
goal: legendreSym q ↑p * legendreSym p ↑q = (-1) ^ (p / 2 * (q / 2))

full_name: legendreSym.quadratic_reciprocity'
code: /-- The Law of Quadratic Reciprocity: if `p` and `q` are odd primes, then
`(q / p) = (-1)^((p-1)(q-1)/4) * (p / q)`. -/
theorem quadratic_reciprocity' (hp : p ≠ 2) (hq : q ≠ 2) :
    legendreSym q p = (-1) ^ (p / 2 * (q / 2)) * legendreSym p q 
goal: legendreSym q ↑p = (-1) ^ (p / 2 * (q / 2)) * legendreSym p ↑q

full_name: legendreSym.quadratic_reciprocity_one_mod_four
code: /-- The Law of Quadratic Reciprocity: if `p` and `q` are odd primes and `p % 4 = 1`,
then `(q / p) = (p / q)`. -/
theorem quadratic_reciprocity_one_mod_four (hp : p % 4 = 1) (hq : q ≠ 2) :
    legendreSym q p = legendreSym p q 
goal: legendreSym q ↑p = legendreSym p ↑q

full_name: legendreSym.quadratic_reciprocity_three_mod_four
code: /-- The Law of Quadratic Reciprocity: if `p` and `q` are primes that are both congruent
to `3` mod `4`, then `(q / p) = -(p / q)`. -/
theorem quadratic_reciprocity_three_mod_four (hp : p % 4 = 3) (hq : q % 4 = 3) :
    legendreSym q p = -legendreSym p q 
goal: legendreSym q ↑p = -legendreSym p ↑q

full_name: ZMod.exists_sq_eq_prime_iff_of_mod_four_eq_one
code: /-- If `p` and `q` are odd primes and `p % 4 = 1`, then `q` is a square mod `p` iff
`p` is a square mod `q`. -/
theorem exists_sq_eq_prime_iff_of_mod_four_eq_one (hp1 : p % 4 = 1) (hq1 : q ≠ 2) :
    IsSquare (q : ZMod p) ↔ IsSquare (p : ZMod q) 
goal: IsSquare ↑q ↔ IsSquare ↑p

full_name: ZMod.exists_sq_eq_prime_iff_of_mod_four_eq_three
code: /-- If `p` and `q` are distinct primes that are both congruent to `3` mod `4`, then `q` is
a square mod `p` iff `p` is a nonsquare mod `q`. -/
theorem exists_sq_eq_prime_iff_of_mod_four_eq_three (hp3 : p % 4 = 3) (hq3 : q % 4 = 3)
    (hpq : p ≠ q) : IsSquare (q : ZMod p) ↔ ¬IsSquare (p : ZMod q) 
goal: IsSquare ↑q ↔ ¬IsSquare ↑p
File: Mathlib/NumberTheory/Liouville/Basic.lean

full_name: Liouville
code: /-- A Liouville number is a real number `x` such that for every natural number `n`, there exist
`a, b ∈ ℤ` with `1 < b` such that `0 < |x - a/b| < 1/bⁿ`.
In the implementation, the condition `x ≠ a/b` replaces the traditional equivalent `0 < |x - a/b|`.
-/
def Liouville (x : ℝ) 
goal: Prop

full_name: Liouville.irrational
code: protected theorem irrational {x : ℝ} (h : Liouville x) : Irrational x 
goal: Irrational x

full_name: Liouville.exists_one_le_pow_mul_dist
code: /-- Let `Z, N` be types, let `R` be a metric space, let `α : R` be a point and let
`j : Z → N → R` be a function.  We aim to estimate how close we can get to `α`, while staying
in the image of `j`.  The points `j z a` of `R` in the image of `j` come with a "cost" equal to
`d a`.  As we get closer to `α` while staying in the image of `j`, we are interested in bounding
the quantity `d a * dist α (j z a)` from below by a strictly positive amount `1 / A`: the intuition
is that approximating well `α` with the points in the image of `j` should come at a high cost.  The
hypotheses on the function `f : R → R` provide us with sufficient conditions to ensure our goal.
The first hypothesis is that `f` is Lipschitz at `α`: this yields a bound on the distance.
The second hypothesis is specific to the Liouville argument and provides the missing bound
involving the cost function `d`.

This lemma collects the properties used in the proof of `exists_pos_real_of_irrational_root`.
It is stated in more general form than needed: in the intended application, `Z = ℤ`, `N = ℕ`,
`R = ℝ`, `d a = (a + 1) ^ f.nat_degree`, `j z a = z / (a + 1)`, `f ∈ ℤ[x]`, `α` is an irrational
root of `f`, `ε` is small, `M` is a bound on the Lipschitz constant of `f` near `α`, `n` is
the degree of the polynomial `f`.
-/
theorem exists_one_le_pow_mul_dist {Z N R : Type*} [PseudoMetricSpace R] {d : N → ℝ}
    {j : Z → N → R} {f : R → R} {α : R} {ε M : ℝ}
    -- denominators are positive
    (d0 : ∀ a : N, 1 ≤ d a)
    (e0 : 0 < ε)
    -- function is Lipschitz at α
    (B : ∀ ⦃y : R⦄, y ∈ closedBall α ε → dist (f α) (f y) ≤ dist α y * M)
    -- clear denominators
    (L : ∀ ⦃z : Z⦄, ∀ ⦃a : N⦄, j z a ∈ closedBall α ε → 1 ≤ d a * dist (f α) (f (j z a))) :
    ∃ A : ℝ, 0 < A ∧ ∀ z : Z, ∀ a : N, 1 ≤ d a * (dist α (j z a) * A) 
goal: ∃ A, 0 < A ∧ ∀ (z : Z) (a : N), 1 ≤ d a * (dist α (j z a) * A)

full_name: Liouville.exists_pos_real_of_irrational_root
code: theorem exists_pos_real_of_irrational_root {α : ℝ} (ha : Irrational α) {f : ℤ[X]} (f0 : f ≠ 0)
    (fa : eval α (map (algebraMap ℤ ℝ) f) = 0) :
    ∃ A : ℝ, 0 < A ∧ ∀ a : ℤ, ∀ b : ℕ,
      (1 : ℝ) ≤ ((b : ℝ) + 1) ^ f.natDegree * (|α - a / (b + 1)| * A) 
goal: ∃ A, 0 < A ∧ ∀ (a : ℤ) (b : ℕ), 1 ≤ (↑b + 1) ^ f.natDegree * (|α - ↑a / (↑b + 1)| * A)

full_name: Liouville.transcendental
code: /-- **Liouville's Theorem** -/
protected theorem transcendental {x : ℝ} (lx : Liouville x) : Transcendental ℤ x 
goal: Transcendental ℤ x
File: Mathlib/NumberTheory/Primorial.lean

full_name: primorial
code: /-- The primorial `n#` of `n` is the product of the primes less than or equal to `n`.
-/
def primorial (n : ℕ) : ℕ 
goal: ℕ

full_name: _aux_Mathlib_NumberTheory_Primorial___unexpand_primorial_1
code: local notation x "#" => primorial x
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_NumberTheory_Primorial___macroRules_term_#_1»
code: local notation x "#" => primorial x
goal: Lean.Macro

full_name: primorial_pos
code: theorem primorial_pos (n : ℕ) : 0 < n# 
goal: 0 < n#

full_name: primorial_succ
code: theorem primorial_succ {n : ℕ} (hn1 : n ≠ 1) (hn : Odd n) : (n + 1)# = n# 
goal: (n + 1)# = n#

full_name: primorial_add
code: theorem primorial_add (m n : ℕ) :
    (m + n)# = m# * ∏ p ∈ filter Nat.Prime (Ico (m + 1) (m + n + 1)), p 
goal: (m + n)# = m# * ∏ p ∈ Finset.filter Nat.Prime (Finset.Ico (m + 1) (m + n + 1)), p

full_name: primorial_add_dvd
code: theorem primorial_add_dvd {m n : ℕ} (h : n ≤ m) : (m + n)# ∣ m# * choose (m + n) m 
goal: (m + n)# ∣ m# * (m + n).choose m

full_name: primorial_add_le
code: theorem primorial_add_le {m n : ℕ} (h : n ≤ m) : (m + n)# ≤ m# * choose (m + n) m 
goal: (m + n)# ≤ m# * (m + n).choose m

full_name: primorial_le_4_pow
code: theorem primorial_le_4_pow (n : ℕ) : n# ≤ 4 ^ n 
goal: n# ≤ 4 ^ n
File: Mathlib/NumberTheory/LegendreSymbol/QuadraticChar/GaussSum.lean

full_name: quadraticChar_two
code: /-- The value of the quadratic character at `2` -/
theorem quadraticChar_two [DecidableEq F] (hF : ringChar F ≠ 2) :
    quadraticChar F 2 = χ₈ (Fintype.card F) 
goal: (quadraticChar F) 2 = ZMod.χ₈ ↑(Fintype.card F)

full_name: FiniteField.isSquare_two_iff
code: /-- `2` is a square in `F` iff `#F` is not congruent to `3` or `5` mod `8`. -/
theorem FiniteField.isSquare_two_iff :
    IsSquare (2 : F) ↔ Fintype.card F % 8 ≠ 3 ∧ Fintype.card F % 8 ≠ 5 
goal: IsSquare 2 ↔ Fintype.card F % 8 ≠ 3 ∧ Fintype.card F % 8 ≠ 5

full_name: quadraticChar_neg_two
code: /-- The value of the quadratic character at `-2` -/
theorem quadraticChar_neg_two [DecidableEq F] (hF : ringChar F ≠ 2) :
    quadraticChar F (-2) = χ₈' (Fintype.card F) 
goal: (quadraticChar F) (-2) = ZMod.χ₈' ↑(Fintype.card F)

full_name: FiniteField.isSquare_neg_two_iff
code: /-- `-2` is a square in `F` iff `#F` is not congruent to `5` or `7` mod `8`. -/
theorem FiniteField.isSquare_neg_two_iff :
    IsSquare (-2 : F) ↔ Fintype.card F % 8 ≠ 5 ∧ Fintype.card F % 8 ≠ 7 
goal: IsSquare (-2) ↔ Fintype.card F % 8 ≠ 5 ∧ Fintype.card F % 8 ≠ 7

full_name: quadraticChar_card_card
code: /-- The relation between the values of the quadratic character of one field `F` at the
cardinality of another field `F'` and of the quadratic character of `F'` at the cardinality
of `F`. -/
theorem quadraticChar_card_card [DecidableEq F] (hF : ringChar F ≠ 2) {F' : Type*} [Field F']
    [Fintype F'] [DecidableEq F'] (hF' : ringChar F' ≠ 2) (h : ringChar F' ≠ ringChar F) :
    quadraticChar F (Fintype.card F') =
    quadraticChar F' (quadraticChar F (-1) * Fintype.card F) 
goal: (quadraticChar F) ↑(Fintype.card F') = (quadraticChar F') (↑((quadraticChar F) (-1)) * ↑(Fintype.card F))

full_name: quadraticChar_odd_prime
code: /-- The value of the quadratic character at an odd prime `p` different from `ringChar F`. -/
theorem quadraticChar_odd_prime [DecidableEq F] (hF : ringChar F ≠ 2) {p : ℕ} [Fact p.Prime]
    (hp₁ : p ≠ 2) (hp₂ : ringChar F ≠ p) :
    quadraticChar F p = quadraticChar (ZMod p) (χ₄ (Fintype.card F) * Fintype.card F) 
goal: (quadraticChar F) ↑p = (quadraticChar (ZMod p)) (↑(ZMod.χ₄ ↑(Fintype.card F)) * ↑(Fintype.card F))

full_name: FiniteField.isSquare_odd_prime_iff
code: /-- An odd prime `p` is a square in `F` iff the quadratic character of `ZMod p` does not
take the value `-1` on `χ₄#F * #F`. -/
theorem FiniteField.isSquare_odd_prime_iff (hF : ringChar F ≠ 2) {p : ℕ} [Fact p.Prime]
    (hp : p ≠ 2) :
    IsSquare (p : F) ↔ quadraticChar (ZMod p) (χ₄ (Fintype.card F) * Fintype.card F) ≠ -1 
goal: IsSquare ↑p ↔ (quadraticChar (ZMod p)) (↑(ZMod.χ₄ ↑(Fintype.card F)) * ↑(Fintype.card F)) ≠ -1