ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Behrend.dValue_pos
theorem dValue_pos (hN₃ : 8 ≤ N) : 0 < dValue N 
Arguments: {N : ℕ} (hN₃ : 8 ≤ N)
Goal: 0 < Behrend.dValue N
-- Behrend.le_N
theorem le_N (hN : 2 ≤ N) : (2 * dValue N - 1) ^ nValue N ≤ N 
Arguments: {N : ℕ} (hN : 2 ≤ N)
Goal: (2 * Behrend.dValue N - 1) ^ Behrend.nValue N ≤ N
-- Behrend.bound
theorem bound (hN : 4096 ≤ N) : (N : ℝ) ^ (nValue N : ℝ)⁻¹ / exp 1 < dValue N 
Arguments: {N : ℕ} (hN : 4096 ≤ N)
Goal: ↑N ^ (↑(Behrend.nValue N))⁻¹ / rexp 1 < ↑(Behrend.dValue N)
-- Behrend.roth_lower_bound_explicit
theorem roth_lower_bound_explicit (hN : 4096 ≤ N) :
    (N : ℝ) * exp (-4 * √(log N)) < rothNumberNat N 
Arguments: {N : ℕ} (hN : 4096 ≤ N)
Goal: ↑N * rexp (-4 * √(Real.log ↑N)) < ↑(rothNumberNat N)
-- Behrend.exp_four_lt
theorem exp_four_lt : exp 4 < 64 
Goal: rexp 4 < 64
-- Behrend.four_zero_nine_six_lt_exp_sixteen
theorem four_zero_nine_six_lt_exp_sixteen : 4096 < exp 16 
Goal: 4096 < rexp 16
-- Behrend.lower_bound_le_one'
theorem lower_bound_le_one' (hN : 2 ≤ N) (hN' : N ≤ 4096) :
    (N : ℝ) * exp (-4 * √(log N)) ≤ 1 
