ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- SlashAction.zero_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)
Goal: 0 ∣[k;γ] g = 0
-- SlashAction.slash_mul
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 h : G) (a : α)
Goal: a ∣[k;γ] (g * h) = (a ∣[k;γ] g) ∣[k;γ] h
-- SlashAction.slash_one
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 : β) (a : α)
Goal: a ∣[k;γ] 1 = a
-- SlashAction.add_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 b : α)
Goal: (a + b) ∣[k;γ] g = a ∣[k;γ] g + b ∣[k;γ] g
-- SlashAction.neg_slash
@[simp]
theorem SlashAction.neg_slash {β G α γ : Type*} [Group G] [AddGroup α] [SMul γ α]
    [SlashAction β G α γ] (k : β) (g : G) (a : α) : (-a) ∣[k;γ] g = -a ∣[k;γ] g 
Arguments: {β : Type u_1} {G : Type u_2} {α : Type u_3} {γ : Type u_4} [Group G] [AddGroup α] [SMul γ α] [SlashAction β G α γ] (k : β) (g : G) (a : α)
Goal: (-a) ∣[k;γ] g = -a ∣[k;γ] g
-- SlashAction.smul_slash_of_tower
@[simp]
theorem SlashAction.smul_slash_of_tower {R β G α : Type*} (γ : Type*) [Group G] [AddGroup α]
    [Monoid γ] [MulAction γ α] [SMul R γ] [SMul R α] [IsScalarTower R γ α] [SlashAction β G α γ]
    (k : β) (g : G) (a : α) (r : R) : (r • a) ∣[k;γ] g = r • a ∣[k;γ] g 
Arguments: {R : Type u_1} {β : Type u_2} {G : Type u_3} {α : Type u_4} (γ : Type u_5) [Group G] [AddGroup α] [Monoid γ] [MulAction γ α] [SMul R γ] [SMul R α] [IsScalarTower R γ α] [SlashAction β G α γ] (k : β) (g : G) (a : α) (r : R)
Goal: (r • a) ∣[k;γ] g = r • a ∣[k;γ] g
-- _private.Mathlib.NumberTheory.ModularForms.SlashActions.0.ModularForm.slash_mul
private theorem slash_mul (k : ℤ) (A B : GL(2, ℝ)⁺) (f : ℍ → ℂ) :
    f ∣[k](A * B) = (f ∣[k]A) ∣[k]B 
Arguments: (k : ℤ) (A B : ↥GL(2, ℝ)⁺) (f : ℍ → ℂ)
Goal: ModularForm.slash k (A * B) f = ModularForm.slash k B (ModularForm.slash k A f)
-- _private.Mathlib.NumberTheory.ModularForms.SlashActions.0.ModularForm.add_slash
private theorem add_slash (k : ℤ) (A : GL(2, ℝ)⁺) (f g : ℍ → ℂ) :
    (f + g) ∣[k]A = f ∣[k]A + g ∣[k]A 
Arguments: (k : ℤ) (A : ↥GL(2, ℝ)⁺) (f g : ℍ → ℂ)
Goal: ModularForm.slash k A (f + g) = ModularForm.slash k A f + ModularForm.slash k A g
-- _private.Mathlib.NumberTheory.ModularForms.SlashActions.0.ModularForm.slash_one
private theorem slash_one (k : ℤ) (f : ℍ → ℂ) : f ∣[k]1 = f 
Arguments: (k : ℤ) (f : ℍ → ℂ)
Goal: ModularForm.slash k 1 f = f
-- _private.Mathlib.NumberTheory.ModularForms.SlashActions.0.ModularForm.smul_slash
private theorem smul_slash (k : ℤ) (A : GL(2, ℝ)⁺) (f : ℍ → ℂ) (c : α) :
    (c • f) ∣[k]A = c • f ∣[k]A 
