ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Nat.image_div_divisors_eq_divisors
@[simp]
theorem image_div_divisors_eq_divisors (n : ℕ) :
    image (fun x : ℕ => n / x) n.divisors = n.divisors 
Arguments: (n : ℕ)
Goal: Finset.image (fun x => n / x) n.divisors = n.divisors
-- Nat.prod_div_divisors
@[to_additive sum_div_divisors]
theorem prod_div_divisors {α : Type*} [CommMonoid α] (n : ℕ) (f : ℕ → α) :
    (∏ d ∈ n.divisors, f (n / d)) = n.divisors.prod f 
Arguments: {α : Type u_1} [CommMonoid α] (n : ℕ) (f : ℕ → α)
Goal: ∏ d ∈ n.divisors, f (n / d) = n.divisors.prod f
-- Nat.sum_div_divisors
@[to_additive sum_div_divisors]
theorem prod_div_divisors {α : Type*} [CommMonoid α] (n : ℕ) (f : ℕ → α) :
    (∏ d ∈ n.divisors, f (n / d)) = n.divisors.prod f 
Arguments: {α : Type u_1} [AddCommMonoid α] (n : ℕ) (f : ℕ → α)
Goal: ∑ d ∈ n.divisors, f (n / d) = n.divisors.sum f
-- Bertrand.real_main_inequality
theorem real_main_inequality {x : ℝ} (x_large : (512 : ℝ) ≤ x) :
    x * (2 * x) ^ √(2 * x) * 4 ^ (2 * x / 3) ≤ 4 ^ x 
Arguments: {x : ℝ} (x_large : 512 ≤ x)
Goal: x * (2 * x) ^ √(2 * x) * 4 ^ (2 * x / 3) ≤ 4 ^ x
-- bertrand_main_inequality
theorem bertrand_main_inequality {n : ℕ} (n_large : 512 ≤ n) :
    n * (2 * n) ^ sqrt (2 * n) * 4 ^ (2 * n / 3) ≤ 4 ^ n 
Arguments: {n : ℕ} (n_large : 512 ≤ n)
Goal: n * (2 * n) ^ (2 * n).sqrt * 4 ^ (2 * n / 3) ≤ 4 ^ n
-- centralBinom_factorization_small
theorem centralBinom_factorization_small (n : ℕ) (n_large : 2 < n)
    (no_prime : ¬∃ p : ℕ, p.Prime ∧ n < p ∧ p ≤ 2 * n) :
    centralBinom n = ∏ p ∈ Finset.range (2 * n / 3 + 1), p ^ (centralBinom n).factorization p 
Arguments: (n : ℕ) (n_large : 2 < n) (no_prime : ¬∃ p, Nat.Prime p ∧ n < p ∧ p ≤ 2 * n)
Goal: n.centralBinom = ∏ p ∈ Finset.range (2 * n / 3 + 1), p ^ n.centralBinom.factorization p
-- centralBinom_le_of_no_bertrand_prime
theorem centralBinom_le_of_no_bertrand_prime (n : ℕ) (n_large : 2 < n)
    (no_prime : ¬∃ p : ℕ, Nat.Prime p ∧ n < p ∧ p ≤ 2 * n) :
    centralBinom n ≤ (2 * n) ^ sqrt (2 * n) * 4 ^ (2 * n / 3) 
Arguments: (n : ℕ) (n_large : 2 < n) (no_prime : ¬∃ p, Nat.Prime p ∧ n < p ∧ p ≤ 2 * n)
Goal: n.centralBinom ≤ (2 * n) ^ (2 * n).sqrt * 4 ^ (2 * n / 3)
-- Nat.exists_prime_lt_and_le_two_mul_eventually
theorem exists_prime_lt_and_le_two_mul_eventually (n : ℕ) (n_large : 512 ≤ n) :
    ∃ p : ℕ, p.Prime ∧ n < p ∧ p ≤ 2 * n 
Arguments: (n : ℕ) (n_large : 512 ≤ n)
Goal: ∃ p, Nat.Prime p ∧ n < p ∧ p ≤ 2 * n
-- Nat.exists_prime_lt_and_le_two_mul_succ
theorem exists_prime_lt_and_le_two_mul_succ {n} (q) {p : ℕ} (prime_p : Nat.Prime p)
    (covering : p ≤ 2 * q) (H : n < q → ∃ p : ℕ, p.Prime ∧ n < p ∧ p ≤ 2 * n) (hn : n < p) :
    ∃ p : ℕ, p.Prime ∧ n < p ∧ p ≤ 2 * n 
Arguments: {n : ℕ} (q : ℕ) {p : ℕ} (prime_p : Nat.Prime p) (covering : p ≤ 2 * q) (H : n < q → ∃ p, Nat.Prime p ∧ n < p ∧ p ≤ 2 * n) (hn : n < p)
Goal: ∃ p, Nat.Prime p ∧ n < p ∧ p ≤ 2 * n
-- Nat.exists_prime_lt_and_le_two_mul
theorem exists_prime_lt_and_le_two_mul (n : ℕ) (hn0 : n ≠ 0) :
    ∃ p, Nat.Prime p ∧ n < p ∧ p ≤ 2 * n 
