ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib.Meta.NormNum.IsRat.neg_to_eq
theorem IsRat.neg_to_eq {α} [DivisionRing α] {n d} :
    {a n' d' : α} → IsRat a (.negOfNat n) d → n = n' → d = d' → a = -(n' / d')
  
Arguments: {α : Type u_1} [DivisionRing α] {n d : ℕ} {a n' d' : α}
Goal: Mathlib.Meta.NormNum.IsRat a (Int.negOfNat n) d → ↑n = n' → ↑d = d' → a = -(n' / d')
-- Mathlib.Meta.NormNum.IsRat.nonneg_to_eq
theorem IsRat.nonneg_to_eq {α} [DivisionRing α] {n d} :
    {a n' d' : α} → IsRat a (.ofNat n) d → n = n' → d = d' → a = n' / d'
  
Arguments: {α : Type u_1} [DivisionRing α] {n d : ℕ} {a n' d' : α}
Goal: Mathlib.Meta.NormNum.IsRat a (Int.ofNat n) d → ↑n = n' → ↑d = d' → a = n' / d'
-- Mathlib.Meta.NormNum.IsRat.of_raw
theorem IsRat.of_raw (α) [DivisionRing α] (n : ℤ) (d : ℕ)
    (h : (d : α) ≠ 0) : IsRat (Rat.rawCast n d : α) n d 
Arguments: (α : Type u_1) [DivisionRing α] (n : ℤ) (d : ℕ) (h : ↑d ≠ 0)
Goal: Mathlib.Meta.NormNum.IsRat (Rat.rawCast n d) n d
-- Mathlib.Meta.NormNum.IsRat.den_nz
theorem IsRat.den_nz {α} [DivisionRing α] {a n d} : IsRat (a : α) n d → (d : α) ≠ 0
  
Arguments: {α : Type u_1} [DivisionRing α] {a : α} {n : ℤ} {d : ℕ}
Goal: Mathlib.Meta.NormNum.IsRat a n d → ↑d ≠ 0
-- Mathlib.Meta.NormNum.not_prime_mul_of_ble
theorem not_prime_mul_of_ble (a b n : ℕ) (h : a * b = n) (h₁ : a.ble 1 = false)
    (h₂ : b.ble 1 = false) : ¬ n.Prime 
Arguments: (a b n : ℕ) (h : a * b = n) (h₁ : a.ble 1 = false) (h₂ : b.ble 1 = false)
Goal: ¬Nat.Prime n
-- Mathlib.Meta.NormNum.MinFacHelper.one_lt
theorem MinFacHelper.one_lt {n k : ℕ} (h : MinFacHelper n k) : 1 < n 
Arguments: {n k : ℕ} (h : Mathlib.Meta.NormNum.MinFacHelper n k)
Goal: 1 < n
-- Mathlib.Meta.NormNum.minFacHelper_0
theorem minFacHelper_0 (n : ℕ)
    (h1 : Nat.ble (nat_lit 2) n = true) (h2 : nat_lit 1 = n % (nat_lit 2)) :
    MinFacHelper n (nat_lit 3) 
Arguments: (n : ℕ) (h1 : Nat.ble 2 n = true) (h2 : 1 = n % 2)
Goal: Mathlib.Meta.NormNum.MinFacHelper n 3
-- Mathlib.Meta.NormNum.minFacHelper_1
theorem minFacHelper_1 {n k k' : ℕ} (e : k + 2 = k') (h : MinFacHelper n k)
    (np : minFac n ≠ k) : MinFacHelper n k' 
Arguments: {n k k' : ℕ} (e : k + 2 = k') (h : Mathlib.Meta.NormNum.MinFacHelper n k) (np : n.minFac ≠ k)
Goal: Mathlib.Meta.NormNum.MinFacHelper n k'
-- Mathlib.Meta.NormNum.minFacHelper_2
theorem minFacHelper_2 {n k k' : ℕ} (e : k + 2 = k') (nk : ¬ Nat.Prime k)
    (h : MinFacHelper n k) : MinFacHelper n k' 
Arguments: {n k k' : ℕ} (e : k + 2 = k') (nk : ¬Nat.Prime k) (h : Mathlib.Meta.NormNum.MinFacHelper n k)
Goal: Mathlib.Meta.NormNum.MinFacHelper n k'
-- Mathlib.Meta.NormNum.minFacHelper_3
theorem minFacHelper_3 {n k k' : ℕ} (e : k + 2 = k') (nk : (n % k).beq 0 = false)
    (h : MinFacHelper n k) : MinFacHelper n k' 
Arguments: {n k k' : ℕ} (e : k + 2 = k') (nk : (n % k).beq 0 = false) (h : Mathlib.Meta.NormNum.MinFacHelper n k)
Goal: Mathlib.Meta.NormNum.MinFacHelper n k'
-- Mathlib.Meta.NormNum.isNat_minFac_1
theorem isNat_minFac_1 : {a : ℕ} → IsNat a (nat_lit 1) → IsNat a.minFac 1
  