Arguments: {α : Type u_1} [SMul α ℂ] [IsScalarTower α ℂ ℂ] (k : ℤ) (A : ↥GL(2, ℝ)⁺) (f : ℍ → ℂ) (c : α)
Goal: ModularForm.slash k A (c • f) = c • ModularForm.slash k A f
-- _private.Mathlib.NumberTheory.ModularForms.SlashActions.0.ModularForm.zero_slash
private theorem zero_slash (k : ℤ) (A : GL(2, ℝ)⁺) : (0 : ℍ → ℂ) ∣[k]A = 0 
Arguments: (k : ℤ) (A : ↥GL(2, ℝ)⁺)
Goal: ModularForm.slash k A 0 = 0
-- ModularForm.slash_def
theorem slash_def (A : GL(2, ℝ)⁺) : f ∣[k] A = slash k A f 
Arguments: {k : ℤ} (f : ℍ → ℂ) (A : ↥GL(2, ℝ)⁺)
Goal: f ∣[k] A = ModularForm.slash k A f
-- ModularForm.subgroup_slash
@[simp]
theorem subgroup_slash (Γ : Subgroup SL(2, ℤ)) (γ : Γ) : f ∣[k] γ = f ∣[k] (γ : GL(2, ℝ)⁺) 
Arguments: {k : ℤ} (f : ℍ → ℂ) (Γ : Subgroup SL(2, ℤ)) (γ : ↥Γ)
Goal: f ∣[k] γ = f ∣[k] ↑↑γ
-- ModularForm.SL_slash
@[simp]
theorem SL_slash (γ : SL(2, ℤ)) : f ∣[k] γ = f ∣[k] (γ : GL(2, ℝ)⁺) 
Arguments: {k : ℤ} (f : ℍ → ℂ) (γ : SL(2, ℤ))
Goal: f ∣[k] γ = f ∣[k] ↑γ
-- ModularForm.is_invariant_const
theorem is_invariant_const (A : SL(2, ℤ)) (x : ℂ) :
    Function.const ℍ x ∣[(0 : ℤ)] A = Function.const ℍ x 
Arguments: (A : SL(2, ℤ)) (x : ℂ)
Goal: Function.const ℍ x ∣[0] A = Function.const ℍ x
-- ModularForm.is_invariant_one
-- @[simp] -- Porting note: simpNF says LHS simplifies to something more complex
theorem is_invariant_one (A : SL(2, ℤ)) : (1 : ℍ → ℂ) ∣[(0 : ℤ)] A = (1 : ℍ → ℂ) 
Arguments: (A : SL(2, ℤ))
Goal: 1 ∣[0] A = 1
-- ModularForm.slash_action_eq'_iff
theorem slash_action_eq'_iff (k : ℤ) (Γ : Subgroup SL(2, ℤ)) (f : ℍ → ℂ) (γ : Γ) (z : ℍ) :
    (f ∣[k] γ) z = f z ↔ f (γ • z) = ((↑ₘ[ℤ] γ 1 0 : ℂ) * z + (↑ₘ[ℤ] γ 1 1 : ℂ)) ^ k * f z 
Arguments: (k : ℤ) (Γ : Subgroup SL(2, ℤ)) (f : ℍ → ℂ) (γ : ↥Γ) (z : ℍ)
Goal: (f ∣[k] γ) z = f z ↔ f (γ • z) = (↑(↑↑↑γ 1 0) * ↑z + ↑(↑↑↑γ 1 1)) ^ k * f z
-- ModularForm.mul_slash
theorem mul_slash (k1 k2 : ℤ) (A : GL(2, ℝ)⁺) (f g : ℍ → ℂ) :
    (f * g) ∣[k1 + k2] A = ((↑ₘA).det : ℝ) • f ∣[k1] A * g ∣[k2] A 
Arguments: (k1 k2 : ℤ) (A : ↥GL(2, ℝ)⁺) (f g : ℍ → ℂ)
Goal: (f * g) ∣[k1 + k2] A = (↑↑A).det • f ∣[k1] A * g ∣[k2] A
-- ModularForm.mul_slash_SL2
theorem mul_slash_SL2 (k1 k2 : ℤ) (A : SL(2, ℤ)) (f g : ℍ → ℂ) :
    (f * g) ∣[k1 + k2] A = f ∣[k1] A * g ∣[k2] A 
Arguments: (k1 k2 : ℤ) (A : SL(2, ℤ)) (f g : ℍ → ℂ)
Goal: (f * g) ∣[k1 + k2] A = f ∣[k1] A * g ∣[k2] A
-- ModularForm.mul_slash_subgroup
theorem mul_slash_subgroup (k1 k2 : ℤ) (Γ : Subgroup SL(2, ℤ)) (A : Γ) (f g : ℍ → ℂ) :
    (f * g) ∣[k1 + k2] A = f ∣[k1] A * g ∣[k2] A 
Arguments: (k1 k2 : ℤ) (Γ : Subgroup SL(2, ℤ)) (A : ↥Γ) (f g : ℍ → ℂ)
Goal: (f * g) ∣[k1 + k2] A = f ∣[k1] A * g ∣[k2] A
-- jacobiSym.zero_right
@[simp]
theorem zero_right (a : ℤ) : J(a | 0) = 1 
Arguments: (a : ℤ)
Goal: jacobiSym a 0 = 1
-- jacobiSym.one_right
@[simp]
theorem one_right (a : ℤ) : J(a | 1) = 1 
Arguments: (a : ℤ)
Goal: jacobiSym a 1 = 1
-- jacobiSym.legendreSym.to_jacobiSym
theorem legendreSym.to_jacobiSym (p : ℕ) [fp : Fact p.Prime] (a : ℤ) :
    legendreSym p a = J(a | p) 