Arguments: (n : ℕ) (hn0 : n ≠ 0)
Goal: ∃ p, Nat.Prime p ∧ n < p ∧ p ≤ 2 * n
-- Rat.RingOfIntegers.isUnit_iff
theorem Rat.RingOfIntegers.isUnit_iff {x : 𝓞 ℚ} : IsUnit x ↔ (x : ℚ) = 1 ∨ (x : ℚ) = -1 
Arguments: {x : 𝓞 ℚ}
Goal: IsUnit x ↔ ↑x = 1 ∨ ↑x = -1
-- NumberField.isUnit_iff_norm
theorem NumberField.isUnit_iff_norm [NumberField K] {x : 𝓞 K} :
    IsUnit x ↔ |(RingOfIntegers.norm ℚ x : ℚ)| = 1 
Arguments: {K : Type u_1} [Field K] [NumberField K] {x : 𝓞 K}
Goal: IsUnit x ↔ |↑((RingOfIntegers.norm ℚ) x)| = 1
-- NumberField.Units.coe_injective
theorem coe_injective : Function.Injective ((↑) : (𝓞 K)ˣ → K) 
Arguments: (K : Type u_1) [Field K]
Goal: Function.Injective fun x => (algebraMap (𝓞 K) K) ↑x
-- NumberField.Units.coe_coe
theorem coe_coe (u : (𝓞 K)ˣ) : ((u : 𝓞 K) : K) = (u : K) 
Arguments: {K : Type u_1} [Field K] (u : (𝓞 K)ˣ)
Goal: ↑↑u = (algebraMap (𝓞 K) K) ↑u
-- NumberField.Units.coe_mul
theorem coe_mul (x y : (𝓞 K)ˣ) : ((x * y : (𝓞 K)ˣ) : K) = (x : K) * (y : K) 
Arguments: {K : Type u_1} [Field K] (x y : (𝓞 K)ˣ)
Goal: (algebraMap (𝓞 K) K) ↑(x * y) = (algebraMap (𝓞 K) K) ↑x * (algebraMap (𝓞 K) K) ↑y
-- NumberField.Units.coe_pow
theorem coe_pow (x : (𝓞 K)ˣ) (n : ℕ) : ((x ^ n : (𝓞 K)ˣ) : K) = (x : K) ^ n 
Arguments: {K : Type u_1} [Field K] (x : (𝓞 K)ˣ) (n : ℕ)
Goal: (algebraMap (𝓞 K) K) ↑(x ^ n) = (algebraMap (𝓞 K) K) ↑x ^ n
-- NumberField.Units.coe_zpow
theorem coe_zpow (x : (𝓞 K)ˣ) (n : ℤ) : (↑(x ^ n) : K) = (x : K) ^ n 
Arguments: {K : Type u_1} [Field K] (x : (𝓞 K)ˣ) (n : ℤ)
Goal: (algebraMap (𝓞 K) K) ↑(x ^ n) = (algebraMap (𝓞 K) K) ↑x ^ n
-- NumberField.Units.coe_one
theorem coe_one : ((1 : (𝓞 K)ˣ) : K) = (1 : K) 
Arguments: {K : Type u_1} [Field K]
Goal: (algebraMap (𝓞 K) K) ↑1 = 1
-- NumberField.Units.coe_neg_one
theorem coe_neg_one : ((-1 : (𝓞 K)ˣ) : K) = (-1 : K) 
Arguments: {K : Type u_1} [Field K]
Goal: (algebraMap (𝓞 K) K) ↑(-1) = -1
-- NumberField.Units.coe_ne_zero
theorem coe_ne_zero (x : (𝓞 K)ˣ) : (x : K) ≠ 0 
Arguments: {K : Type u_1} [Field K] (x : (𝓞 K)ˣ)
Goal: (algebraMap (𝓞 K) K) ↑x ≠ 0
-- NumberField.Units.norm
@[simp]
protected theorem norm [NumberField K] (x : (𝓞 K)ˣ) :
    |Algebra.norm ℚ (x : K)| = 1 
Arguments: (K : Type u_1) [Field K] [NumberField K] (x : (𝓞 K)ˣ)
Goal: |(Algebra.norm ℚ) ((algebraMap (𝓞 K) K) ↑x)| = 1
-- NumberField.Units.mem_torsion
theorem mem_torsion {x : (𝓞 K)ˣ} [NumberField K] :
    x ∈ torsion K ↔ ∀ w : InfinitePlace K, w x = 1 
Arguments: (K : Type u_1) [Field K] {x : (𝓞 K)ˣ} [NumberField K]
Goal: x ∈ NumberField.Units.torsion K ↔ ∀ (w : NumberField.InfinitePlace K), w ((algebraMap (𝓞 K) K) ↑x) = 1
-- NumberField.Units.rootsOfUnity_eq_one
theorem rootsOfUnity_eq_one [NumberField K] {k : ℕ+} (hc : Nat.Coprime k (torsionOrder K))
    {ζ : (𝓞 K)ˣ} : ζ ∈ rootsOfUnity k (𝓞 K) ↔ ζ = 1 
Arguments: (K : Type u_1) [Field K] [NumberField K] {k : ℕ+} (hc : (↑k).Coprime ↑(NumberField.Units.torsionOrder K)) {ζ : (𝓞 K)ˣ}
Goal: ζ ∈ rootsOfUnity k (𝓞 K) ↔ ζ = 1
-- NumberField.Units.rootsOfUnity_eq_torsion
theorem rootsOfUnity_eq_torsion [NumberField K] :
    rootsOfUnity (torsionOrder K) (𝓞 K) = torsion K 