Arguments: {a : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat a 1 → Mathlib.Meta.NormNum.IsNat a.minFac 1
-- Mathlib.Meta.NormNum.isNat_minFac_2
theorem isNat_minFac_2 : {a a' : ℕ} → IsNat a a' → a' % 2 = 0 → IsNat a.minFac 2
  
Arguments: {a a' : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat a a' → a' % 2 = 0 → Mathlib.Meta.NormNum.IsNat a.minFac 2
-- Mathlib.Meta.NormNum.isNat_minFac_3
theorem isNat_minFac_3 : {n n' : ℕ} → (k : ℕ) →
    IsNat n n' → MinFacHelper n' k → nat_lit 0 = n' % k → IsNat (minFac n) k
  
Arguments: {n n' : ℕ} (k : ℕ)
Goal: Mathlib.Meta.NormNum.IsNat n n' →
  Mathlib.Meta.NormNum.MinFacHelper n' k → 0 = n' % k → Mathlib.Meta.NormNum.IsNat n.minFac k
-- Mathlib.Meta.NormNum.isNat_minFac_4
theorem isNat_minFac_4 : {n n' k : ℕ} →
    IsNat n n' → MinFacHelper n' k → (k * k).ble n' = false → IsNat (minFac n) n'
  
Arguments: {n n' k : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat n n' →
  Mathlib.Meta.NormNum.MinFacHelper n' k → (k * k).ble n' = false → Mathlib.Meta.NormNum.IsNat n.minFac n'
-- Mathlib.Meta.NormNum.isNat_prime_0
theorem isNat_prime_0 : {n : ℕ} → IsNat n (nat_lit 0) → ¬ n.Prime
  
Arguments: {n : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat n 0 → ¬Nat.Prime n
-- Mathlib.Meta.NormNum.isNat_prime_1
theorem isNat_prime_1 : {n : ℕ} → IsNat n (nat_lit 1) → ¬ n.Prime
  
Arguments: {n : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat n 1 → ¬Nat.Prime n
-- Mathlib.Meta.NormNum.isNat_prime_2
theorem isNat_prime_2 : {n n' : ℕ} →
    IsNat n n' → Nat.ble 2 n' = true → IsNat (minFac n') n' → n.Prime
  
Arguments: {n n' : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat n n' → Nat.ble 2 n' = true → Mathlib.Meta.NormNum.IsNat n'.minFac n' → Nat.Prime n
-- Mathlib.Meta.NormNum.isNat_not_prime
theorem isNat_not_prime {n n' : ℕ} (h : IsNat n n') : ¬n'.Prime → ¬n.Prime 
Arguments: {n n' : ℕ} (h : Mathlib.Meta.NormNum.IsNat n n')
Goal: ¬Nat.Prime n' → ¬Nat.Prime n
-- Mathlib.Meta.NormNum.isRat_mkRat
theorem isRat_mkRat : {a na n : ℤ} → {b nb d : ℕ} → IsInt a na → IsNat b nb →
    IsRat (na / nb : ℚ) n d → IsRat (mkRat a b) n d
  
Arguments: {a na n : ℤ} {b nb d : ℕ}
Goal: Mathlib.Meta.NormNum.IsInt a na →
  Mathlib.Meta.NormNum.IsNat b nb →
    Mathlib.Meta.NormNum.IsRat (↑na / ↑nb) n d → Mathlib.Meta.NormNum.IsRat (mkRat a b) n d
-- Mathlib.Meta.NormNum.isNat_ratCast
theorem isNat_ratCast {R : Type*} [DivisionRing R] : {q : ℚ} → {n : ℕ} →
    IsNat q n → IsNat (q : R) n
  
Arguments: {R : Type u_1} [DivisionRing R] {q : ℚ} {n : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat q n → Mathlib.Meta.NormNum.IsNat (↑q) n
-- Mathlib.Meta.NormNum.isInt_ratCast
theorem isInt_ratCast {R : Type*} [DivisionRing R] : {q : ℚ} → {n : ℤ} →
    IsInt q n → IsInt (q : R) n
  
Arguments: {R : Type u_1} [DivisionRing R] {q : ℚ} {n : ℤ}
Goal: Mathlib.Meta.NormNum.IsInt q n → Mathlib.Meta.NormNum.IsInt (↑q) n
-- Mathlib.Meta.NormNum.isRat_ratCast
theorem isRat_ratCast {R : Type*} [DivisionRing R] [CharZero R] : {q : ℚ} → {n : ℤ} → {d : ℕ} →
    IsRat q n d → IsRat (q : R) n d
  
Arguments: {R : Type u_1} [DivisionRing R] [CharZero R] {q : ℚ} {n : ℤ} {d : ℕ}
Goal: Mathlib.Meta.NormNum.IsRat q n d → Mathlib.Meta.NormNum.IsRat (↑q) n d
-- Mathlib.Meta.NormNum.isRat_inv_pos
theorem isRat_inv_pos {α} [DivisionRing α] [CharZero α] {a : α} {n d : ℕ} :
    IsRat a (.ofNat (Nat.succ n)) d → IsRat a⁻¹ (.ofNat d) (Nat.succ n) 
Arguments: {α : Type u_1} [DivisionRing α] [CharZero α] {a : α} {n d : ℕ}
Goal: Mathlib.Meta.NormNum.IsRat a (Int.ofNat n.succ) d → Mathlib.Meta.NormNum.IsRat a⁻¹ (Int.ofNat d) n.succ
-- Mathlib.Meta.NormNum.isRat_inv_one
theorem isRat_inv_one {α} [DivisionRing α] : {a : α} →
    IsNat a (nat_lit 1) → IsNat a⁻¹ (nat_lit 1)
  
Arguments: {α : Type u_1} [DivisionRing α] {a : α}
Goal: Mathlib.Meta.NormNum.IsNat a 1 → Mathlib.Meta.NormNum.IsNat a⁻¹ 1
-- Mathlib.Meta.NormNum.isRat_inv_zero
theorem isRat_inv_zero {α} [DivisionRing α] : {a : α} →
    IsNat a (nat_lit 0) → IsNat a⁻¹ (nat_lit 0)
  
Arguments: {α : Type u_1} [DivisionRing α] {a : α}
Goal: Mathlib.Meta.NormNum.IsNat a 0 → Mathlib.Meta.NormNum.IsNat a⁻¹ 0
-- Mathlib.Meta.NormNum.isRat_inv_neg_one
theorem isRat_inv_neg_one {α} [DivisionRing α] : {a : α} →
    IsInt a (.negOfNat (nat_lit 1)) → IsInt a⁻¹ (.negOfNat (nat_lit 1))
  
Arguments: {α : Type u_1} [DivisionRing α] {a : α}
Goal: Mathlib.Meta.NormNum.IsInt a (Int.negOfNat 1) → Mathlib.Meta.NormNum.IsInt a⁻¹ (Int.negOfNat 1)
-- Mathlib.Meta.NormNum.isRat_inv_neg
theorem isRat_inv_neg {α} [DivisionRing α] [CharZero α] {a : α} {n d : ℕ} :
    IsRat a (.negOfNat (Nat.succ n)) d → IsRat a⁻¹ (.negOfNat d) (Nat.succ n) 
Arguments: {α : Type u_1} [DivisionRing α] [CharZero α] {a : α} {n d : ℕ}
Goal: Mathlib.Meta.NormNum.IsRat a (Int.negOfNat n.succ) d → Mathlib.Meta.NormNum.IsRat a⁻¹ (Int.negOfNat d) n.succ
-- Mathlib.Meta.NormNum.jacobiSymNat.zero_right
theorem jacobiSymNat.zero_right (a : ℕ) : jacobiSymNat a 0 = 1 
Arguments: (a : ℕ)
Goal: Mathlib.Meta.NormNum.jacobiSymNat a 0 = 1
-- Mathlib.Meta.NormNum.jacobiSymNat.one_right
theorem jacobiSymNat.one_right (a : ℕ) : jacobiSymNat a 1 = 1 
Arguments: (a : ℕ)
Goal: Mathlib.Meta.NormNum.jacobiSymNat a 1 = 1
-- Mathlib.Meta.NormNum.jacobiSymNat.zero_left
theorem jacobiSymNat.zero_left (b : ℕ) (hb : Nat.beq (b / 2) 0 = false) : jacobiSymNat 0 b = 0 
Arguments: (b : ℕ) (hb : (b / 2).beq 0 = false)
Goal: Mathlib.Meta.NormNum.jacobiSymNat 0 b = 0
-- Mathlib.Meta.NormNum.jacobiSymNat.one_left
theorem jacobiSymNat.one_left (b : ℕ) : jacobiSymNat 1 b = 1 
Arguments: (b : ℕ)
Goal: Mathlib.Meta.NormNum.jacobiSymNat 1 b = 1
-- Mathlib.Meta.NormNum.LegendreSym.to_jacobiSym
theorem LegendreSym.to_jacobiSym (p : ℕ) (pp : Fact p.Prime) (a r : ℤ)
    (hr : IsInt (jacobiSym a p) r) : IsInt (legendreSym p a) r 
Arguments: (p : ℕ) (pp : Fact (Nat.Prime p)) (a r : ℤ) (hr : Mathlib.Meta.NormNum.IsInt (jacobiSym a p) r)
Goal: Mathlib.Meta.NormNum.IsInt (legendreSym p a) r
-- Mathlib.Meta.NormNum.JacobiSym.mod_left
theorem JacobiSym.mod_left (a : ℤ) (b ab' : ℕ) (ab r b' : ℤ) (hb' : (b : ℤ) = b')
    (hab : a % b' = ab) (h : (ab' : ℤ) = ab) (hr : jacobiSymNat ab' b = r) : jacobiSym a b = r 
Arguments: (a : ℤ) (b ab' : ℕ) (ab r b' : ℤ) (hb' : ↑b = b') (hab : a % b' = ab) (h : ↑ab' = ab) (hr : Mathlib.Meta.NormNum.jacobiSymNat ab' b = r)
Goal: jacobiSym a b = r
-- Mathlib.Meta.NormNum.jacobiSymNat.mod_left
theorem jacobiSymNat.mod_left (a b ab : ℕ) (r : ℤ) (hab : a % b = ab) (hr : jacobiSymNat ab b = r) :
    jacobiSymNat a b = r 
Arguments: (a b ab : ℕ) (r : ℤ) (hab : a % b = ab) (hr : Mathlib.Meta.NormNum.jacobiSymNat ab b = r)
Goal: Mathlib.Meta.NormNum.jacobiSymNat a b = r
-- Mathlib.Meta.NormNum.jacobiSymNat.even_even
theorem jacobiSymNat.even_even (a b : ℕ) (hb₀ : Nat.beq (b / 2) 0 = false) (ha : a % 2 = 0)
    (hb₁ : b % 2 = 0) : jacobiSymNat a b = 0 
Arguments: (a b : ℕ) (hb₀ : (b / 2).beq 0 = false) (ha : a % 2 = 0) (hb₁ : b % 2 = 0)
Goal: Mathlib.Meta.NormNum.jacobiSymNat a b = 0
-- Mathlib.Meta.NormNum.jacobiSymNat.odd_even
theorem jacobiSymNat.odd_even (a b c : ℕ) (r : ℤ) (ha : a % 2 = 1) (hb : b % 2 = 0) (hc : b / 2 = c)
    (hr : jacobiSymNat a c = r) : jacobiSymNat a b = r 
Arguments: (a b c : ℕ) (r : ℤ) (ha : a % 2 = 1) (hb : b % 2 = 0) (hc : b / 2 = c) (hr : Mathlib.Meta.NormNum.jacobiSymNat a c = r)
Goal: Mathlib.Meta.NormNum.jacobiSymNat a b = r
-- Mathlib.Meta.NormNum.jacobiSymNat.double_even
theorem jacobiSymNat.double_even (a b c : ℕ) (r : ℤ) (ha : a % 4 = 0) (hb : b % 2 = 1)
    (hc : a / 4 = c) (hr : jacobiSymNat c b = r) : jacobiSymNat a b = r 
Arguments: (a b c : ℕ) (r : ℤ) (ha : a % 4 = 0) (hb : b % 2 = 1) (hc : a / 4 = c) (hr : Mathlib.Meta.NormNum.jacobiSymNat c b = r)
Goal: Mathlib.Meta.NormNum.jacobiSymNat a b = r
-- Mathlib.Meta.NormNum.jacobiSymNat.even_odd₁
theorem jacobiSymNat.even_odd₁ (a b c : ℕ) (r : ℤ) (ha : a % 2 = 0) (hb : b % 8 = 1)
    (hc : a / 2 = c) (hr : jacobiSymNat c b = r) : jacobiSymNat a b = r 
Arguments: (a b c : ℕ) (r : ℤ) (ha : a % 2 = 0) (hb : b % 8 = 1) (hc : a / 2 = c) (hr : Mathlib.Meta.NormNum.jacobiSymNat c b = r)
Goal: Mathlib.Meta.NormNum.jacobiSymNat a b = r
-- Mathlib.Meta.NormNum.jacobiSymNat.even_odd₇
theorem jacobiSymNat.even_odd₇ (a b c : ℕ) (r : ℤ) (ha : a % 2 = 0) (hb : b % 8 = 7)
    (hc : a / 2 = c) (hr : jacobiSymNat c b = r) : jacobiSymNat a b = r 
Arguments: (a b c : ℕ) (r : ℤ) (ha : a % 2 = 0) (hb : b % 8 = 7) (hc : a / 2 = c) (hr : Mathlib.Meta.NormNum.jacobiSymNat c b = r)
Goal: Mathlib.Meta.NormNum.jacobiSymNat a b = r
-- Mathlib.Meta.NormNum.jacobiSymNat.even_odd₃
theorem jacobiSymNat.even_odd₃ (a b c : ℕ) (r : ℤ) (ha : a % 2 = 0) (hb : b % 8 = 3)
    (hc : a / 2 = c) (hr : jacobiSymNat c b = r) : jacobiSymNat a b = -r 
Arguments: (a b c : ℕ) (r : ℤ) (ha : a % 2 = 0) (hb : b % 8 = 3) (hc : a / 2 = c) (hr : Mathlib.Meta.NormNum.jacobiSymNat c b = r)
Goal: Mathlib.Meta.NormNum.jacobiSymNat a b = -r
-- Mathlib.Meta.NormNum.jacobiSymNat.even_odd₅
theorem jacobiSymNat.even_odd₅ (a b c : ℕ) (r : ℤ) (ha : a % 2 = 0) (hb : b % 8 = 5)
    (hc : a / 2 = c) (hr : jacobiSymNat c b = r) : jacobiSymNat a b = -r 
Arguments: (a b c : ℕ) (r : ℤ) (ha : a % 2 = 0) (hb : b % 8 = 5) (hc : a / 2 = c) (hr : Mathlib.Meta.NormNum.jacobiSymNat c b = r)
Goal: Mathlib.Meta.NormNum.jacobiSymNat a b = -r
-- Mathlib.Meta.NormNum.jacobiSymNat.qr₁
theorem jacobiSymNat.qr₁ (a b : ℕ) (r : ℤ) (ha : a % 4 = 1) (hb : b % 2 = 1)
    (hr : jacobiSymNat b a = r) : jacobiSymNat a b = r 
Arguments: (a b : ℕ) (r : ℤ) (ha : a % 4 = 1) (hb : b % 2 = 1) (hr : Mathlib.Meta.NormNum.jacobiSymNat b a = r)
Goal: Mathlib.Meta.NormNum.jacobiSymNat a b = r
-- Mathlib.Meta.NormNum.jacobiSymNat.qr₁_mod
theorem jacobiSymNat.qr₁_mod (a b ab : ℕ) (r : ℤ) (ha : a % 4 = 1) (hb : b % 2 = 1)
    (hab : b % a = ab) (hr : jacobiSymNat ab a = r) : jacobiSymNat a b = r 
Arguments: (a b ab : ℕ) (r : ℤ) (ha : a % 4 = 1) (hb : b % 2 = 1) (hab : b % a = ab) (hr : Mathlib.Meta.NormNum.jacobiSymNat ab a = r)
Goal: Mathlib.Meta.NormNum.jacobiSymNat a b = r
-- Mathlib.Meta.NormNum.jacobiSymNat.qr₁'
theorem jacobiSymNat.qr₁' (a b : ℕ) (r : ℤ) (ha : a % 2 = 1) (hb : b % 4 = 1)
    (hr : jacobiSymNat b a = r) : jacobiSymNat a b = r 
Arguments: (a b : ℕ) (r : ℤ) (ha : a % 2 = 1) (hb : b % 4 = 1) (hr : Mathlib.Meta.NormNum.jacobiSymNat b a = r)
Goal: Mathlib.Meta.NormNum.jacobiSymNat a b = r
-- Mathlib.Meta.NormNum.jacobiSymNat.qr₁'_mod
theorem jacobiSymNat.qr₁'_mod (a b ab : ℕ) (r : ℤ) (ha : a % 2 = 1) (hb : b % 4 = 1)
    (hab : b % a = ab) (hr : jacobiSymNat ab a = r) : jacobiSymNat a b = r 
Arguments: (a b ab : ℕ) (r : ℤ) (ha : a % 2 = 1) (hb : b % 4 = 1) (hab : b % a = ab) (hr : Mathlib.Meta.NormNum.jacobiSymNat ab a = r)
Goal: Mathlib.Meta.NormNum.jacobiSymNat a b = r
-- Mathlib.Meta.NormNum.jacobiSymNat.qr₃
theorem jacobiSymNat.qr₃ (a b : ℕ) (r : ℤ) (ha : a % 4 = 3) (hb : b % 4 = 3)
    (hr : jacobiSymNat b a = r) : jacobiSymNat a b = -r 
Arguments: (a b : ℕ) (r : ℤ) (ha : a % 4 = 3) (hb : b % 4 = 3) (hr : Mathlib.Meta.NormNum.jacobiSymNat b a = r)
Goal: Mathlib.Meta.NormNum.jacobiSymNat a b = -r
-- Mathlib.Meta.NormNum.jacobiSymNat.qr₃_mod
theorem jacobiSymNat.qr₃_mod (a b ab : ℕ) (r : ℤ) (ha : a % 4 = 3) (hb : b % 4 = 3)
    (hab : b % a = ab) (hr : jacobiSymNat ab a = r) : jacobiSymNat a b = -r 
Arguments: (a b ab : ℕ) (r : ℤ) (ha : a % 4 = 3) (hb : b % 4 = 3) (hab : b % a = ab) (hr : Mathlib.Meta.NormNum.jacobiSymNat ab a = r)
Goal: Mathlib.Meta.NormNum.jacobiSymNat a b = -r
-- Mathlib.Meta.NormNum.isInt_jacobiSym
theorem isInt_jacobiSym : {a na : ℤ} → {b nb : ℕ} → {r : ℤ} →
    IsInt a na → IsNat b nb → jacobiSym na nb = r → IsInt (jacobiSym a b) r
  
Arguments: {a na : ℤ} {b nb : ℕ} {r : ℤ}
Goal: Mathlib.Meta.NormNum.IsInt a na →
  Mathlib.Meta.NormNum.IsNat b nb → jacobiSym na nb = r → Mathlib.Meta.NormNum.IsInt (jacobiSym a b) r
-- Mathlib.Meta.NormNum.isInt_jacobiSymNat
theorem isInt_jacobiSymNat : {a na : ℕ} → {b nb : ℕ} → {r : ℤ} →
    IsNat a na → IsNat b nb → jacobiSymNat na nb = r → IsInt (jacobiSymNat a b) r
  
Arguments: {a na b nb : ℕ} {r : ℤ}
Goal: Mathlib.Meta.NormNum.IsNat a na →
  Mathlib.Meta.NormNum.IsNat b nb →
    Mathlib.Meta.NormNum.jacobiSymNat na nb = r → Mathlib.Meta.NormNum.IsInt (Mathlib.Meta.NormNum.jacobiSymNat a b) r
-- Mathlib.Meta.NormNum.natPow_zero
theorem natPow_zero : Nat.pow a (nat_lit 0) = nat_lit 1 
Arguments: {a : ℕ}
Goal: a.pow 0 = 1
-- Mathlib.Meta.NormNum.natPow_one
theorem natPow_one : Nat.pow a (nat_lit 1) = a 
Arguments: {a : ℕ}
Goal: a.pow 1 = a
-- Mathlib.Meta.NormNum.zero_natPow
theorem zero_natPow : Nat.pow (nat_lit 0) (Nat.succ b) = nat_lit 0 
Arguments: {b : ℕ}
Goal: Nat.pow 0 b.succ = 0
-- Mathlib.Meta.NormNum.one_natPow
theorem one_natPow : Nat.pow (nat_lit 1) b = nat_lit 1 
Arguments: {b : ℕ}
Goal: Nat.pow 1 b = 1
-- Mathlib.Meta.NormNum.IsNatPowT.run'
structure IsNatPowT (p : Prop) (a b c : Nat) : Prop where
    run' : p → Nat.pow a b = c
Arguments: {p : Prop} {a b c : ℕ} (self : Mathlib.Meta.NormNum.IsNatPowT p a b c)
Goal: p → a.pow b = c
-- Mathlib.Meta.NormNum.IsNatPowT.run
theorem IsNatPowT.run
    (p : IsNatPowT (Nat.pow a (nat_lit 1) = a) a b c) : Nat.pow a b = c 
Arguments: {a b c : ℕ} (p : Mathlib.Meta.NormNum.IsNatPowT (a.pow 1 = a) a b c)
Goal: a.pow b = c
-- Mathlib.Meta.NormNum.IsNatPowT.trans
theorem IsNatPowT.trans {p : Prop} {b' c' : ℕ} (h1 : IsNatPowT p a b c)
    (h2 : IsNatPowT (Nat.pow a b = c) a b' c') : IsNatPowT p a b' c' 
Arguments: {a b c : ℕ} {p : Prop} {b' c' : ℕ} (h1 : Mathlib.Meta.NormNum.IsNatPowT p a b c) (h2 : Mathlib.Meta.NormNum.IsNatPowT (a.pow b = c) a b' c')
Goal: Mathlib.Meta.NormNum.IsNatPowT p a b' c'
-- Mathlib.Meta.NormNum.IsNatPowT.bit0
theorem IsNatPowT.bit0 : IsNatPowT (Nat.pow a b = c) a (nat_lit 2 * b) (Nat.mul c c) 
Arguments: {a b c : ℕ}
Goal: Mathlib.Meta.NormNum.IsNatPowT (a.pow b = c) a (2 * b) (c.mul c)
-- Mathlib.Meta.NormNum.IsNatPowT.bit1
theorem IsNatPowT.bit1 :
    IsNatPowT (Nat.pow a b = c) a (nat_lit 2 * b + nat_lit 1) (Nat.mul c (Nat.mul c a)) 
Arguments: {a b c : ℕ}
Goal: Mathlib.Meta.NormNum.IsNatPowT (a.pow b = c) a (2 * b + 1) (c.mul (c.mul a))
-- Mathlib.Meta.NormNum.intPow_ofNat
theorem intPow_ofNat (h1 : Nat.pow a b = c) :
    Int.pow (Int.ofNat a) b = Int.ofNat c 
Arguments: {a b c : ℕ} (h1 : a.pow b = c)
Goal: (Int.ofNat a).pow b = Int.ofNat c
-- Mathlib.Meta.NormNum.intPow_negOfNat_bit0
theorem intPow_negOfNat_bit0 {b' c' : ℕ} (h1 : Nat.pow a b' = c')
    (hb : nat_lit 2 * b' = b) (hc : c' * c' = c) :
    Int.pow (Int.negOfNat a) b = Int.ofNat c 
Arguments: {a b c b' c' : ℕ} (h1 : a.pow b' = c') (hb : 2 * b' = b) (hc : c' * c' = c)
Goal: (Int.negOfNat a).pow b = Int.ofNat c
-- Mathlib.Meta.NormNum.intPow_negOfNat_bit1
theorem intPow_negOfNat_bit1 {b' c' : ℕ} (h1 : Nat.pow a b' = c')
    (hb : nat_lit 2 * b' + nat_lit 1 = b) (hc : c' * (c' * a) = c) :
    Int.pow (Int.negOfNat a) b = Int.negOfNat c 
Arguments: {a b c b' c' : ℕ} (h1 : a.pow b' = c') (hb : 2 * b' + 1 = b) (hc : c' * (c' * a) = c)
Goal: (Int.negOfNat a).pow b = Int.negOfNat c
-- Mathlib.Meta.NormNum.isNat_pow
theorem isNat_pow {α} [Semiring α] : ∀ {f : α → ℕ → α} {a : α} {b a' b' c : ℕ},
    f = HPow.hPow → IsNat a a' → IsNat b b' → Nat.pow a' b' = c → IsNat (f a b) c
  
Arguments: {α : Type u_1} [Semiring α] {f : α → ℕ → α} {a : α} {b a' b' c : ℕ}
Goal: f = HPow.hPow →
  Mathlib.Meta.NormNum.IsNat a a' →
    Mathlib.Meta.NormNum.IsNat b b' → a'.pow b' = c → Mathlib.Meta.NormNum.IsNat (f a b) c
-- Mathlib.Meta.NormNum.isInt_pow
theorem isInt_pow {α} [Ring α] : ∀ {f : α → ℕ → α} {a : α} {b : ℕ} {a' : ℤ} {b' : ℕ} {c : ℤ},
    f = HPow.hPow → IsInt a a' → IsNat b b' → Int.pow a' b' = c → IsInt (f a b) c
  
Arguments: {α : Type u_1} [Ring α] {f : α → ℕ → α} {a : α} {b : ℕ} {a' : ℤ} {b' : ℕ} {c : ℤ}
Goal: f = HPow.hPow →
  Mathlib.Meta.NormNum.IsInt a a' →
    Mathlib.Meta.NormNum.IsNat b b' → a'.pow b' = c → Mathlib.Meta.NormNum.IsInt (f a b) c
-- Mathlib.Meta.NormNum.isRat_pow
theorem isRat_pow {α} [Ring α] {f : α → ℕ → α} {a : α} {an cn : ℤ} {ad b b' cd : ℕ} :
    f = HPow.hPow → IsRat a an ad → IsNat b b' →
    Int.pow an b' = cn → Nat.pow ad b' = cd →
    IsRat (f a b) cn cd 
Arguments: {α : Type u_1} [Ring α] {f : α → ℕ → α} {a : α} {an cn : ℤ} {ad b b' cd : ℕ}
Goal: f = HPow.hPow →
  Mathlib.Meta.NormNum.IsRat a an ad →
    Mathlib.Meta.NormNum.IsNat b b' → an.pow b' = cn → ad.pow b' = cd → Mathlib.Meta.NormNum.IsRat (f a b) cn cd
-- Mathlib.Meta.NormNum.isNat_zpow_pos
theorem isNat_zpow_pos {α : Type*} [DivisionSemiring α] {a : α} {b : ℤ} {nb ne : ℕ}
    (pb : IsNat b nb) (pe' : IsNat (a ^ nb) ne) :
    IsNat (a ^ b) ne 
Arguments: {α : Type u_1} [DivisionSemiring α] {a : α} {b : ℤ} {nb ne : ℕ} (pb : Mathlib.Meta.NormNum.IsNat b nb) (pe' : Mathlib.Meta.NormNum.IsNat (a ^ nb) ne)
Goal: Mathlib.Meta.NormNum.IsNat (a ^ b) ne
-- Mathlib.Meta.NormNum.isNat_zpow_neg
theorem isNat_zpow_neg {α : Type*} [DivisionSemiring α] {a : α} {b : ℤ} {nb ne : ℕ}
    (pb : IsInt b (Int.negOfNat nb)) (pe' : IsNat (a ^ nb)⁻¹ ne) :
    IsNat (a ^ b) ne 
Arguments: {α : Type u_1} [DivisionSemiring α] {a : α} {b : ℤ} {nb ne : ℕ} (pb : Mathlib.Meta.NormNum.IsInt b (Int.negOfNat nb)) (pe' : Mathlib.Meta.NormNum.IsNat (a ^ nb)⁻¹ ne)
Goal: Mathlib.Meta.NormNum.IsNat (a ^ b) ne
-- Mathlib.Meta.NormNum.isInt_zpow_pos
theorem isInt_zpow_pos {α : Type*} [DivisionRing α] {a : α} {b : ℤ} {nb ne : ℕ}
    (pb : IsNat b nb) (pe' : IsInt (a ^ nb) (Int.negOfNat ne)) :
    IsInt (a ^ b) (Int.negOfNat ne) 
Arguments: {α : Type u_1} [DivisionRing α] {a : α} {b : ℤ} {nb ne : ℕ} (pb : Mathlib.Meta.NormNum.IsNat b nb) (pe' : Mathlib.Meta.NormNum.IsInt (a ^ nb) (Int.negOfNat ne))
Goal: Mathlib.Meta.NormNum.IsInt (a ^ b) (Int.negOfNat ne)
-- Mathlib.Meta.NormNum.isInt_zpow_neg
theorem isInt_zpow_neg {α : Type*} [DivisionRing α] {a : α} {b : ℤ} {nb ne : ℕ}
    (pb : IsInt b (Int.negOfNat nb)) (pe' : IsInt (a ^ nb)⁻¹ (Int.negOfNat ne)) :
    IsInt (a ^ b) (Int.negOfNat ne) 
Arguments: {α : Type u_1} [DivisionRing α] {a : α} {b : ℤ} {nb ne : ℕ} (pb : Mathlib.Meta.NormNum.IsInt b (Int.negOfNat nb)) (pe' : Mathlib.Meta.NormNum.IsInt (a ^ nb)⁻¹ (Int.negOfNat ne))
Goal: Mathlib.Meta.NormNum.IsInt (a ^ b) (Int.negOfNat ne)
-- Mathlib.Meta.NormNum.isRat_zpow_pos
theorem isRat_zpow_pos {α : Type*} [DivisionRing α] {a : α} {b : ℤ} {nb : ℕ}
    {num : ℤ} {den : ℕ}
    (pb : IsNat b nb) (pe' : IsRat (a^nb) num den) :
    IsRat (a^b) num den 
Arguments: {α : Type u_1} [DivisionRing α] {a : α} {b : ℤ} {nb : ℕ} {num : ℤ} {den : ℕ} (pb : Mathlib.Meta.NormNum.IsNat b nb) (pe' : Mathlib.Meta.NormNum.IsRat (a ^ nb) num den)
Goal: Mathlib.Meta.NormNum.IsRat (a ^ b) num den
-- Mathlib.Meta.NormNum.isRat_zpow_neg
theorem isRat_zpow_neg {α : Type*} [DivisionRing α] {a : α} {b : ℤ} {nb : ℕ}
    {num : ℤ} {den : ℕ}
    (pb : IsInt b (Int.negOfNat nb)) (pe' : IsRat ((a^nb)⁻¹) num den) :
    IsRat (a^b) num den 
Arguments: {α : Type u_1} [DivisionRing α] {a : α} {b : ℤ} {nb : ℕ} {num : ℤ} {den : ℕ} (pb : Mathlib.Meta.NormNum.IsInt b (Int.negOfNat nb)) (pe' : Mathlib.Meta.NormNum.IsRat (a ^ nb)⁻¹ num den)
Goal: Mathlib.Meta.NormNum.IsRat (a ^ b) num den
-- Mathlib.Meta.NormNum.isNat_le_true
theorem isNat_le_true [OrderedSemiring α] : {a b : α} → {a' b' : ℕ} →
    IsNat a a' → IsNat b b' → Nat.ble a' b' = true → a ≤ b
  
Arguments: {α : Type u_1} [OrderedSemiring α] {a b : α} {a' b' : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat a a' → Mathlib.Meta.NormNum.IsNat b b' → a'.ble b' = true → a ≤ b
-- Mathlib.Meta.NormNum.isNat_lt_false
theorem isNat_lt_false [OrderedSemiring α] {a b : α} {a' b' : ℕ}
    (ha : IsNat a a') (hb : IsNat b b') (h : Nat.ble b' a' = true) : ¬a < b 
Arguments: {α : Type u_1} [OrderedSemiring α] {a b : α} {a' b' : ℕ} (ha : Mathlib.Meta.NormNum.IsNat a a') (hb : Mathlib.Meta.NormNum.IsNat b b') (h : b'.ble a' = true)
Goal: ¬a < b
-- Mathlib.Meta.NormNum.isRat_le_true
theorem isRat_le_true [LinearOrderedRing α] : {a b : α} → {na nb : ℤ} → {da db : ℕ} →
    IsRat a na da → IsRat b nb db →
    decide (Int.mul na (.ofNat db) ≤ Int.mul nb (.ofNat da)) → a ≤ b
  
Arguments: {α : Type u_1} [LinearOrderedRing α] {a b : α} {na nb : ℤ} {da db : ℕ}
Goal: Mathlib.Meta.NormNum.IsRat a na da →
  Mathlib.Meta.NormNum.IsRat b nb db → decide (na.mul (Int.ofNat db) ≤ nb.mul (Int.ofNat da)) = true → a ≤ b
-- Mathlib.Meta.NormNum.isRat_lt_true
theorem isRat_lt_true [LinearOrderedRing α] [Nontrivial α] : {a b : α} → {na nb : ℤ} → {da db : ℕ} →
    IsRat a na da → IsRat b nb db → decide (na * db < nb * da) → a < b
  
Arguments: {α : Type u_1} [LinearOrderedRing α] [Nontrivial α] {a b : α} {na nb : ℤ} {da db : ℕ}
Goal: Mathlib.Meta.NormNum.IsRat a na da → Mathlib.Meta.NormNum.IsRat b nb db → decide (na * ↑db < nb * ↑da) = true → a < b
-- Mathlib.Meta.NormNum.isRat_le_false
theorem isRat_le_false [LinearOrderedRing α] [Nontrivial α] {a b : α} {na nb : ℤ} {da db : ℕ}
    (ha : IsRat a na da) (hb : IsRat b nb db) (h : decide (nb * da < na * db)) : ¬a ≤ b 
Arguments: {α : Type u_1} [LinearOrderedRing α] [Nontrivial α] {a b : α} {na nb : ℤ} {da db : ℕ} (ha : Mathlib.Meta.NormNum.IsRat a na da) (hb : Mathlib.Meta.NormNum.IsRat b nb db) (h : decide (nb * ↑da < na * ↑db) = true)
Goal: ¬a ≤ b