Arguments: (p : ℕ) [fp : Fact (Nat.Prime p)] (a : ℤ)
Goal: legendreSym p a = jacobiSym a p
-- jacobiSym.mul_right'
theorem mul_right' (a : ℤ) {b₁ b₂ : ℕ} (hb₁ : b₁ ≠ 0) (hb₂ : b₂ ≠ 0) :
    J(a | b₁ * b₂) = J(a | b₁) * J(a | b₂) 
Arguments: (a : ℤ) {b₁ b₂ : ℕ} (hb₁ : b₁ ≠ 0) (hb₂ : b₂ ≠ 0)
Goal: jacobiSym a (b₁ * b₂) = jacobiSym a b₁ * jacobiSym a b₂
-- jacobiSym.mul_right
theorem mul_right (a : ℤ) (b₁ b₂ : ℕ) [NeZero b₁] [NeZero b₂] :
    J(a | b₁ * b₂) = J(a | b₁) * J(a | b₂) 
Arguments: (a : ℤ) (b₁ b₂ : ℕ) [NeZero b₁] [NeZero b₂]
Goal: jacobiSym a (b₁ * b₂) = jacobiSym a b₁ * jacobiSym a b₂
-- jacobiSym.trichotomy
theorem trichotomy (a : ℤ) (b : ℕ) : J(a | b) = 0 ∨ J(a | b) = 1 ∨ J(a | b) = -1 
Arguments: (a : ℤ) (b : ℕ)
Goal: jacobiSym a b = 0 ∨ jacobiSym a b = 1 ∨ jacobiSym a b = -1
-- jacobiSym.one_left
@[simp]
theorem one_left (b : ℕ) : J(1 | b) = 1 
Arguments: (b : ℕ)
Goal: jacobiSym 1 b = 1
-- jacobiSym.mul_left
theorem mul_left (a₁ a₂ : ℤ) (b : ℕ) : J(a₁ * a₂ | b) = J(a₁ | b) * J(a₂ | b) 
Arguments: (a₁ a₂ : ℤ) (b : ℕ)
Goal: jacobiSym (a₁ * a₂) b = jacobiSym a₁ b * jacobiSym a₂ b
-- jacobiSym.eq_zero_iff_not_coprime
theorem eq_zero_iff_not_coprime {a : ℤ} {b : ℕ} [NeZero b] : J(a | b) = 0 ↔ a.gcd b ≠ 1 
Arguments: {a : ℤ} {b : ℕ} [NeZero b]
Goal: jacobiSym a b = 0 ↔ a.gcd ↑b ≠ 1
-- jacobiSym.ne_zero
protected theorem ne_zero {a : ℤ} {b : ℕ} (h : a.gcd b = 1) : J(a | b) ≠ 0 
Arguments: {a : ℤ} {b : ℕ} (h : a.gcd ↑b = 1)
Goal: jacobiSym a b ≠ 0
-- jacobiSym.eq_zero_iff
theorem eq_zero_iff {a : ℤ} {b : ℕ} : J(a | b) = 0 ↔ b ≠ 0 ∧ a.gcd b ≠ 1 
Arguments: {a : ℤ} {b : ℕ}
Goal: jacobiSym a b = 0 ↔ b ≠ 0 ∧ a.gcd ↑b ≠ 1
-- jacobiSym.zero_left
theorem zero_left {b : ℕ} (hb : 1 < b) : J(0 | b) = 0 
Arguments: {b : ℕ} (hb : 1 < b)
Goal: jacobiSym 0 b = 0
-- jacobiSym.eq_one_or_neg_one
theorem eq_one_or_neg_one {a : ℤ} {b : ℕ} (h : a.gcd b = 1) : J(a | b) = 1 ∨ J(a | b) = -1 
Arguments: {a : ℤ} {b : ℕ} (h : a.gcd ↑b = 1)
Goal: jacobiSym a b = 1 ∨ jacobiSym a b = -1
-- jacobiSym.pow_left
theorem pow_left (a : ℤ) (e b : ℕ) : J(a ^ e | b) = J(a | b) ^ e 
Arguments: (a : ℤ) (e b : ℕ)
Goal: jacobiSym (a ^ e) b = jacobiSym a b ^ e
-- jacobiSym.pow_right
theorem pow_right (a : ℤ) (b e : ℕ) : J(a | b ^ e) = J(a | b) ^ e 
Arguments: (a : ℤ) (b e : ℕ)
Goal: jacobiSym a (b ^ e) = jacobiSym a b ^ e
-- jacobiSym.sq_one
theorem sq_one {a : ℤ} {b : ℕ} (h : a.gcd b = 1) : J(a | b) ^ 2 = 1 
Arguments: {a : ℤ} {b : ℕ} (h : a.gcd ↑b = 1)
Goal: jacobiSym a b ^ 2 = 1
-- jacobiSym.sq_one'
theorem sq_one' {a : ℤ} {b : ℕ} (h : a.gcd b = 1) : J(a ^ 2 | b) = 1 
Arguments: {a : ℤ} {b : ℕ} (h : a.gcd ↑b = 1)
Goal: jacobiSym (a ^ 2) b = 1
-- jacobiSym.mod_left
theorem mod_left (a : ℤ) (b : ℕ) : J(a | b) = J(a % b | b) 
Arguments: (a : ℤ) (b : ℕ)
Goal: jacobiSym a b = jacobiSym (a % ↑b) b
-- jacobiSym.mod_left'
theorem mod_left' {a₁ a₂ : ℤ} {b : ℕ} (h : a₁ % b = a₂ % b) : J(a₁ | b) = J(a₂ | b) 
Arguments: {a₁ a₂ : ℤ} {b : ℕ} (h : a₁ % ↑b = a₂ % ↑b)
Goal: jacobiSym a₁ b = jacobiSym a₂ b
-- jacobiSym.prime_dvd_of_eq_neg_one
theorem prime_dvd_of_eq_neg_one {p : ℕ} [Fact p.Prime] {a : ℤ} (h : J(a | p) = -1) {x y : ℤ}
    (hxy : ↑p ∣ (x ^ 2 - a * y ^ 2 : ℤ)) : ↑p ∣ x ∧ ↑p ∣ y 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {a : ℤ} (h : jacobiSym a p = -1) {x y : ℤ} (hxy : ↑p ∣ x ^ 2 - a * y ^ 2)