Arguments: (K : Type u_1) [Field K] [NumberField K]
Goal: rootsOfUnity (NumberField.Units.torsionOrder K) (𝓞 K) = NumberField.Units.torsion K
-- Pell.is_pell_solution_iff_mem_unitary
theorem is_pell_solution_iff_mem_unitary {d : ℤ} {a : ℤ√d} :
    a.re ^ 2 - d * a.im ^ 2 = 1 ↔ a ∈ unitary (ℤ√d) 
Arguments: {d : ℤ} {a : ℤ√d}
Goal: a.re ^ 2 - d * a.im ^ 2 = 1 ↔ a ∈ unitary (ℤ√d)
-- Pell.Solution₁.prop
theorem prop (a : Solution₁ d) : a.x ^ 2 - d * a.y ^ 2 = 1 
Arguments: {d : ℤ} (a : Pell.Solution₁ d)
Goal: a.x ^ 2 - d * a.y ^ 2 = 1
-- Pell.Solution₁.prop_x
theorem prop_x (a : Solution₁ d) : a.x ^ 2 = 1 + d * a.y ^ 2 
Arguments: {d : ℤ} (a : Pell.Solution₁ d)
Goal: a.x ^ 2 = 1 + d * a.y ^ 2
-- Pell.Solution₁.prop_y
theorem prop_y (a : Solution₁ d) : d * a.y ^ 2 = a.x ^ 2 - 1 
Arguments: {d : ℤ} (a : Pell.Solution₁ d)
Goal: d * a.y ^ 2 = a.x ^ 2 - 1
-- Pell.Solution₁.ext
@[ext]
theorem ext {a b : Solution₁ d} (hx : a.x = b.x) (hy : a.y = b.y) : a = b 
Arguments: {d : ℤ} {a b : Pell.Solution₁ d} (hx : a.x = b.x) (hy : a.y = b.y)
Goal: a = b
-- Pell.Solution₁.x_mk
@[simp]
theorem x_mk (x y : ℤ) (prop : x ^ 2 - d * y ^ 2 = 1) : (mk x y prop).x = x 
Arguments: {d : ℤ} (x y : ℤ) (prop : x ^ 2 - d * y ^ 2 = 1)
Goal: (Pell.Solution₁.mk x y prop).x = x
-- Pell.Solution₁.y_mk
@[simp]
theorem y_mk (x y : ℤ) (prop : x ^ 2 - d * y ^ 2 = 1) : (mk x y prop).y = y 
Arguments: {d : ℤ} (x y : ℤ) (prop : x ^ 2 - d * y ^ 2 = 1)
Goal: (Pell.Solution₁.mk x y prop).y = y
-- Pell.Solution₁.coe_mk
@[simp]
theorem coe_mk (x y : ℤ) (prop : x ^ 2 - d * y ^ 2 = 1) : (↑(mk x y prop) : ℤ√d) = ⟨x, y⟩ 
Arguments: {d : ℤ} (x y : ℤ) (prop : x ^ 2 - d * y ^ 2 = 1)
Goal: ↑(Pell.Solution₁.mk x y prop) = { re := x, im := y }
-- Pell.Solution₁.x_one
@[simp]
theorem x_one : (1 : Solution₁ d).x = 1 
Arguments: {d : ℤ}
Goal: Pell.Solution₁.x 1 = 1
-- Pell.Solution₁.y_one
@[simp]
theorem y_one : (1 : Solution₁ d).y = 0 
Arguments: {d : ℤ}
Goal: Pell.Solution₁.y 1 = 0
-- Pell.Solution₁.x_mul
@[simp]
theorem x_mul (a b : Solution₁ d) : (a * b).x = a.x * b.x + d * (a.y * b.y) 
Arguments: {d : ℤ} (a b : Pell.Solution₁ d)
Goal: (a * b).x = a.x * b.x + d * (a.y * b.y)
-- Pell.Solution₁.y_mul
@[simp]
theorem y_mul (a b : Solution₁ d) : (a * b).y = a.x * b.y + a.y * b.x 
Arguments: {d : ℤ} (a b : Pell.Solution₁ d)
Goal: (a * b).y = a.x * b.y + a.y * b.x
-- Pell.Solution₁.x_inv
@[simp]
theorem x_inv (a : Solution₁ d) : a⁻¹.x = a.x 
Arguments: {d : ℤ} (a : Pell.Solution₁ d)
Goal: a⁻¹.x = a.x
-- Pell.Solution₁.y_inv
@[simp]
theorem y_inv (a : Solution₁ d) : a⁻¹.y = -a.y 
Arguments: {d : ℤ} (a : Pell.Solution₁ d)
Goal: a⁻¹.y = -a.y
-- Pell.Solution₁.x_neg
@[simp]
theorem x_neg (a : Solution₁ d) : (-a).x = -a.x 
Arguments: {d : ℤ} (a : Pell.Solution₁ d)
Goal: (-a).x = -a.x
-- Pell.Solution₁.y_neg
@[simp]
theorem y_neg (a : Solution₁ d) : (-a).y = -a.y 
Arguments: {d : ℤ} (a : Pell.Solution₁ d)
Goal: (-a).y = -a.y
-- Pell.Solution₁.eq_zero_of_d_neg
theorem eq_zero_of_d_neg (h₀ : d < 0) (a : Solution₁ d) : a.x = 0 ∨ a.y = 0 
Arguments: {d : ℤ} (h₀ : d < 0) (a : Pell.Solution₁ d)
Goal: a.x = 0 ∨ a.y = 0
-- Pell.Solution₁.x_ne_zero
theorem x_ne_zero (h₀ : 0 ≤ d) (a : Solution₁ d) : a.x ≠ 0 
Arguments: {d : ℤ} (h₀ : 0 ≤ d) (a : Pell.Solution₁ d)
Goal: a.x ≠ 0
-- Pell.Solution₁.y_ne_zero_of_one_lt_x
theorem y_ne_zero_of_one_lt_x {a : Solution₁ d} (ha : 1 < a.x) : a.y ≠ 0 
Arguments: {d : ℤ} {a : Pell.Solution₁ d} (ha : 1 < a.x)
Goal: a.y ≠ 0
-- Pell.Solution₁.d_pos_of_one_lt_x
theorem d_pos_of_one_lt_x {a : Solution₁ d} (ha : 1 < a.x) : 0 < d 
Arguments: {d : ℤ} {a : Pell.Solution₁ d} (ha : 1 < a.x)
Goal: 0 < d
-- Pell.Solution₁.d_nonsquare_of_one_lt_x
theorem d_nonsquare_of_one_lt_x {a : Solution₁ d} (ha : 1 < a.x) : ¬IsSquare d 
Arguments: {d : ℤ} {a : Pell.Solution₁ d} (ha : 1 < a.x)
Goal: ¬IsSquare d
-- Pell.Solution₁.eq_one_of_x_eq_one
theorem eq_one_of_x_eq_one (h₀ : d ≠ 0) {a : Solution₁ d} (ha : a.x = 1) : a = 1 
Arguments: {d : ℤ} (h₀ : d ≠ 0) {a : Pell.Solution₁ d} (ha : a.x = 1)
Goal: a = 1
-- Pell.Solution₁.eq_one_or_neg_one_iff_y_eq_zero
theorem eq_one_or_neg_one_iff_y_eq_zero {a : Solution₁ d} : a = 1 ∨ a = -1 ↔ a.y = 0 
Arguments: {d : ℤ} {a : Pell.Solution₁ d}
Goal: a = 1 ∨ a = -1 ↔ a.y = 0
-- Pell.Solution₁.x_mul_pos
theorem x_mul_pos {a b : Solution₁ d} (ha : 0 < a.x) (hb : 0 < b.x) : 0 < (a * b).x 
Arguments: {d : ℤ} {a b : Pell.Solution₁ d} (ha : 0 < a.x) (hb : 0 < b.x)
Goal: 0 < (a * b).x
-- Pell.Solution₁.y_mul_pos
theorem y_mul_pos {a b : Solution₁ d} (hax : 0 < a.x) (hay : 0 < a.y) (hbx : 0 < b.x)
    (hby : 0 < b.y) : 0 < (a * b).y 