Arguments: {N : ℕ} (hN : 2 ≤ N) (hN' : N ≤ 4096)
Goal: ↑N * rexp (-4 * √(Real.log ↑N)) ≤ 1
-- Behrend.lower_bound_le_one
theorem lower_bound_le_one (hN : 1 ≤ N) (hN' : N ≤ 4096) :
    (N : ℝ) * exp (-4 * √(log N)) ≤ 1 
Arguments: {N : ℕ} (hN : 1 ≤ N) (hN' : N ≤ 4096)
Goal: ↑N * rexp (-4 * √(Real.log ↑N)) ≤ 1
-- Behrend.roth_lower_bound
theorem roth_lower_bound : (N : ℝ) * exp (-4 * √(log N)) ≤ rothNumberNat N 
Arguments: {N : ℕ}
Goal: ↑N * rexp (-4 * √(Real.log ↑N)) ≤ ↑(rothNumberNat N)
-- _private.Mathlib.Tactic.Peel.0.Mathlib.Tactic.Peel.and_imp_left_of_imp_imp
private lemma and_imp_left_of_imp_imp {p q r : Prop} (h : r → p → q) : r ∧ p → r ∧ q 
Arguments: {p q r : Prop} (h : r → p → q)
Goal: r ∧ p → r ∧ q
-- _private.Mathlib.Tactic.Peel.0.Mathlib.Tactic.Peel.eventually_imp
private theorem eventually_imp {α : Type*} {p q : α → Prop} {f : Filter α}
    (hq : ∀ (x : α), p x → q x) (hp : ∀ᶠ (x : α) in f, p x) : ∀ᶠ (x : α) in f, q x 
Arguments: {α : Type u_1} {p q : α → Prop} {f : Filter α} (hq : ∀ (x : α), p x → q x) (hp : ∀ᶠ (x : α) in f, p x)
Goal: ∀ᶠ (x : α) in f, q x
-- _private.Mathlib.Tactic.Peel.0.Mathlib.Tactic.Peel.frequently_imp
private theorem frequently_imp {α : Type*} {p q : α → Prop} {f : Filter α}
    (hq : ∀ (x : α), p x → q x) (hp : ∃ᶠ (x : α) in f, p x) : ∃ᶠ (x : α) in f, q x 
Arguments: {α : Type u_1} {p q : α → Prop} {f : Filter α} (hq : ∀ (x : α), p x → q x) (hp : ∃ᶠ (x : α) in f, p x)
Goal: ∃ᶠ (x : α) in f, q x
-- _private.Mathlib.Tactic.Peel.0.Mathlib.Tactic.Peel.eventually_congr
private theorem eventually_congr {α : Type*} {p q : α → Prop} {f : Filter α}
    (hq : ∀ (x : α), p x ↔ q x) : (∀ᶠ (x : α) in f, p x) ↔ ∀ᶠ (x : α) in f, q x 
Arguments: {α : Type u_1} {p q : α → Prop} {f : Filter α} (hq : ∀ (x : α), p x ↔ q x)
Goal: (∀ᶠ (x : α) in f, p x) ↔ ∀ᶠ (x : α) in f, q x
-- _private.Mathlib.Tactic.Peel.0.Mathlib.Tactic.Peel.frequently_congr
private theorem frequently_congr {α : Type*} {p q : α → Prop} {f : Filter α}
    (hq : ∀ (x : α), p x ↔ q x) : (∃ᶠ (x : α) in f, p x) ↔ ∃ᶠ (x : α) in f, q x 
Arguments: {α : Type u_1} {p q : α → Prop} {f : Filter α} (hq : ∀ (x : α), p x ↔ q x)
Goal: (∃ᶠ (x : α) in f, p x) ↔ ∃ᶠ (x : α) in f, q x
-- Sat.Fmla.subsumes.prop
structure Fmla.subsumes (f f' : Fmla) : Prop where
  prop : ∀ x, x ∈ f' → x ∈ f
Arguments: {f f' : Sat.Fmla} (self : f.subsumes f') (x : Sat.Clause)
Goal: x ∈ f' → x ∈ f
-- Sat.Fmla.subsumes_self
theorem Fmla.subsumes_self (f : Fmla) : f.subsumes f 
Arguments: (f : Sat.Fmla)
Goal: f.subsumes f
-- Sat.Fmla.subsumes_left
theorem Fmla.subsumes_left (f f₁ f₂ : Fmla) (H : f.subsumes (f₁.and f₂)) : f.subsumes f₁ 
Arguments: (f f₁ f₂ : Sat.Fmla) (H : f.subsumes (f₁.and f₂))
Goal: f.subsumes f₁
-- Sat.Fmla.subsumes_right
theorem Fmla.subsumes_right (f f₁ f₂ : Fmla) (H : f.subsumes (f₁.and f₂)) : f.subsumes f₂ 
Arguments: (f f₁ f₂ : Sat.Fmla) (H : f.subsumes (f₁.and f₂))
Goal: f.subsumes f₂
-- Sat.Valuation.satisfies_fmla.prop
structure Valuation.satisfies_fmla (v : Valuation) (f : Fmla) : Prop where
  prop : ∀ c, c ∈ f → v.satisfies c
Arguments: {v : Sat.Valuation} {f : Sat.Fmla} (self : v.satisfies_fmla f) (c : Sat.Clause)
Goal: c ∈ f → v.satisfies c
-- Sat.Fmla.proof_of_subsumes
theorem Fmla.proof_of_subsumes {f : Fmla} {c : Clause}
    (H : Fmla.subsumes f (Fmla.one c)) : f.proof c 
Arguments: {f : Sat.Fmla} {c : Sat.Clause} (H : f.subsumes (Sat.Fmla.one c))
Goal: f.proof c
-- Sat.Valuation.by_cases
theorem Valuation.by_cases {v : Valuation} {l}
    (h₁ : v.neg l.negate → False) (h₂ : v.neg l → False) : False 
Arguments: {v : Sat.Valuation} {l : Sat.Literal} (h₁ : v.neg l.negate → False) (h₂ : v.neg l → False)
Goal: False
-- Sat.Valuation.mk_implies
theorem Valuation.mk_implies {p} {as ps} (as₁) : as = List.reverseAux as₁ ps →
    (Valuation.mk as).implies p ps as₁.length → p 
Arguments: {p : Prop} {as ps : List Prop} (as₁ : List Prop)
Goal: as = as₁.reverseAux ps → (Sat.Valuation.mk as).implies p ps as₁.length → p
-- Sat.Fmla.reify.prop
structure Fmla.reify (v : Valuation) (f : Fmla) (p : Prop) : Prop where
  prop : ¬ v.satisfies_fmla f → p
Arguments: {v : Sat.Valuation} {f : Sat.Fmla} {p : Prop} (self : Sat.Fmla.reify v f p)
Goal: ¬v.satisfies_fmla f → p
-- Sat.Fmla.refute
theorem Fmla.refute {p : Prop} {ps} (f : Fmla) (hf : f.proof [])
    (hv : ∀ v, Valuation.implies v (Fmla.reify v f p) ps 0) : p 
Arguments: {p : Prop} {ps : List Prop} (f : Sat.Fmla) (hf : f.proof []) (hv : ∀ (v : Sat.Valuation), v.implies (Sat.Fmla.reify v f p) ps 0)
Goal: p
-- Sat.Fmla.reify_or
theorem Fmla.reify_or {f₁ : Fmla} {a : Prop} {f₂ : Fmla} {b : Prop}
    (h₁ : Fmla.reify v f₁ a) (h₂ : Fmla.reify v f₂ b) : Fmla.reify v (f₁.and f₂) (a ∨ b) 
Arguments: {v : Sat.Valuation} {f₁ : Sat.Fmla} {a : Prop} {f₂ : Sat.Fmla} {b : Prop} (h₁ : Sat.Fmla.reify v f₁ a) (h₂ : Sat.Fmla.reify v f₂ b)
Goal: Sat.Fmla.reify v (f₁.and f₂) (a ∨ b)
-- Sat.Clause.reify.prop
structure Clause.reify (v : Valuation) (c : Clause) (p : Prop) : Prop where
  prop : ¬ v.satisfies c → p
Arguments: {v : Sat.Valuation} {c : Sat.Clause} {p : Prop} (self : Sat.Clause.reify v c p)
Goal: ¬v.satisfies c → p
-- Sat.Fmla.reify_one
theorem Fmla.reify_one {c : Clause} {a : Prop} (h : Clause.reify v c a) :
    Fmla.reify v (Fmla.one c) a 
Arguments: {v : Sat.Valuation} {c : Sat.Clause} {a : Prop} (h : Sat.Clause.reify v c a)
Goal: Sat.Fmla.reify v (Sat.Fmla.one c) a
-- Sat.Literal.reify.prop
structure Literal.reify (v : Valuation) (l : Literal) (p : Prop) : Prop where
  prop : v.neg l → p
Arguments: {v : Sat.Valuation} {l : Sat.Literal} {p : Prop} (self : Sat.Literal.reify v l p)
Goal: v.neg l → p
-- Sat.Clause.reify_and
theorem Clause.reify_and {l : Literal} {a : Prop} {c : Clause} {b : Prop}
    (h₁ : Literal.reify v l a) (h₂ : Clause.reify v c b) :
    Clause.reify v (Clause.cons l c) (a ∧ b) 
Arguments: {v : Sat.Valuation} {l : Sat.Literal} {a : Prop} {c : Sat.Clause} {b : Prop} (h₁ : Sat.Literal.reify v l a) (h₂ : Sat.Clause.reify v c b)
Goal: Sat.Clause.reify v (Sat.Clause.cons l c) (a ∧ b)
-- Sat.Clause.reify_zero
theorem Clause.reify_zero : Clause.reify v Clause.nil True 
Arguments: {v : Sat.Valuation}
Goal: Sat.Clause.reify v Sat.Clause.nil True
-- Sat.Clause.reify_one
theorem Clause.reify_one {l : Literal} {a : Prop}
    (h₁ : Literal.reify v l a) : Clause.reify v (Clause.nil.cons l) a 
Arguments: {v : Sat.Valuation} {l : Sat.Literal} {a : Prop} (h₁ : Sat.Literal.reify v l a)
Goal: Sat.Clause.reify v (Sat.Clause.cons l Sat.Clause.nil) a
-- Sat.Literal.reify_pos
theorem Literal.reify_pos {a : Prop} {n : ℕ} (h : v n ↔ a) : (Literal.pos n).reify v ¬a 
Arguments: {v : Sat.Valuation} {a : Prop} {n : ℕ} (h : v n ↔ a)
Goal: Sat.Literal.reify v (Sat.Literal.pos n) ¬a
-- Sat.Literal.reify_neg
theorem Literal.reify_neg {a : Prop} {n : ℕ} (h : v n ↔ a) : (Literal.neg n).reify v a 
Arguments: {v : Sat.Valuation} {a : Prop} {n : ℕ} (h : v n ↔ a)
Goal: Sat.Literal.reify v (Sat.Literal.neg n) a
-- Tactic.NormNum.int_gcd_helper'
theorem int_gcd_helper' {d : ℕ} {x y : ℤ} (a b : ℤ) (h₁ : (d : ℤ) ∣ x) (h₂ : (d : ℤ) ∣ y)
    (h₃ : x * a + y * b = d) : Int.gcd x y = d 
Arguments: {d : ℕ} {x y : ℤ} (a b : ℤ) (h₁ : ↑d ∣ x) (h₂ : ↑d ∣ y) (h₃ : x * a + y * b = ↑d)
Goal: x.gcd y = d
-- Tactic.NormNum.nat_gcd_helper_dvd_left
theorem nat_gcd_helper_dvd_left (x y : ℕ) (h : y % x = 0) : Nat.gcd x y = x 
Arguments: (x y : ℕ) (h : y % x = 0)
Goal: x.gcd y = x
-- Tactic.NormNum.nat_gcd_helper_dvd_right
theorem nat_gcd_helper_dvd_right (x y : ℕ) (h : x % y = 0) : Nat.gcd x y = y 
Arguments: (x y : ℕ) (h : x % y = 0)
Goal: x.gcd y = y
-- Tactic.NormNum.nat_gcd_helper_2
theorem nat_gcd_helper_2 (d x y a b : ℕ) (hu : x % d = 0) (hv : y % d = 0)
    (h : x * a = y * b + d) : Nat.gcd x y = d 
Arguments: (d x y a b : ℕ) (hu : x % d = 0) (hv : y % d = 0) (h : x * a = y * b + d)
Goal: x.gcd y = d
-- Tactic.NormNum.nat_gcd_helper_1
theorem nat_gcd_helper_1 (d x y a b : ℕ) (hu : x % d = 0) (hv : y % d = 0)
    (h : y * b = x * a + d) : Nat.gcd x y = d 
Arguments: (d x y a b : ℕ) (hu : x % d = 0) (hv : y % d = 0) (h : y * b = x * a + d)
Goal: x.gcd y = d
-- Tactic.NormNum.nat_gcd_helper_1'
theorem nat_gcd_helper_1' (x y a b : ℕ) (h : y * b = x * a + 1) :
    Nat.gcd x y = 1 
Arguments: (x y a b : ℕ) (h : y * b = x * a + 1)
Goal: x.gcd y = 1
-- Tactic.NormNum.nat_gcd_helper_2'
theorem nat_gcd_helper_2' (x y a b : ℕ) (h : x * a = y * b + 1) :
    Nat.gcd x y = 1 
Arguments: (x y a b : ℕ) (h : x * a = y * b + 1)
Goal: x.gcd y = 1
-- Tactic.NormNum.nat_lcm_helper
theorem nat_lcm_helper (x y d m : ℕ) (hd : Nat.gcd x y = d)
    (d0 : Nat.beq d 0 = false)
    (dm : x * y = d * m) : Nat.lcm x y = m 
Arguments: (x y d m : ℕ) (hd : x.gcd y = d) (d0 : d.beq 0 = false) (dm : x * y = d * m)
Goal: x.lcm y = m
-- Tactic.NormNum.int_gcd_helper
theorem int_gcd_helper {x y : ℤ} {x' y' d : ℕ}
    (hx : x.natAbs = x') (hy : y.natAbs = y') (h : Nat.gcd x' y' = d) :
    Int.gcd x y = d 
Arguments: {x y : ℤ} {x' y' d : ℕ} (hx : x.natAbs = x') (hy : y.natAbs = y') (h : x'.gcd y' = d)
Goal: x.gcd y = d
-- Tactic.NormNum.int_lcm_helper
theorem int_lcm_helper {x y : ℤ} {x' y' d : ℕ}
    (hx : x.natAbs = x') (hy : y.natAbs = y') (h : Nat.lcm x' y' = d) :
    Int.lcm x y = d 
Arguments: {x y : ℤ} {x' y' d : ℕ} (hx : x.natAbs = x') (hy : y.natAbs = y') (h : x'.lcm y' = d)
Goal: x.lcm y = d
-- Tactic.NormNum.isNat_gcd
theorem isNat_gcd : {x y nx ny z : ℕ} →
    IsNat x nx → IsNat y ny → Nat.gcd nx ny = z → IsNat (Nat.gcd x y) z
  
Arguments: {x y nx ny z : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat x nx →
  Mathlib.Meta.NormNum.IsNat y ny → nx.gcd ny = z → Mathlib.Meta.NormNum.IsNat (x.gcd y) z
-- Tactic.NormNum.isNat_lcm
theorem isNat_lcm : {x y nx ny z : ℕ} →
    IsNat x nx → IsNat y ny → Nat.lcm nx ny = z → IsNat (Nat.lcm x y) z
  
Arguments: {x y nx ny z : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat x nx →
  Mathlib.Meta.NormNum.IsNat y ny → nx.lcm ny = z → Mathlib.Meta.NormNum.IsNat (x.lcm y) z
-- Tactic.NormNum.isInt_gcd
theorem isInt_gcd : {x y nx ny : ℤ} → {z : ℕ} →
    IsInt x nx → IsInt y ny → Int.gcd nx ny = z → IsNat (Int.gcd x y) z
  
Arguments: {x y nx ny : ℤ} {z : ℕ}
Goal: Mathlib.Meta.NormNum.IsInt x nx →
  Mathlib.Meta.NormNum.IsInt y ny → nx.gcd ny = z → Mathlib.Meta.NormNum.IsNat (x.gcd y) z
-- Tactic.NormNum.isInt_lcm
theorem isInt_lcm : {x y nx ny : ℤ} → {z : ℕ} →
    IsInt x nx → IsInt y ny → Int.lcm nx ny = z → IsNat (Int.lcm x y) z
  
Arguments: {x y nx ny : ℤ} {z : ℕ}
Goal: Mathlib.Meta.NormNum.IsInt x nx →
  Mathlib.Meta.NormNum.IsInt y ny → nx.lcm ny = z → Mathlib.Meta.NormNum.IsNat (x.lcm y) z
-- Mathlib.Meta.NormNum.isNat_eq_false
theorem isNat_eq_false [AddMonoidWithOne α] [CharZero α] : {a b : α} → {a' b' : ℕ} →
    IsNat a a' → IsNat b b' → Nat.beq a' b' = false → ¬a = b
  
Arguments: {α : Type u_1} [AddMonoidWithOne α] [CharZero α] {a b : α} {a' b' : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat a a' → Mathlib.Meta.NormNum.IsNat b b' → a'.beq b' = false → ¬a = b
-- Mathlib.Meta.NormNum.isInt_eq_false
theorem isInt_eq_false [Ring α] [CharZero α] : {a b : α} → {a' b' : ℤ} →
    IsInt a a' → IsInt b b' → decide (a' = b') = false → ¬a = b
  
Arguments: {α : Type u_1} [Ring α] [CharZero α] {a b : α} {a' b' : ℤ}
Goal: Mathlib.Meta.NormNum.IsInt a a' → Mathlib.Meta.NormNum.IsInt b b' → decide (a' = b') = false → ¬a = b
-- Mathlib.Meta.NormNum.Rat.invOf_denom_swap
theorem Rat.invOf_denom_swap [Ring α] (n₁ n₂ : ℤ) (a₁ a₂ : α)
    [Invertible a₁] [Invertible a₂] : n₁ * ⅟a₁ = n₂ * ⅟a₂ ↔ n₁ * a₂ = n₂ * a₁ 
Arguments: {α : Type u_1} [Ring α] (n₁ n₂ : ℤ) (a₁ a₂ : α) [Invertible a₁] [Invertible a₂]
Goal: ↑n₁ * ⅟a₁ = ↑n₂ * ⅟a₂ ↔ ↑n₁ * a₂ = ↑n₂ * a₁
-- Mathlib.Meta.NormNum.isRat_eq_false
theorem isRat_eq_false [Ring α] [CharZero α] : {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)) = false → ¬a = b
  
Arguments: {α : Type u_1} [Ring α] [CharZero α] {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)) = false → ¬a = b
-- Tactic.NormNum.nat_sqrt_helper
lemma nat_sqrt_helper {x y r : ℕ} (hr : y * y + r = x) (hle : Nat.ble r (2 * y)) :
    Nat.sqrt x = y 
Arguments: {x y r : ℕ} (hr : y * y + r = x) (hle : r.ble (2 * y) = true)
Goal: x.sqrt = y
-- Tactic.NormNum.isNat_sqrt
theorem isNat_sqrt : {x nx z : ℕ} → IsNat x nx → Nat.sqrt nx = z → IsNat (Nat.sqrt x) z
  
Arguments: {x nx z : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat x nx → nx.sqrt = z → Mathlib.Meta.NormNum.IsNat x.sqrt z
-- Tactic.NormNum.int_not_isCoprime_helper
theorem int_not_isCoprime_helper (x y : ℤ) (d : ℕ) (hd : Int.gcd x y = d)
    (h : Nat.beq d 1 = false) : ¬ IsCoprime x y 
Arguments: (x y : ℤ) (d : ℕ) (hd : x.gcd y = d) (h : d.beq 1 = false)
Goal: ¬IsCoprime x y
-- Tactic.NormNum.isInt_isCoprime
theorem isInt_isCoprime : {x y nx ny : ℤ} →
    IsInt x nx → IsInt y ny → IsCoprime nx ny → IsCoprime x y
  
Arguments: {x y nx ny : ℤ}
Goal: Mathlib.Meta.NormNum.IsInt x nx → Mathlib.Meta.NormNum.IsInt y ny → IsCoprime nx ny → IsCoprime x y
-- Tactic.NormNum.isInt_not_isCoprime
theorem isInt_not_isCoprime : {x y nx ny : ℤ} →
    IsInt x nx → IsInt y ny → ¬ IsCoprime nx ny → ¬ IsCoprime x y
  
Arguments: {x y nx ny : ℤ}
Goal: Mathlib.Meta.NormNum.IsInt x nx → Mathlib.Meta.NormNum.IsInt y ny → ¬IsCoprime nx ny → ¬IsCoprime x y
-- Mathlib.Meta.NormNum.isFibAux_zero
theorem isFibAux_zero : IsFibAux 0 0 1 
Goal: Mathlib.Meta.NormNum.IsFibAux 0 0 1
-- Mathlib.Meta.NormNum.isFibAux_one
theorem isFibAux_one : IsFibAux 1 1 1 
Goal: Mathlib.Meta.NormNum.IsFibAux 1 1 1
-- Mathlib.Meta.NormNum.isFibAux_two_mul
theorem isFibAux_two_mul {n a b n' a' b' : ℕ} (H : IsFibAux n a b)
    (hn : 2 * n = n') (h1 : a * (2 * b - a) = a') (h2 : a * a + b * b = b') :
    IsFibAux n' a' b' 
Arguments: {n a b n' a' b' : ℕ} (H : Mathlib.Meta.NormNum.IsFibAux n a b) (hn : 2 * n = n') (h1 : a * (2 * b - a) = a') (h2 : a * a + b * b = b')
Goal: Mathlib.Meta.NormNum.IsFibAux n' a' b'
-- Mathlib.Meta.NormNum.isFibAux_two_mul_add_one
theorem isFibAux_two_mul_add_one {n a b n' a' b' : ℕ} (H : IsFibAux n a b)
    (hn : 2 * n + 1 = n') (h1 : a * a + b * b = a') (h2 : b * (2 * a + b) = b') :
    IsFibAux n' a' b' 
Arguments: {n a b n' a' b' : ℕ} (H : Mathlib.Meta.NormNum.IsFibAux n a b) (hn : 2 * n + 1 = n') (h1 : a * a + b * b = a') (h2 : b * (2 * a + b) = b')
Goal: Mathlib.Meta.NormNum.IsFibAux n' a' b'
-- Mathlib.Meta.NormNum.isFibAux_two_mul_done
theorem isFibAux_two_mul_done {n a b n' a' : ℕ} (H : IsFibAux n a b)
    (hn : 2 * n = n') (h : a * (2 * b - a) = a') : fib n' = a' 
Arguments: {n a b n' a' : ℕ} (H : Mathlib.Meta.NormNum.IsFibAux n a b) (hn : 2 * n = n') (h : a * (2 * b - a) = a')
Goal: Nat.fib n' = a'
-- Mathlib.Meta.NormNum.isFibAux_two_mul_add_one_done
theorem isFibAux_two_mul_add_one_done {n a b n' a' : ℕ} (H : IsFibAux n a b)
    (hn : 2 * n + 1 = n') (h : a * a + b * b = a') : fib n' = a' 
Arguments: {n a b n' a' : ℕ} (H : Mathlib.Meta.NormNum.IsFibAux n a b) (hn : 2 * n + 1 = n') (h : a * a + b * b = a')
Goal: Nat.fib n' = a'
-- Mathlib.Meta.NormNum.isNat_fib
theorem isNat_fib : {x nx z : ℕ} → IsNat x nx → Nat.fib nx = z → IsNat (Nat.fib x) z
  
Arguments: {x nx z : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat x nx → Nat.fib nx = z → Mathlib.Meta.NormNum.IsNat (Nat.fib x) z
-- Mathlib.Meta.NormNum.isRat_ofScientific_of_true
theorem isRat_ofScientific_of_true [DivisionRing α] :
    {m e : ℕ} → {n : ℤ} → {d : ℕ} →
    IsRat (mkRat m (10 ^ e) : α) n d → IsRat (OfScientific.ofScientific m true e : α) n d
  
Arguments: {α : Type u_1} [DivisionRing α] {m e : ℕ} {n : ℤ} {d : ℕ}
Goal: Mathlib.Meta.NormNum.IsRat (↑(mkRat (↑m) (10 ^ e))) n d →
  Mathlib.Meta.NormNum.IsRat (OfScientific.ofScientific m true e) n d
-- Mathlib.Meta.NormNum.isNat_ofScientific_of_false
theorem isNat_ofScientific_of_false [DivisionRing α] : {m e nm ne n : ℕ} →
    IsNat m nm → IsNat e ne → n = Nat.mul nm ((10 : ℕ) ^ ne) →
    IsNat (OfScientific.ofScientific m false e : α) n
  
Arguments: {α : Type u_1} [DivisionRing α] {m e nm ne n : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat m nm →
  Mathlib.Meta.NormNum.IsNat e ne →
    n = nm.mul (10 ^ ne) → Mathlib.Meta.NormNum.IsNat (OfScientific.ofScientific m false e) n
-- Mathlib.Meta.NormNum.isInt_ediv_zero
lemma isInt_ediv_zero : ∀ {a b r : ℤ}, IsInt a r → IsNat b (nat_lit 0) → IsNat (a / b) (nat_lit 0)
  
Arguments: {a b r : ℤ}
Goal: Mathlib.Meta.NormNum.IsInt a r → Mathlib.Meta.NormNum.IsNat b 0 → Mathlib.Meta.NormNum.IsNat (a / b) 0
-- Mathlib.Meta.NormNum.isInt_ediv
lemma isInt_ediv {a b q m a' : ℤ} {b' r : ℕ}
    (ha : IsInt a a') (hb : IsNat b b')
    (hm : q * b' = m) (h : r + m = a') (h₂ : Nat.blt r b' = true) :
    IsInt (a / b) q 
Arguments: {a b q m a' : ℤ} {b' r : ℕ} (ha : Mathlib.Meta.NormNum.IsInt a a') (hb : Mathlib.Meta.NormNum.IsNat b b') (hm : q * ↑b' = m) (h : ↑r + m = a') (h₂ : r.blt b' = true)
Goal: Mathlib.Meta.NormNum.IsInt (a / b) q
-- Mathlib.Meta.NormNum.isInt_ediv_neg
lemma isInt_ediv_neg {a b q q' : ℤ} (h : IsInt (a / -b) q) (hq : -q = q') : IsInt (a / b) q' 
Arguments: {a b q q' : ℤ} (h : Mathlib.Meta.NormNum.IsInt (a / -b) q) (hq : -q = q')
Goal: Mathlib.Meta.NormNum.IsInt (a / b) q'
-- Mathlib.Meta.NormNum.isNat_neg_of_isNegNat
lemma isNat_neg_of_isNegNat {a : ℤ} {b : ℕ} (h : IsInt a (.negOfNat b)) : IsNat (-a) b 
Arguments: {a : ℤ} {b : ℕ} (h : Mathlib.Meta.NormNum.IsInt a (Int.negOfNat b))
Goal: Mathlib.Meta.NormNum.IsNat (-a) b
-- Mathlib.Meta.NormNum.isInt_emod_zero
lemma isInt_emod_zero : ∀ {a b r : ℤ}, IsInt a r → IsNat b (nat_lit 0) → IsInt (a % b) r
  
Arguments: {a b r : ℤ}
Goal: Mathlib.Meta.NormNum.IsInt a r → Mathlib.Meta.NormNum.IsNat b 0 → Mathlib.Meta.NormNum.IsInt (a % b) r
-- Mathlib.Meta.NormNum.isInt_emod
lemma isInt_emod {a b q m a' : ℤ} {b' r : ℕ}
    (ha : IsInt a a') (hb : IsNat b b')
    (hm : q * b' = m) (h : r + m = a') (h₂ : Nat.blt r b' = true) :
    IsNat (a % b) r 
Arguments: {a b q m a' : ℤ} {b' r : ℕ} (ha : Mathlib.Meta.NormNum.IsInt a a') (hb : Mathlib.Meta.NormNum.IsNat b b') (hm : q * ↑b' = m) (h : ↑r + m = a') (h₂ : r.blt b' = true)
Goal: Mathlib.Meta.NormNum.IsNat (a % b) r
-- Mathlib.Meta.NormNum.isInt_emod_neg
lemma isInt_emod_neg {a b : ℤ} {r : ℕ} (h : IsNat (a % -b) r) : IsNat (a % b) r 
Arguments: {a b : ℤ} {r : ℕ} (h : Mathlib.Meta.NormNum.IsNat (a % -b) r)
Goal: Mathlib.Meta.NormNum.IsNat (a % b) r
-- Mathlib.Meta.NormNum.isInt_dvd_true
theorem isInt_dvd_true : {a b : ℤ} → {a' b' c : ℤ} →
    IsInt a a' → IsInt b b' → Int.mul a' c = b' → a ∣ b
  
Arguments: {a b a' b' c : ℤ}
Goal: Mathlib.Meta.NormNum.IsInt a a' → Mathlib.Meta.NormNum.IsInt b b' → a'.mul c = b' → a ∣ b
-- Mathlib.Meta.NormNum.isInt_dvd_false
theorem isInt_dvd_false : {a b : ℤ} → {a' b' : ℤ} →
    IsInt a a' → IsInt b b' → Int.mod b' a' != 0 → ¬a ∣ b
  
Arguments: {a b a' b' : ℤ}
Goal: Mathlib.Meta.NormNum.IsInt a a' → Mathlib.Meta.NormNum.IsInt b b' → (b'.mod a' != 0) = true → ¬a ∣ b
-- Mathlib.Meta.NormNum.IsNat.out
structure IsNat {α : Type u} [AddMonoidWithOne α] (a : α) (n : ℕ) : Prop where
    out : a = n
Arguments: {α : Type u} [AddMonoidWithOne α] {a : α} {n : ℕ} (self : Mathlib.Meta.NormNum.IsNat a n)
Goal: a = ↑n
-- Mathlib.Meta.NormNum.IsNat.raw_refl
theorem IsNat.raw_refl (n : ℕ) : IsNat n n 
Arguments: (n : ℕ)
Goal: Mathlib.Meta.NormNum.IsNat n n
-- Mathlib.Meta.NormNum.IsNat.to_eq
theorem IsNat.to_eq {α : Type u} [AddMonoidWithOne α] {n} : {a a' : α} → IsNat a n → n = a' → a = a'
  
Arguments: {α : Type u} [AddMonoidWithOne α] {n : ℕ} {a a' : α}
Goal: Mathlib.Meta.NormNum.IsNat a n → ↑n = a' → a = a'
-- Mathlib.Meta.NormNum.IsNat.to_raw_eq
theorem IsNat.to_raw_eq {a : α} {n : ℕ} [AddMonoidWithOne α] : IsNat (a : α) n → a = n.rawCast
  
Arguments: {α : Type u} {a : α} {n : ℕ} [AddMonoidWithOne α]
Goal: Mathlib.Meta.NormNum.IsNat a n → a = n.rawCast
-- Mathlib.Meta.NormNum.IsNat.of_raw
theorem IsNat.of_raw (α) [AddMonoidWithOne α] (n : ℕ) : IsNat (n.rawCast : α) n 
Arguments: (α : Type u_1) [AddMonoidWithOne α] (n : ℕ)
Goal: Mathlib.Meta.NormNum.IsNat n.rawCast n
-- Mathlib.Meta.NormNum.isNat.natElim
@[elab_as_elim]
theorem isNat.natElim {p : ℕ → Prop} : {n : ℕ} → {n' : ℕ} → IsNat n n' → p n' → p n
  
Arguments: {p : ℕ → Prop} {n n' : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat n n' → p n' → p n
-- Mathlib.Meta.NormNum.IsInt.out
structure IsInt [Ring α] (a : α) (n : ℤ) : Prop where
    out : a = n
Arguments: {α : Type u} [Ring α] {a : α} {n : ℤ} (self : Mathlib.Meta.NormNum.IsInt a n)
Goal: a = ↑n
-- Mathlib.Meta.NormNum.IsInt.to_isNat
theorem IsInt.to_isNat {α} [Ring α] : ∀ {a : α} {n}, IsInt a (.ofNat n) → IsNat a n
  
Arguments: {α : Type u_1} [Ring α] {a : α} {n : ℕ}
Goal: Mathlib.Meta.NormNum.IsInt a (Int.ofNat n) → Mathlib.Meta.NormNum.IsNat a n
-- Mathlib.Meta.NormNum.IsNat.to_isInt
theorem IsNat.to_isInt {α} [Ring α] : ∀ {a : α} {n}, IsNat a n → IsInt a (.ofNat n)
  
Arguments: {α : Type u_1} [Ring α] {a : α} {n : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat a n → Mathlib.Meta.NormNum.IsInt a (Int.ofNat n)
-- Mathlib.Meta.NormNum.IsInt.to_raw_eq
theorem IsInt.to_raw_eq {a : α} {n : ℤ} [Ring α] : IsInt (a : α) n → a = n.rawCast
  
Arguments: {α : Type u} {a : α} {n : ℤ} [Ring α]
Goal: Mathlib.Meta.NormNum.IsInt a n → a = n.rawCast
-- Mathlib.Meta.NormNum.IsInt.of_raw
theorem IsInt.of_raw (α) [Ring α] (n : ℤ) : IsInt (n.rawCast : α) n 
Arguments: (α : Type u_1) [Ring α] (n : ℤ)
Goal: Mathlib.Meta.NormNum.IsInt n.rawCast n
-- Mathlib.Meta.NormNum.IsInt.neg_to_eq
theorem IsInt.neg_to_eq {α} [Ring α] {n} :
    {a a' : α} → IsInt a (.negOfNat n) → n = a' → a = -a'
  
Arguments: {α : Type u_1} [Ring α] {n : ℕ} {a a' : α}
Goal: Mathlib.Meta.NormNum.IsInt a (Int.negOfNat n) → ↑n = a' → a = -a'
-- Mathlib.Meta.NormNum.IsInt.nonneg_to_eq
theorem IsInt.nonneg_to_eq {α} [Ring α] {n}
    {a a' : α} (h : IsInt a (.ofNat n)) (e : n = a') : a = a' 
Arguments: {α : Type u_1} [Ring α] {n : ℕ} {a a' : α} (h : Mathlib.Meta.NormNum.IsInt a (Int.ofNat n)) (e : ↑n = a')
Goal: a = a'
-- Mathlib.Meta.NormNum.IsRat.to_isNat
theorem IsRat.to_isNat {α} [Ring α] : ∀ {a : α} {n}, IsRat a (.ofNat n) (nat_lit 1) → IsNat a n
  
Arguments: {α : Type u_1} [Ring α] {a : α} {n : ℕ}
Goal: Mathlib.Meta.NormNum.IsRat a (Int.ofNat n) 1 → Mathlib.Meta.NormNum.IsNat a n
-- Mathlib.Meta.NormNum.IsNat.to_isRat
theorem IsNat.to_isRat {α} [Ring α] : ∀ {a : α} {n}, IsNat a n → IsRat a (.ofNat n) (nat_lit 1)
  
Arguments: {α : Type u_1} [Ring α] {a : α} {n : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat a n → Mathlib.Meta.NormNum.IsRat a (Int.ofNat n) 1
-- Mathlib.Meta.NormNum.IsRat.to_isInt
theorem IsRat.to_isInt {α} [Ring α] : ∀ {a : α} {n}, IsRat a n (nat_lit 1) → IsInt a n
  
Arguments: {α : Type u_1} [Ring α] {a : α} {n : ℤ}
Goal: Mathlib.Meta.NormNum.IsRat a n 1 → Mathlib.Meta.NormNum.IsInt a n
-- Mathlib.Meta.NormNum.IsInt.to_isRat
theorem IsInt.to_isRat {α} [Ring α] : ∀ {a : α} {n}, IsInt a n → IsRat a n (nat_lit 1)
  
Arguments: {α : Type u_1} [Ring α] {a : α} {n : ℤ}
Goal: Mathlib.Meta.NormNum.IsInt a n → Mathlib.Meta.NormNum.IsRat a n 1
-- Mathlib.Meta.NormNum.IsRat.to_raw_eq
theorem IsRat.to_raw_eq {n : ℤ} {d : ℕ} [DivisionRing α] :
    ∀ {a}, IsRat (a : α) n d → a = Rat.rawCast n d
  
Arguments: {α : Type u} {n : ℤ} {d : ℕ} [DivisionRing α] {a : α}
Goal: Mathlib.Meta.NormNum.IsRat a n d → a = Rat.rawCast n d