Goal: ↑p ∣ x ∧ ↑p ∣ y
-- jacobiSym.list_prod_left
theorem list_prod_left {l : List ℤ} {n : ℕ} : J(l.prod | n) = (l.map fun a => J(a | n)).prod 
Arguments: {l : List ℤ} {n : ℕ}
Goal: jacobiSym l.prod n = (List.map (fun a => jacobiSym a n) l).prod
-- jacobiSym.list_prod_right
theorem list_prod_right {a : ℤ} {l : List ℕ} (hl : ∀ n ∈ l, n ≠ 0) :
    J(a | l.prod) = (l.map fun n => J(a | n)).prod 
Arguments: {a : ℤ} {l : List ℕ} (hl : ∀ n ∈ l, n ≠ 0)
Goal: jacobiSym a l.prod = (List.map (fun n => jacobiSym a n) l).prod
-- jacobiSym.eq_neg_one_at_prime_divisor_of_eq_neg_one
theorem eq_neg_one_at_prime_divisor_of_eq_neg_one {a : ℤ} {n : ℕ} (h : J(a | n) = -1) :
    ∃ p : ℕ, p.Prime ∧ p ∣ n ∧ J(a | p) = -1 
Arguments: {a : ℤ} {n : ℕ} (h : jacobiSym a n = -1)
Goal: ∃ p, Nat.Prime p ∧ p ∣ n ∧ jacobiSym a p = -1
-- ZMod.nonsquare_of_jacobiSym_eq_neg_one
theorem nonsquare_of_jacobiSym_eq_neg_one {a : ℤ} {b : ℕ} (h : J(a | b) = -1) :
    ¬IsSquare (a : ZMod b) 
Arguments: {a : ℤ} {b : ℕ} (h : jacobiSym a b = -1)
Goal: ¬IsSquare ↑a
-- ZMod.nonsquare_iff_jacobiSym_eq_neg_one
theorem nonsquare_iff_jacobiSym_eq_neg_one {a : ℤ} {p : ℕ} [Fact p.Prime] :
    J(a | p) = -1 ↔ ¬IsSquare (a : ZMod p) 
Arguments: {a : ℤ} {p : ℕ} [Fact (Nat.Prime p)]
Goal: jacobiSym a p = -1 ↔ ¬IsSquare ↑a
-- ZMod.isSquare_of_jacobiSym_eq_one
theorem isSquare_of_jacobiSym_eq_one {a : ℤ} {p : ℕ} [Fact p.Prime] (h : J(a | p) = 1) :
    IsSquare (a : ZMod p) 
Arguments: {a : ℤ} {p : ℕ} [Fact (Nat.Prime p)] (h : jacobiSym a p = 1)
Goal: IsSquare ↑a
-- jacobiSym.value_at
theorem value_at (a : ℤ) {R : Type*} [CommSemiring R] (χ : R →* ℤ)
    (hp : ∀ (p : ℕ) (pp : p.Prime), p ≠ 2 → @legendreSym p ⟨pp⟩ a = χ p) {b : ℕ} (hb : Odd b) :
    J(a | b) = χ b 