Arguments: {d : ℤ} {a b : Pell.Solution₁ d} (hax : 0 < a.x) (hay : 0 < a.y) (hbx : 0 < b.x) (hby : 0 < b.y)
Goal: 0 < (a * b).y
-- Pell.Solution₁.x_pow_pos
theorem x_pow_pos {a : Solution₁ d} (hax : 0 < a.x) (n : ℕ) : 0 < (a ^ n).x 
Arguments: {d : ℤ} {a : Pell.Solution₁ d} (hax : 0 < a.x) (n : ℕ)
Goal: 0 < (a ^ n).x
-- Pell.Solution₁.y_pow_succ_pos
theorem y_pow_succ_pos {a : Solution₁ d} (hax : 0 < a.x) (hay : 0 < a.y) (n : ℕ) :
    0 < (a ^ n.succ).y 
Arguments: {d : ℤ} {a : Pell.Solution₁ d} (hax : 0 < a.x) (hay : 0 < a.y) (n : ℕ)
Goal: 0 < (a ^ n.succ).y
-- Pell.Solution₁.y_zpow_pos
theorem y_zpow_pos {a : Solution₁ d} (hax : 0 < a.x) (hay : 0 < a.y) {n : ℤ} (hn : 0 < n) :
    0 < (a ^ n).y 
Arguments: {d : ℤ} {a : Pell.Solution₁ d} (hax : 0 < a.x) (hay : 0 < a.y) {n : ℤ} (hn : 0 < n)
Goal: 0 < (a ^ n).y
-- Pell.Solution₁.x_zpow_pos
theorem x_zpow_pos {a : Solution₁ d} (hax : 0 < a.x) (n : ℤ) : 0 < (a ^ n).x 
Arguments: {d : ℤ} {a : Pell.Solution₁ d} (hax : 0 < a.x) (n : ℤ)
Goal: 0 < (a ^ n).x
-- Pell.Solution₁.sign_y_zpow_eq_sign_of_x_pos_of_y_pos
theorem sign_y_zpow_eq_sign_of_x_pos_of_y_pos {a : Solution₁ d} (hax : 0 < a.x) (hay : 0 < a.y)
    (n : ℤ) : (a ^ n).y.sign = n.sign 
Arguments: {d : ℤ} {a : Pell.Solution₁ d} (hax : 0 < a.x) (hay : 0 < a.y) (n : ℤ)
Goal: (a ^ n).y.sign = n.sign
-- Pell.Solution₁.exists_pos_variant
theorem exists_pos_variant (h₀ : 0 < d) (a : Solution₁ d) :
    ∃ b : Solution₁ d, 0 < b.x ∧ 0 ≤ b.y ∧ a ∈ ({b, b⁻¹, -b, -b⁻¹} : Set (Solution₁ d)) 
Arguments: {d : ℤ} (h₀ : 0 < d) (a : Pell.Solution₁ d)
Goal: ∃ b, 0 < b.x ∧ 0 ≤ b.y ∧ a ∈ {b, b⁻¹, -b, -b⁻¹}
-- Pell.exists_of_not_isSquare
theorem exists_of_not_isSquare (h₀ : 0 < d) (hd : ¬IsSquare d) :
    ∃ x y : ℤ, x ^ 2 - d * y ^ 2 = 1 ∧ y ≠ 0 
Arguments: {d : ℤ} (h₀ : 0 < d) (hd : ¬IsSquare d)
Goal: ∃ x y, x ^ 2 - d * y ^ 2 = 1 ∧ y ≠ 0
-- Pell.exists_iff_not_isSquare
theorem exists_iff_not_isSquare (h₀ : 0 < d) :
    (∃ x y : ℤ, x ^ 2 - d * y ^ 2 = 1 ∧ y ≠ 0) ↔ ¬IsSquare d 
Arguments: {d : ℤ} (h₀ : 0 < d)
Goal: (∃ x y, x ^ 2 - d * y ^ 2 = 1 ∧ y ≠ 0) ↔ ¬IsSquare d
-- Pell.Solution₁.exists_nontrivial_of_not_isSquare
theorem exists_nontrivial_of_not_isSquare (h₀ : 0 < d) (hd : ¬IsSquare d) :
    ∃ a : Solution₁ d, a ≠ 1 ∧ a ≠ -1 
Arguments: {d : ℤ} (h₀ : 0 < d) (hd : ¬IsSquare d)
Goal: ∃ a, a ≠ 1 ∧ a ≠ -1
-- Pell.Solution₁.exists_pos_of_not_isSquare
theorem exists_pos_of_not_isSquare (h₀ : 0 < d) (hd : ¬IsSquare d) :
    ∃ a : Solution₁ d, 1 < a.x ∧ 0 < a.y 
Arguments: {d : ℤ} (h₀ : 0 < d) (hd : ¬IsSquare d)
Goal: ∃ a, 1 < a.x ∧ 0 < a.y
-- Pell.IsFundamental.x_pos
theorem x_pos {a : Solution₁ d} (h : IsFundamental a) : 0 < a.x 
Arguments: {d : ℤ} {a : Pell.Solution₁ d} (h : Pell.IsFundamental a)
Goal: 0 < a.x
-- Pell.IsFundamental.d_pos
theorem d_pos {a : Solution₁ d} (h : IsFundamental a) : 0 < d 
Arguments: {d : ℤ} {a : Pell.Solution₁ d} (h : Pell.IsFundamental a)
Goal: 0 < d
-- Pell.IsFundamental.d_nonsquare
theorem d_nonsquare {a : Solution₁ d} (h : IsFundamental a) : ¬IsSquare d 
Arguments: {d : ℤ} {a : Pell.Solution₁ d} (h : Pell.IsFundamental a)
Goal: ¬IsSquare d
-- Pell.IsFundamental.subsingleton
theorem subsingleton {a b : Solution₁ d} (ha : IsFundamental a) (hb : IsFundamental b) : a = b 
Arguments: {d : ℤ} {a b : Pell.Solution₁ d} (ha : Pell.IsFundamental a) (hb : Pell.IsFundamental b)
Goal: a = b
-- Pell.IsFundamental.exists_of_not_isSquare
theorem exists_of_not_isSquare (h₀ : 0 < d) (hd : ¬IsSquare d) :
    ∃ a : Solution₁ d, IsFundamental a 
Arguments: {d : ℤ} (h₀ : 0 < d) (hd : ¬IsSquare d)
Goal: ∃ a, Pell.IsFundamental a
-- Pell.IsFundamental.y_strictMono
theorem y_strictMono {a : Solution₁ d} (h : IsFundamental a) :
    StrictMono fun n : ℤ => (a ^ n).y 
Arguments: {d : ℤ} {a : Pell.Solution₁ d} (h : Pell.IsFundamental a)
Goal: StrictMono fun n => (a ^ n).y
-- Pell.IsFundamental.zpow_y_lt_iff_lt
theorem zpow_y_lt_iff_lt {a : Solution₁ d} (h : IsFundamental a) (m n : ℤ) :
    (a ^ m).y < (a ^ n).y ↔ m < n 