Arguments: (a : ℤ) {R : Type u_1} [CommSemiring R] (χ : R →* ℤ) (hp : ∀ (p : ℕ) (pp : Nat.Prime p), p ≠ 2 → legendreSym p a = χ ↑p) {b : ℕ} (hb : Odd b)
Goal: jacobiSym a b = χ ↑b
-- jacobiSym.at_neg_one
theorem at_neg_one {b : ℕ} (hb : Odd b) : J(-1 | b) = χ₄ b 
Arguments: {b : ℕ} (hb : Odd b)
Goal: jacobiSym (-1) b = ZMod.χ₄ ↑b
-- jacobiSym.neg
protected theorem neg (a : ℤ) {b : ℕ} (hb : Odd b) : J(-a | b) = χ₄ b * J(a | b) 
Arguments: (a : ℤ) {b : ℕ} (hb : Odd b)
Goal: jacobiSym (-a) b = ZMod.χ₄ ↑b * jacobiSym a b
-- jacobiSym.at_two
theorem at_two {b : ℕ} (hb : Odd b) : J(2 | b) = χ₈ b 
Arguments: {b : ℕ} (hb : Odd b)
Goal: jacobiSym 2 b = ZMod.χ₈ ↑b
-- jacobiSym.at_neg_two
theorem at_neg_two {b : ℕ} (hb : Odd b) : J(-2 | b) = χ₈' b 
Arguments: {b : ℕ} (hb : Odd b)
Goal: jacobiSym (-2) b = ZMod.χ₈' ↑b
-- jacobiSym.div_four_left
theorem div_four_left {a : ℤ} {b : ℕ} (ha4 : a % 4 = 0) (hb2 : b % 2 = 1) :
    J(a / 4 | b) = J(a | b) 
Arguments: {a : ℤ} {b : ℕ} (ha4 : a % 4 = 0) (hb2 : b % 2 = 1)
Goal: jacobiSym (a / 4) b = jacobiSym a b
-- jacobiSym.even_odd
theorem even_odd {a : ℤ} {b : ℕ} (ha2 : a % 2 = 0) (hb2 : b % 2 = 1) :
    (if b % 8 = 3 ∨ b % 8 = 5 then -J(a / 2 | b) else J(a / 2 | b)) = J(a | b) 
Arguments: {a : ℤ} {b : ℕ} (ha2 : a % 2 = 0) (hb2 : b % 2 = 1)
Goal: (if b % 8 = 3 ∨ b % 8 = 5 then -jacobiSym (a / 2) b else jacobiSym (a / 2) b) = jacobiSym a b
-- qrSign.neg_one_pow
theorem neg_one_pow {m n : ℕ} (hm : Odd m) (hn : Odd n) :
    qrSign m n = (-1) ^ (m / 2 * (n / 2)) 
Arguments: {m n : ℕ} (hm : Odd m) (hn : Odd n)
Goal: qrSign m n = (-1) ^ (m / 2 * (n / 2))
-- qrSign.sq_eq_one
theorem sq_eq_one {m n : ℕ} (hm : Odd m) (hn : Odd n) : qrSign m n ^ 2 = 1 
Arguments: {m n : ℕ} (hm : Odd m) (hn : Odd n)
Goal: qrSign m n ^ 2 = 1
-- qrSign.mul_left
theorem mul_left (m₁ m₂ n : ℕ) : qrSign (m₁ * m₂) n = qrSign m₁ n * qrSign m₂ n 
Arguments: (m₁ m₂ n : ℕ)
Goal: qrSign (m₁ * m₂) n = qrSign m₁ n * qrSign m₂ n
-- qrSign.mul_right
theorem mul_right (m n₁ n₂ : ℕ) [NeZero n₁] [NeZero n₂] :
    qrSign m (n₁ * n₂) = qrSign m n₁ * qrSign m n₂ 
Arguments: (m n₁ n₂ : ℕ) [NeZero n₁] [NeZero n₂]
Goal: qrSign m (n₁ * n₂) = qrSign m n₁ * qrSign m n₂
-- qrSign.symm
protected theorem symm {m n : ℕ} (hm : Odd m) (hn : Odd n) : qrSign m n = qrSign n m 
Arguments: {m n : ℕ} (hm : Odd m) (hn : Odd n)
Goal: qrSign m n = qrSign n m
-- qrSign.eq_iff_eq
theorem eq_iff_eq {m n : ℕ} (hm : Odd m) (hn : Odd n) (x y : ℤ) :
    qrSign m n * x = y ↔ x = qrSign m n * y 
Arguments: {m n : ℕ} (hm : Odd m) (hn : Odd n) (x y : ℤ)
Goal: qrSign m n * x = y ↔ x = qrSign m n * y
-- jacobiSym.quadratic_reciprocity'
theorem quadratic_reciprocity' {a b : ℕ} (ha : Odd a) (hb : Odd b) :
    J(a | b) = qrSign b a * J(b | a) 