Arguments: {d : ℤ} {a : Pell.Solution₁ d} (h : Pell.IsFundamental a) (m n : ℤ)
Goal: (a ^ m).y < (a ^ n).y ↔ m < n
-- Pell.IsFundamental.zpow_eq_one_iff
theorem zpow_eq_one_iff {a : Solution₁ d} (h : IsFundamental a) (n : ℤ) : a ^ n = 1 ↔ n = 0 
Arguments: {d : ℤ} {a : Pell.Solution₁ d} (h : Pell.IsFundamental a) (n : ℤ)
Goal: a ^ n = 1 ↔ n = 0
-- Pell.IsFundamental.zpow_ne_neg_zpow
theorem zpow_ne_neg_zpow {a : Solution₁ d} (h : IsFundamental a) {n n' : ℤ} : a ^ n ≠ -a ^ n' 
Arguments: {d : ℤ} {a : Pell.Solution₁ d} (h : Pell.IsFundamental a) {n n' : ℤ}
Goal: a ^ n ≠ -a ^ n'
-- Pell.IsFundamental.x_le_x
theorem x_le_x {a₁ : Solution₁ d} (h : IsFundamental a₁) {a : Solution₁ d} (hax : 1 < a.x) :
    a₁.x ≤ a.x 
Arguments: {d : ℤ} {a₁ : Pell.Solution₁ d} (h : Pell.IsFundamental a₁) {a : Pell.Solution₁ d} (hax : 1 < a.x)
Goal: a₁.x ≤ a.x
-- Pell.IsFundamental.y_le_y
theorem y_le_y {a₁ : Solution₁ d} (h : IsFundamental a₁) {a : Solution₁ d} (hax : 1 < a.x)
    (hay : 0 < a.y) : a₁.y ≤ a.y 
Arguments: {d : ℤ} {a₁ : Pell.Solution₁ d} (h : Pell.IsFundamental a₁) {a : Pell.Solution₁ d} (hax : 1 < a.x) (hay : 0 < a.y)
Goal: a₁.y ≤ a.y
-- Pell.IsFundamental.x_mul_y_le_y_mul_x
theorem x_mul_y_le_y_mul_x {a₁ : Solution₁ d} (h : IsFundamental a₁) {a : Solution₁ d}
    (hax : 1 < a.x) (hay : 0 < a.y) : a.x * a₁.y ≤ a.y * a₁.x 
Arguments: {d : ℤ} {a₁ : Pell.Solution₁ d} (h : Pell.IsFundamental a₁) {a : Pell.Solution₁ d} (hax : 1 < a.x) (hay : 0 < a.y)
Goal: a.x * a₁.y ≤ a.y * a₁.x
-- Pell.IsFundamental.mul_inv_y_nonneg
theorem mul_inv_y_nonneg {a₁ : Solution₁ d} (h : IsFundamental a₁) {a : Solution₁ d} (hax : 1 < a.x)
    (hay : 0 < a.y) : 0 ≤ (a * a₁⁻¹).y 
Arguments: {d : ℤ} {a₁ : Pell.Solution₁ d} (h : Pell.IsFundamental a₁) {a : Pell.Solution₁ d} (hax : 1 < a.x) (hay : 0 < a.y)
Goal: 0 ≤ (a * a₁⁻¹).y
-- Pell.IsFundamental.mul_inv_x_pos
theorem mul_inv_x_pos {a₁ : Solution₁ d} (h : IsFundamental a₁) {a : Solution₁ d} (hax : 1 < a.x)
    (hay : 0 < a.y) : 0 < (a * a₁⁻¹).x 
Arguments: {d : ℤ} {a₁ : Pell.Solution₁ d} (h : Pell.IsFundamental a₁) {a : Pell.Solution₁ d} (hax : 1 < a.x) (hay : 0 < a.y)
Goal: 0 < (a * a₁⁻¹).x
-- Pell.IsFundamental.mul_inv_x_lt_x
theorem mul_inv_x_lt_x {a₁ : Solution₁ d} (h : IsFundamental a₁) {a : Solution₁ d} (hax : 1 < a.x)
    (hay : 0 < a.y) : (a * a₁⁻¹).x < a.x 
Arguments: {d : ℤ} {a₁ : Pell.Solution₁ d} (h : Pell.IsFundamental a₁) {a : Pell.Solution₁ d} (hax : 1 < a.x) (hay : 0 < a.y)
Goal: (a * a₁⁻¹).x < a.x
-- Pell.IsFundamental.eq_pow_of_nonneg
theorem eq_pow_of_nonneg {a₁ : Solution₁ d} (h : IsFundamental a₁) {a : Solution₁ d} (hax : 0 < a.x)
    (hay : 0 ≤ a.y) : ∃ n : ℕ, a = a₁ ^ n 
Arguments: {d : ℤ} {a₁ : Pell.Solution₁ d} (h : Pell.IsFundamental a₁) {a : Pell.Solution₁ d} (hax : 0 < a.x) (hay : 0 ≤ a.y)
Goal: ∃ n, a = a₁ ^ n
-- Pell.IsFundamental.eq_zpow_or_neg_zpow
theorem eq_zpow_or_neg_zpow {a₁ : Solution₁ d} (h : IsFundamental a₁) (a : Solution₁ d) :
    ∃ n : ℤ, a = a₁ ^ n ∨ a = -a₁ ^ n 
Arguments: {d : ℤ} {a₁ : Pell.Solution₁ d} (h : Pell.IsFundamental a₁) (a : Pell.Solution₁ d)
Goal: ∃ n, a = a₁ ^ n ∨ a = -a₁ ^ n
-- Pell.existsUnique_pos_generator
theorem existsUnique_pos_generator (h₀ : 0 < d) (hd : ¬IsSquare d) :
    ∃! a₁ : Solution₁ d,
      1 < a₁.x ∧ 0 < a₁.y ∧ ∀ a : Solution₁ d, ∃ n : ℤ, a = a₁ ^ n ∨ a = -a₁ ^ n 
Arguments: {d : ℤ} (h₀ : 0 < d) (hd : ¬IsSquare d)
Goal: ∃! a₁, 1 < a₁.x ∧ 0 < a₁.y ∧ ∀ (a : Pell.Solution₁ d), ∃ n, a = a₁ ^ n ∨ a = -a₁ ^ n
-- Pell.pos_generator_iff_fundamental
theorem pos_generator_iff_fundamental (a : Solution₁ d) :
    (1 < a.x ∧ 0 < a.y ∧ ∀ b : Solution₁ d, ∃ n : ℤ, b = a ^ n ∨ b = -a ^ n) ↔ IsFundamental a 
Arguments: {d : ℤ} (a : Pell.Solution₁ d)
Goal: (1 < a.x ∧ 0 < a.y ∧ ∀ (b : Pell.Solution₁ d), ∃ n, b = a ^ n ∨ b = -a ^ n) ↔ Pell.IsFundamental a
-- ZMod.Ico_map_valMinAbs_natAbs_eq_Ico_map_id
theorem Ico_map_valMinAbs_natAbs_eq_Ico_map_id (p : ℕ) [hp : Fact p.Prime] (a : ZMod p)
    (hap : a ≠ 0) : ((Ico 1 (p / 2).succ).1.map fun (x : ℕ) => (a * x).valMinAbs.natAbs) =
    (Ico 1 (p / 2).succ).1.map fun a => a 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] (a : ZMod p) (hap : a ≠ 0)
Goal: Multiset.map (fun x => (a * ↑x).valMinAbs.natAbs) (Finset.Ico 1 (p / 2).succ).val =
  Multiset.map (fun a => a) (Finset.Ico 1 (p / 2).succ).val
-- _private.Mathlib.NumberTheory.LegendreSymbol.GaussEisensteinLemmas.0.ZMod.gauss_lemma_aux₁
private theorem gauss_lemma_aux₁ (p : ℕ) [Fact p.Prime] {a : ℤ}
    (hap : (a : ZMod p) ≠ 0) : (a ^ (p / 2) * (p / 2)! : ZMod p) =
    (-1 : ZMod p) ^ ((Ico 1 (p / 2).succ).filter fun x : ℕ =>
      ¬(a * x : ZMod p).val ≤ p / 2).card * (p / 2)! 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] {a : ℤ} (hap : ↑a ≠ 0)
Goal: ↑a ^ (p / 2) * ↑(p / 2)! =
  (-1) ^ (Finset.filter (fun x => ¬(↑a * ↑x).val ≤ p / 2) (Finset.Ico 1 (p / 2).succ)).card * ↑(p / 2)!
-- ZMod.gauss_lemma_aux
theorem gauss_lemma_aux (p : ℕ) [hp : Fact p.Prime] {a : ℤ}
    (hap : (a : ZMod p) ≠ 0) : (↑a ^ (p / 2) : ZMod p) =
    ((-1) ^ ((Ico 1 (p / 2).succ).filter fun x : ℕ => p / 2 < (a * x : ZMod p).val).card :) 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] {a : ℤ} (hap : ↑a ≠ 0)
Goal: ↑a ^ (p / 2) = ↑((-1) ^ (Finset.filter (fun x => p / 2 < (↑a * ↑x).val) (Finset.Ico 1 (p / 2).succ)).card)
-- ZMod.gauss_lemma
theorem gauss_lemma {p : ℕ} [h : Fact p.Prime] {a : ℤ} (hp : p ≠ 2) (ha0 : (a : ZMod p) ≠ 0) :
    legendreSym p a = (-1) ^ ((Ico 1 (p / 2).succ).filter fun x : ℕ =>
      p / 2 < (a * x : ZMod p).val).card 
Arguments: {p : ℕ} [h : Fact (Nat.Prime p)] {a : ℤ} (hp : p ≠ 2) (ha0 : ↑a ≠ 0)
Goal: legendreSym p a = (-1) ^ (Finset.filter (fun x => p / 2 < (↑a * ↑x).val) (Finset.Ico 1 (p / 2).succ)).card
-- _private.Mathlib.NumberTheory.LegendreSymbol.GaussEisensteinLemmas.0.ZMod.eisenstein_lemma_aux₁
private theorem eisenstein_lemma_aux₁ (p : ℕ) [Fact p.Prime] [hp2 : Fact (p % 2 = 1)] {a : ℕ}
    (hap : (a : ZMod p) ≠ 0) : ((∑ x ∈ Ico 1 (p / 2).succ, a * x : ℕ) : ZMod 2) =
    ((Ico 1 (p / 2).succ).filter fun x : ℕ => p / 2 < (a * x : ZMod p).val).card +
      ∑ x ∈ Ico 1 (p / 2).succ, x + (∑ x ∈ Ico 1 (p / 2).succ, a * x / p : ℕ) 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] [hp2 : Fact (p % 2 = 1)] {a : ℕ} (hap : ↑a ≠ 0)