Arguments: {a b : ℕ} (ha : Odd a) (hb : Odd b)
Goal: jacobiSym (↑a) b = qrSign b a * jacobiSym (↑b) a
-- jacobiSym.quadratic_reciprocity
theorem quadratic_reciprocity {a b : ℕ} (ha : Odd a) (hb : Odd b) :
    J(a | b) = (-1) ^ (a / 2 * (b / 2)) * J(b | a) 
Arguments: {a b : ℕ} (ha : Odd a) (hb : Odd b)
Goal: jacobiSym (↑a) b = (-1) ^ (a / 2 * (b / 2)) * jacobiSym (↑b) a
-- jacobiSym.quadratic_reciprocity_one_mod_four
theorem quadratic_reciprocity_one_mod_four {a b : ℕ} (ha : a % 4 = 1) (hb : Odd b) :
    J(a | b) = J(b | a) 
Arguments: {a b : ℕ} (ha : a % 4 = 1) (hb : Odd b)
Goal: jacobiSym (↑a) b = jacobiSym (↑b) a
-- jacobiSym.quadratic_reciprocity_one_mod_four'
theorem quadratic_reciprocity_one_mod_four' {a b : ℕ} (ha : Odd a) (hb : b % 4 = 1) :
    J(a | b) = J(b | a) 
Arguments: {a b : ℕ} (ha : Odd a) (hb : b % 4 = 1)
Goal: jacobiSym (↑a) b = jacobiSym (↑b) a
-- jacobiSym.quadratic_reciprocity_three_mod_four
theorem quadratic_reciprocity_three_mod_four {a b : ℕ} (ha : a % 4 = 3) (hb : b % 4 = 3) :
    J(a | b) = -J(b | a) 
Arguments: {a b : ℕ} (ha : a % 4 = 3) (hb : b % 4 = 3)
Goal: jacobiSym (↑a) b = -jacobiSym (↑b) a
-- jacobiSym.quadratic_reciprocity_if
theorem quadratic_reciprocity_if {a b : ℕ} (ha2 : a % 2 = 1) (hb2 : b % 2 = 1) :
    (if a % 4 = 3 ∧ b % 4 = 3 then -J(b | a) else J(b | a)) = J(a | b) 
Arguments: {a b : ℕ} (ha2 : a % 2 = 1) (hb2 : b % 2 = 1)
Goal: (if a % 4 = 3 ∧ b % 4 = 3 then -jacobiSym (↑b) a else jacobiSym (↑b) a) = jacobiSym (↑a) b
-- jacobiSym.mod_right'
theorem mod_right' (a : ℕ) {b : ℕ} (hb : Odd b) : J(a | b) = J(a | b % (4 * a)) 
Arguments: (a : ℕ) {b : ℕ} (hb : Odd b)
Goal: jacobiSym (↑a) b = jacobiSym (↑a) (b % (4 * a))
-- jacobiSym.mod_right
theorem mod_right (a : ℤ) {b : ℕ} (hb : Odd b) : J(a | b) = J(a | b % (4 * a.natAbs)) 
Arguments: (a : ℤ) {b : ℕ} (hb : Odd b)
Goal: jacobiSym a b = jacobiSym a (b % (4 * a.natAbs))
-- _private.Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol.0.fastJacobiSymAux.eq_jacobiSym
private theorem fastJacobiSymAux.eq_jacobiSym {a b : ℕ} {flip : Bool} {ha0 : a > 0}
    (hb2 : b % 2 = 1) (hb1 : b > 1) :
    fastJacobiSymAux a b flip ha0 = if flip then -J(a | b) else J(a | b) 
Arguments: {a b : ℕ} {flip : Bool} {ha0 : a > 0} (hb2 : b % 2 = 1) (hb1 : b > 1)
Goal: fastJacobiSymAux a b flip ha0 = if flip = true then -jacobiSym (↑a) b else jacobiSym (↑a) b
-- _private.Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol.0.fastJacobiSym.eq
@[csimp] private theorem fastJacobiSym.eq : jacobiSym = fastJacobiSym 
Goal: jacobiSym = fastJacobiSym
-- _private.Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol.0.fastLegendreSym.eq
@[csimp] private theorem fastLegendreSym.eq : legendreSym = fastLegendreSym 
Goal: legendreSym = fastLegendreSym
-- NumberField.det_of_basisMatrix_non_zero
theorem det_of_basisMatrix_non_zero : (basisMatrix K).det ≠ 0 
Arguments: (K : Type u_1) [Field K] [NumberField K] [DecidableEq (K →+* ℂ)]
Goal: (NumberField.basisMatrix K).det ≠ 0
-- NumberField.canonicalEmbedding_eq_basisMatrix_mulVec
theorem canonicalEmbedding_eq_basisMatrix_mulVec (α : K) :
    canonicalEmbedding K α = (basisMatrix K).transpose.mulVec
      (fun i ↦ (((integralBasis K).reindex (equivReindex K).symm).repr α i : ℂ)) 
Arguments: {K : Type u_1} [Field K] [NumberField K] (α : K)
Goal: (NumberField.canonicalEmbedding K) α =
  (NumberField.basisMatrix K).transpose.mulVec fun i =>
    ↑((((NumberField.integralBasis K).reindex (NumberField.equivReindex K).symm).repr α) i)
-- NumberField.inverse_basisMatrix_mulVec_eq_repr
theorem inverse_basisMatrix_mulVec_eq_repr (α : 𝓞 K) :
    ∀ i, ((basisMatrix K).transpose)⁻¹.mulVec (fun j =>
      canonicalEmbedding K (algebraMap (𝓞 K) K α) j) i =
      ((integralBasis K).reindex (equivReindex K).symm).repr α i 
Arguments: {K : Type u_1} [Field K] [NumberField K] [DecidableEq (K →+* ℂ)] (α : NumberField.RingOfIntegers K) (i : K →+* ℂ)
Goal: (NumberField.basisMatrix K).transpose⁻¹.mulVec
    (fun j => (NumberField.canonicalEmbedding K) ((algebraMap (NumberField.RingOfIntegers K) K) α) j) i =
  ↑((((NumberField.integralBasis K).reindex (NumberField.equivReindex K).symm).repr ↑α) i)
-- NumberField.to_charZero
class NumberField (K : Type*) [Field K] : Prop where
  [to_charZero : CharZero K]
  [to_finiteDimensional : FiniteDimensional ℚ K]
Arguments: {K : Type u_1} [Field K] [self : NumberField K]
Goal: CharZero K
-- NumberField.to_finiteDimensional
class NumberField (K : Type*) [Field K] : Prop where
  [to_charZero : CharZero K]
  [to_finiteDimensional : FiniteDimensional ℚ K]