Goal: ↑(∑ x ∈ Finset.Ico 1 (p / 2).succ, a * x) =
  ↑(Finset.filter (fun x => p / 2 < (↑a * ↑x).val) (Finset.Ico 1 (p / 2).succ)).card +
      ↑(∑ x ∈ Finset.Ico 1 (p / 2).succ, x) +
    ↑(∑ x ∈ Finset.Ico 1 (p / 2).succ, a * x / p)
-- ZMod.eisenstein_lemma_aux
theorem eisenstein_lemma_aux (p : ℕ) [Fact p.Prime] [Fact (p % 2 = 1)] {a : ℕ} (ha2 : a % 2 = 1)
    (hap : (a : ZMod p) ≠ 0) :
    ((Ico 1 (p / 2).succ).filter fun x : ℕ => p / 2 < (a * x : ZMod p).val).card ≡
      ∑ x ∈ Ico 1 (p / 2).succ, x * a / p [MOD 2] 
Arguments: (p : ℕ) [Fact (Nat.Prime p)] [Fact (p % 2 = 1)] {a : ℕ} (ha2 : a % 2 = 1) (hap : ↑a ≠ 0)
Goal: (Finset.filter (fun x => p / 2 < (↑a * ↑x).val) (Finset.Ico 1 (p / 2).succ)).card ≡
  ∑ x ∈ Finset.Ico 1 (p / 2).succ, x * a / p [MOD 2]
-- ZMod.div_eq_filter_card
theorem div_eq_filter_card {a b c : ℕ} (hb0 : 0 < b) (hc : a / b ≤ c) :
    a / b = ((Ico 1 c.succ).filter fun x => x * b ≤ a).card 
Arguments: {a b c : ℕ} (hb0 : 0 < b) (hc : a / b ≤ c)
Goal: a / b = (Finset.filter (fun x => x * b ≤ a) (Finset.Ico 1 c.succ)).card
-- _private.Mathlib.NumberTheory.LegendreSymbol.GaussEisensteinLemmas.0.ZMod.sum_Ico_eq_card_lt
private theorem sum_Ico_eq_card_lt {p q : ℕ} :
    ∑ a ∈ Ico 1 (p / 2).succ, a * q / p =
    ((Ico 1 (p / 2).succ ×ˢ Ico 1 (q / 2).succ).filter fun x : ℕ × ℕ =>
      x.2 * p ≤ x.1 * q).card 
Arguments: {p q : ℕ}
Goal: ∑ a ∈ Finset.Ico 1 (p / 2).succ, a * q / p =
  (Finset.filter (fun x => x.2 * p ≤ x.1 * q) (Finset.Ico 1 (p / 2).succ ×ˢ Finset.Ico 1 (q / 2).succ)).card
-- ZMod.sum_mul_div_add_sum_mul_div_eq_mul
theorem sum_mul_div_add_sum_mul_div_eq_mul (p q : ℕ) [hp : Fact p.Prime] (hq0 : (q : ZMod p) ≠ 0) :
    ∑ a ∈ Ico 1 (p / 2).succ, a * q / p + ∑ a ∈ Ico 1 (q / 2).succ, a * p / q =
    p / 2 * (q / 2) 
Arguments: (p q : ℕ) [hp : Fact (Nat.Prime p)] (hq0 : ↑q ≠ 0)
Goal: ∑ a ∈ Finset.Ico 1 (p / 2).succ, a * q / p + ∑ a ∈ Finset.Ico 1 (q / 2).succ, a * p / q = p / 2 * (q / 2)
-- ZMod.eisenstein_lemma
theorem eisenstein_lemma {p : ℕ} [Fact p.Prime] (hp : p ≠ 2) {a : ℕ} (ha1 : a % 2 = 1)
    (ha0 : (a : ZMod p) ≠ 0) : legendreSym p a = (-1) ^ ∑ x ∈ Ico 1 (p / 2).succ, x * a / p 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (hp : p ≠ 2) {a : ℕ} (ha1 : a % 2 = 1) (ha0 : ↑a ≠ 0)
Goal: legendreSym p ↑a = (-1) ^ ∑ x ∈ Finset.Ico 1 (p / 2).succ, x * a / p
-- SlashAction.smul_slash
class SlashAction (β G α γ : Type*) [Group G] [AddMonoid α] [SMul γ α] where
  map : β → G → α → α
  zero_slash : ∀ (k : β) (g : G), map k g 0 = 0
  slash_one : ∀ (k : β) (a : α), map k 1 a = a
  slash_mul : ∀ (k : β) (g h : G) (a : α), map k (g * h) a = map k h (map k g a)
  smul_slash : ∀ (k : β) (g : G) (a : α) (z : γ), map k g (z • a) = z • map k g a
  add_slash : ∀ (k : β) (g : G) (a b : α), map k g (a + b) = map k g a + map k g b
Arguments: {β : Type u_1} {G : Type u_2} {α : Type u_3} {γ : Type u_4} [Group G] [AddMonoid α] [SMul γ α] [self : SlashAction β G α γ] (k : β) (g : G) (a : α) (z : γ)
Goal: (z • a) ∣[k;γ] g = z • a ∣[k;γ] g