Arguments: {K : Type u_1} [Field K] [self : NumberField K]
Goal: FiniteDimensional ℚ K
-- Int.not_isField
theorem Int.not_isField : ¬IsField ℤ 
Goal: ¬IsField ℤ
-- NumberField.isAlgebraic
protected theorem isAlgebraic : Algebra.IsAlgebraic ℚ K 
Arguments: (K : Type u_1) [Field K] [nf : NumberField K]
Goal: Algebra.IsAlgebraic ℚ K
-- NumberField.RingOfIntegers.coe_eq_algebraMap
lemma coe_eq_algebraMap (x : 𝓞 K) : (x : K) = algebraMap _ _ x 
Arguments: {K : Type u_1} [Field K] (x : NumberField.RingOfIntegers K)
Goal: ↑x = (algebraMap (NumberField.RingOfIntegers K) K) x
-- NumberField.RingOfIntegers.ext
@[ext] theorem ext {x y : 𝓞 K} (h : (x : K) = (y : K)) : x = y 
Arguments: {K : Type u_1} [Field K] {x y : NumberField.RingOfIntegers K} (h : ↑x = ↑y)
Goal: x = y
-- NumberField.RingOfIntegers.ext_iff
theorem ext_iff {x y : 𝓞 K} : x = y ↔ (x : K) = (y : K) 
Arguments: {K : Type u_1} [Field K] {x y : NumberField.RingOfIntegers K}
Goal: x = y ↔ ↑x = ↑y
-- NumberField.RingOfIntegers.eq_iff
@[norm_cast]
theorem eq_iff {x y : 𝓞 K} : (x : K) = (y : K) ↔ x = y 
Arguments: {K : Type u_1} [Field K] {x y : NumberField.RingOfIntegers K}
Goal: ↑x = ↑y ↔ x = y
-- NumberField.RingOfIntegers.map_mk
@[simp] lemma map_mk (x : K) (hx) : algebraMap (𝓞 K) K ⟨x, hx⟩ = x 
Arguments: {K : Type u_1} [Field K] (x : K) (hx : x ∈ integralClosure ℤ K)
Goal: (algebraMap (NumberField.RingOfIntegers K) K) ⟨x, hx⟩ = x
-- NumberField.RingOfIntegers.coe_mk
lemma coe_mk {x : K} (hx) : ((⟨x, hx⟩ : 𝓞 K) : K) = x 
Arguments: {K : Type u_1} [Field K] {x : K} (hx : x ∈ integralClosure ℤ K)
Goal: ↑⟨x, hx⟩ = x
-- NumberField.RingOfIntegers.mk_eq_mk
lemma mk_eq_mk (x y : K) (hx hy) : (⟨x, hx⟩ : 𝓞 K) = ⟨y, hy⟩ ↔ x = y 
Arguments: {K : Type u_1} [Field K] (x y : K) (hx : x ∈ integralClosure ℤ K) (hy : y ∈ integralClosure ℤ K)
Goal: ⟨x, hx⟩ = ⟨y, hy⟩ ↔ x = y
-- NumberField.RingOfIntegers.mk_one
@[simp] lemma mk_one : (⟨1, one_mem _⟩ : 𝓞 K) = 1 
Arguments: {K : Type u_1} [Field K]
Goal: ⟨1, ⋯⟩ = 1
-- NumberField.RingOfIntegers.mk_zero
@[simp] lemma mk_zero : (⟨0, zero_mem _⟩ : 𝓞 K) = 0 
Arguments: {K : Type u_1} [Field K]
Goal: ⟨0, ⋯⟩ = 0
-- NumberField.RingOfIntegers.mk_add_mk
@[simp] lemma mk_add_mk (x y : K) (hx hy) : (⟨x, hx⟩ : 𝓞 K) + ⟨y, hy⟩ = ⟨x + y, add_mem hx hy⟩ 
Arguments: {K : Type u_1} [Field K] (x y : K) (hx : x ∈ integralClosure ℤ K) (hy : y ∈ integralClosure ℤ K)
Goal: ⟨x, hx⟩ + ⟨y, hy⟩ = ⟨x + y, ⋯⟩
-- NumberField.RingOfIntegers.mk_mul_mk
@[simp] lemma mk_mul_mk (x y : K) (hx hy) : (⟨x, hx⟩ : 𝓞 K) * ⟨y, hy⟩ = ⟨x * y, mul_mem hx hy⟩ 
Arguments: {K : Type u_1} [Field K] (x y : K) (hx : x ∈ integralClosure ℤ K) (hy : y ∈ integralClosure ℤ K)
Goal: ⟨x, hx⟩ * ⟨y, hy⟩ = ⟨x * y, ⋯⟩
-- NumberField.RingOfIntegers.mk_sub_mk
@[simp] lemma mk_sub_mk (x y : K) (hx hy) : (⟨x, hx⟩ : 𝓞 K) - ⟨y, hy⟩ = ⟨x - y, sub_mem hx hy⟩ 
Arguments: {K : Type u_1} [Field K] (x y : K) (hx : x ∈ integralClosure ℤ K) (hy : y ∈ integralClosure ℤ K)
Goal: ⟨x, hx⟩ - ⟨y, hy⟩ = ⟨x - y, ⋯⟩
-- NumberField.RingOfIntegers.neg_mk
@[simp] lemma neg_mk (x : K) (hx) : (-⟨x, hx⟩ : 𝓞 K) = ⟨-x, neg_mem hx⟩ 
Arguments: {K : Type u_1} [Field K] (x : K) (hx : x ∈ integralClosure ℤ K)
Goal: -⟨x, hx⟩ = ⟨-x, ⋯⟩
-- NumberField.RingOfIntegers.coe_injective
lemma coe_injective : Function.Injective (algebraMap (𝓞 K) K) 
Arguments: {K : Type u_1} [Field K]
Goal: Function.Injective ⇑(algebraMap (NumberField.RingOfIntegers K) K)
-- NumberField.RingOfIntegers.coe_eq_zero_iff
@[simp] lemma coe_eq_zero_iff {x : 𝓞 K} : algebraMap _ K x = 0 ↔ x = 0 
Arguments: {K : Type u_1} [Field K] {x : NumberField.RingOfIntegers K}
Goal: (algebraMap (NumberField.RingOfIntegers K) K) x = 0 ↔ x = 0
-- NumberField.RingOfIntegers.coe_ne_zero_iff
lemma coe_ne_zero_iff {x : 𝓞 K} : algebraMap _ K x ≠ 0 ↔ x ≠ 0 
Arguments: {K : Type u_1} [Field K] {x : NumberField.RingOfIntegers K}
Goal: (algebraMap (NumberField.RingOfIntegers K) K) x ≠ 0 ↔ x ≠ 0
-- NumberField.RingOfIntegers.isIntegral_coe
theorem isIntegral_coe (x : 𝓞 K) : IsIntegral ℤ (algebraMap _ K x) 
Arguments: {K : Type u_1} [Field K] (x : NumberField.RingOfIntegers K)
Goal: IsIntegral ℤ ((algebraMap (NumberField.RingOfIntegers K) K) x)
-- NumberField.RingOfIntegers.isIntegral
theorem isIntegral (x : 𝓞 K) : IsIntegral ℤ x 
Arguments: {K : Type u_1} [Field K] (x : NumberField.RingOfIntegers K)
Goal: IsIntegral ℤ x
-- NumberField.RingOfIntegers.not_isField
theorem not_isField : ¬IsField (𝓞 K) 
Arguments: (K : Type u_1) [Field K] [nf : NumberField K]
Goal: ¬IsField (NumberField.RingOfIntegers K)