ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Data/Nat/Cast/WithTop.lean

full_name: instWellFoundedRelationWithTopNat
code: instance : WellFoundedRelation (WithTop ℕ) 
goal: WellFoundedRelation (WithTop ℕ)

full_name: Nat.cast_withTop
code: theorem Nat.cast_withTop (n : ℕ) :  Nat.cast n = WithTop.some n 
goal: ↑n = ↑n

full_name: Nat.cast_withBot
code: theorem Nat.cast_withBot (n : ℕ) : Nat.cast n = WithBot.some n 
goal: ↑n = ↑n
File: Mathlib/Data/Nat/Cast/Order/Ring.lean

full_name: Nat.cast_nonneg
code: /-- Specialisation of `Nat.cast_nonneg'`, which seems to be easier for Lean to use. -/
@[simp]
theorem cast_nonneg {α} [OrderedSemiring α] (n : ℕ) : 0 ≤ (n : α) 
goal: 0 ≤ ↑n

full_name: Nat.ofNat_nonneg
code: /-- Specialisation of `Nat.ofNat_nonneg'`, which seems to be easier for Lean to use. -/
-- See note [no_index around OfNat.ofNat]
@[simp]
theorem ofNat_nonneg {α} [OrderedSemiring α] (n : ℕ) [n.AtLeastTwo] :
    0 ≤ (no_index (OfNat.ofNat n : α)) 
goal: 0 ≤ OfNat.ofNat n

full_name: Nat.cast_min
code: @[simp, norm_cast]
theorem cast_min {α} [LinearOrderedSemiring α] {a b : ℕ} : ((min a b : ℕ) : α) = min (a : α) b 
goal: ↑(min a b) = min ↑a ↑b

full_name: Nat.cast_max
code: @[simp, norm_cast]
theorem cast_max {α} [LinearOrderedSemiring α] {a b : ℕ} : ((max a b : ℕ) : α) = max (a : α) b 
goal: ↑(max a b) = max ↑a ↑b

full_name: Nat.cast_pos
code: /-- Specialisation of `Nat.cast_pos'`, which seems to be easier for Lean to use. -/
@[simp]
theorem cast_pos {α} [OrderedSemiring α] [Nontrivial α] {n : ℕ} : (0 : α) < n ↔ 0 < n 
goal: 0 < ↑n ↔ 0 < n

full_name: Nat.ofNat_pos'
code: /-- See also `Nat.ofNat_pos`, specialised for an `OrderedSemiring`. -/
-- See note [no_index around OfNat.ofNat]
@[simp low]
theorem ofNat_pos' {n : ℕ} [n.AtLeastTwo] : 0 < (no_index (OfNat.ofNat n : α)) 
goal: 0 < OfNat.ofNat n

full_name: Nat.ofNat_pos
code: /-- Specialisation of `Nat.ofNat_pos'`, which seems to be easier for Lean to use. -/
-- See note [no_index around OfNat.ofNat]
@[simp]
theorem ofNat_pos {α} [OrderedSemiring α] [Nontrivial α] {n : ℕ} [n.AtLeastTwo] :
    0 < (no_index (OfNat.ofNat n : α)) 
goal: 0 < OfNat.ofNat n

full_name: Nat.cast_tsub
code: /-- A version of `Nat.cast_sub` that works for `ℝ≥0` and `ℚ≥0`. Note that this proof doesn't work
for `ℕ∞` and `ℝ≥0∞`, so we use type-specific lemmas for these types. -/
@[simp, norm_cast]
theorem cast_tsub [CanonicallyOrderedCommSemiring α] [Sub α] [OrderedSub α]
    [ContravariantClass α α (· + ·) (· ≤ ·)] (m n : ℕ) : ↑(m - n) = (m - n : α) 
goal: ↑(m - n) = ↑m - ↑n

full_name: Nat.abs_cast
code: @[simp, norm_cast]
theorem abs_cast [LinearOrderedRing α] (a : ℕ) : |(a : α)| = a 
goal: |↑a| = ↑a

full_name: Nat.abs_ofNat
code: @[simp]
theorem abs_ofNat [LinearOrderedRing α] (n : ℕ) [n.AtLeastTwo] :
    |(no_index (OfNat.ofNat n : α))| = OfNat.ofNat n 
goal: |OfNat.ofNat n| = OfNat.ofNat n
File: Mathlib/Data/Nat/Cast/SetInterval.lean

full_name: Nat.range_cast_int
code: @[simp]
theorem range_cast_int : range ((↑) : ℕ → ℤ) = Ici 0 
goal: Set.range Nat.cast = Set.Ici 0

full_name: Nat.image_cast_int_Icc
code: theorem image_cast_int_Icc (a b : ℕ) : (↑) '' Icc a b = Icc (a : ℤ) b 
goal: Nat.cast '' Set.Icc a b = Set.Icc ↑a ↑b

full_name: Nat.image_cast_int_Ico
code: theorem image_cast_int_Ico (a b : ℕ) : (↑) '' Ico a b = Ico (a : ℤ) b 
goal: Nat.cast '' Set.Ico a b = Set.Ico ↑a ↑b

full_name: Nat.image_cast_int_Ioc
code: theorem image_cast_int_Ioc (a b : ℕ) : (↑) '' Ioc a b = Ioc (a : ℤ) b 
goal: Nat.cast '' Set.Ioc a b = Set.Ioc ↑a ↑b

full_name: Nat.image_cast_int_Ioo
code: theorem image_cast_int_Ioo (a b : ℕ) : (↑) '' Ioo a b = Ioo (a : ℤ) b 
goal: Nat.cast '' Set.Ioo a b = Set.Ioo ↑a ↑b

full_name: Nat.image_cast_int_Iic
code: theorem image_cast_int_Iic (a : ℕ) : (↑) '' Iic a = Icc (0 : ℤ) a 
goal: Nat.cast '' Set.Iic a = Set.Icc 0 ↑a

full_name: Nat.image_cast_int_Iio
code: theorem image_cast_int_Iio (a : ℕ) : (↑) '' Iio a = Ico (0 : ℤ) a 
goal: Nat.cast '' Set.Iio a = Set.Ico 0 ↑a

full_name: Nat.image_cast_int_Ici
code: theorem image_cast_int_Ici (a : ℕ) : (↑) '' Ici a = Ici (a : ℤ) 
goal: Nat.cast '' Set.Ici a = Set.Ici ↑a

full_name: Nat.image_cast_int_Ioi
code: theorem image_cast_int_Ioi (a : ℕ) : (↑) '' Ioi a = Ioi (a : ℤ) 
goal: Nat.cast '' Set.Ioi a = Set.Ioi ↑a
File: Mathlib/Data/Nat/Cast/NeZero.lean

full_name: NeZero.one_le
code: theorem one_le {n : ℕ} [NeZero n] : 1 ≤ n 
goal: 1 ≤ n

full_name: NeZero.natCast_ne
code: lemma natCast_ne (n : ℕ) (R) [AddMonoidWithOne R] [h : NeZero (n : R)] : (n : R) ≠ 0 
goal: ↑n ≠ 0

full_name: NeZero.of_neZero_natCast
code: lemma of_neZero_natCast (R) [AddMonoidWithOne R] {n : ℕ} [h : NeZero (n : R)] : NeZero n 
goal: NeZero n

full_name: NeZero.pos_of_neZero_natCast
code: lemma pos_of_neZero_natCast (R) [AddMonoidWithOne R] {n : ℕ} [NeZero (n : R)] : 0 < n 
goal: 0 < n
File: Mathlib/Data/Nat/Cast/Synonym.lean

full_name: instNatCastOrderDual
code: instance [h : NatCast α] : NatCast αᵒᵈ 
goal: NatCast αᵒᵈ

full_name: instAddMonoidWithOneOrderDual
code: instance [h : AddMonoidWithOne α] : AddMonoidWithOne αᵒᵈ 
goal: AddMonoidWithOne αᵒᵈ

full_name: instAddCommMonoidWithOneOrderDual
code: instance [h : AddCommMonoidWithOne α] : AddCommMonoidWithOne αᵒᵈ 
goal: AddCommMonoidWithOne αᵒᵈ

full_name: toDual_natCast
code: @[simp]
theorem toDual_natCast [NatCast α] (n : ℕ) : toDual (n : α) = n 
goal: OrderDual.toDual ↑n = ↑n

full_name: toDual_ofNat
code: @[simp]
theorem toDual_ofNat [NatCast α] (n : ℕ) [n.AtLeastTwo] :
    (toDual (no_index (OfNat.ofNat n : α))) = OfNat.ofNat n 
goal: OrderDual.toDual (OfNat.ofNat n) = OfNat.ofNat n

full_name: ofDual_natCast
code: @[simp]
theorem ofDual_natCast [NatCast α] (n : ℕ) : (ofDual n : α) = n 
goal: OrderDual.ofDual ↑n = ↑n

full_name: ofDual_ofNat
code: @[simp]
theorem ofDual_ofNat [NatCast α] (n : ℕ) [n.AtLeastTwo] :
    (ofDual (no_index (OfNat.ofNat n : αᵒᵈ))) = OfNat.ofNat n 
goal: OrderDual.ofDual (OfNat.ofNat n) = OfNat.ofNat n

full_name: instNatCastLex
code: instance [h : NatCast α] : NatCast (Lex α) 
goal: NatCast (Lex α)

full_name: instAddMonoidWithOneLex
code: instance [h : AddMonoidWithOne α] : AddMonoidWithOne (Lex α) 
goal: AddMonoidWithOne (Lex α)

full_name: instAddCommMonoidWithOneLex
code: instance [h : AddCommMonoidWithOne α] : AddCommMonoidWithOne (Lex α) 
goal: AddCommMonoidWithOne (Lex α)

full_name: toLex_natCast
code: @[simp]
theorem toLex_natCast [NatCast α] (n : ℕ) : toLex (n : α) = n 
goal: toLex ↑n = ↑n

full_name: toLex_ofNat
code: @[simp]
theorem toLex_ofNat [NatCast α] (n : ℕ) [n.AtLeastTwo] :
    (toLex (no_index (OfNat.ofNat n : α))) = OfNat.ofNat n 
goal: toLex (OfNat.ofNat n) = OfNat.ofNat n

full_name: ofLex_natCast
code: @[simp]
theorem ofLex_natCast [NatCast α] (n : ℕ) : (ofLex n : α) = n 
goal: ofLex ↑n = ↑n

full_name: ofLex_ofNat
code: @[simp]
theorem ofLex_ofNat [NatCast α] (n : ℕ) [n.AtLeastTwo] :
    (ofLex (no_index (OfNat.ofNat n : Lex α))) = OfNat.ofNat n 
goal: ofLex (OfNat.ofNat n) = OfNat.ofNat n
File: Mathlib/Data/Nat/Cast/Prod.lean

full_name: Prod.instAddMonoidWithOne
code: instance instAddMonoidWithOne : AddMonoidWithOne (α × β) 
goal: AddMonoidWithOne (α × β)

full_name: Prod.fst_natCast
code: @[simp]
theorem fst_natCast (n : ℕ) : (n : α × β).fst = n 
goal: (↑n).1 = ↑n

full_name: Prod.fst_ofNat
code: @[simp]
theorem fst_ofNat (n : ℕ) [n.AtLeastTwo] :
    (no_index (OfNat.ofNat n : α × β)).1 = (OfNat.ofNat n : α) 
goal: (OfNat.ofNat n).1 = OfNat.ofNat n

full_name: Prod.snd_natCast
code: @[simp]
theorem snd_natCast (n : ℕ) : (n : α × β).snd = n 
goal: (↑n).2 = ↑n

full_name: Prod.snd_ofNat
code: @[simp]
theorem snd_ofNat (n : ℕ) [n.AtLeastTwo] :
    (no_index (OfNat.ofNat n : α × β)).2 = (OfNat.ofNat n : β) 
goal: (OfNat.ofNat n).2 = OfNat.ofNat n
File: Mathlib/Data/Nat/Cast/Commute.lean

full_name: Nat.cast_commute
code: theorem cast_commute (n : ℕ) (x : α) : Commute (n : α) x 
goal: Commute (↑n) x

full_name: Commute.ofNat_left
code: theorem _root_.Commute.ofNat_left (n : ℕ) [n.AtLeastTwo] (x : α) : Commute (OfNat.ofNat n) x 
goal: Commute (OfNat.ofNat n) x

full_name: Nat.cast_comm
code: theorem cast_comm (n : ℕ) (x : α) : (n : α) * x = x * n 
goal: ↑n * x = x * ↑n

full_name: Nat.commute_cast
code: theorem commute_cast (x : α) (n : ℕ) : Commute x n 
goal: Commute x ↑n

full_name: Commute.ofNat_right
code: theorem _root_.Commute.ofNat_right (x : α) (n : ℕ) [n.AtLeastTwo] : Commute x (OfNat.ofNat n) 
goal: Commute x (OfNat.ofNat n)

full_name: SemiconjBy.natCast_mul_right
code: @[simp]
lemma natCast_mul_right (h : SemiconjBy a x y) (n : ℕ) : SemiconjBy a (n * x) (n * y) 
goal: SemiconjBy a (↑n * x) (↑n * y)

full_name: SemiconjBy.natCast_mul_left
code: @[simp]
lemma natCast_mul_left (h : SemiconjBy a x y) (n : ℕ) : SemiconjBy (n * a) x y 
goal: SemiconjBy (↑n * a) x y

full_name: SemiconjBy.natCast_mul_natCast_mul
code: @[simp]
lemma natCast_mul_natCast_mul (h : SemiconjBy a x y) (m n : ℕ) :
    SemiconjBy (m * a) (n * x) (n * y) 
goal: SemiconjBy (↑m * a) (↑n * x) (↑n * y)

full_name: Commute.natCast_mul_right
code: @[simp] lemma natCast_mul_right (h : Commute a b) (n : ℕ) : Commute a (n * b) 
goal: Commute a (↑n * b)

full_name: Commute.natCast_mul_left
code: @[simp] lemma natCast_mul_left (h : Commute a b) (n : ℕ) : Commute (n * a) b 
goal: Commute (↑n * a) b

full_name: Commute.natCast_mul_natCast_mul
code: @[simp] lemma natCast_mul_natCast_mul (h : Commute a b) (m n : ℕ) : Commute (m * a) (n * b) 
goal: Commute (↑m * a) (↑n * b)

full_name: Commute.self_natCast_mul
code: lemma self_natCast_mul : Commute a (n * a) 
goal: Commute a (↑n * a)

full_name: Commute.natCast_mul_self
code: lemma natCast_mul_self : Commute (n * a) a 
goal: Commute (↑n * a) a

full_name: Commute.self_natCast_mul_natCast_mul
code: lemma self_natCast_mul_natCast_mul : Commute (m * a) (n * a) 
goal: Commute (↑m * a) (↑n * a)
File: Mathlib/Data/Nat/Notation.lean

full_name: _aux_Mathlib_Data_Nat_Notation___unexpand_Nat_1
code: @[inherit_doc] notation "ℕ" => Nat
goal: Lean.PrettyPrinter.Unexpander

full_name: _aux_Mathlib_Data_Nat_Notation___macroRules_termℕ_1
code: @[inherit_doc] notation "ℕ" => Nat
goal: Lean.Macro
File: Mathlib/Data/Nat/Order/Lemmas.lean

full_name: Nat.Subtype.orderBot
code: instance Subtype.orderBot (s : Set ℕ) [DecidablePred (· ∈ s)] [h : Nonempty s] : OrderBot s 
goal: OrderBot ↑s

full_name: Nat.Subtype.semilatticeSup
code: instance Subtype.semilatticeSup (s : Set ℕ) : SemilatticeSup s 
goal: SemilatticeSup ↑s

full_name: Nat.Subtype.coe_bot
code: theorem Subtype.coe_bot {s : Set ℕ} [DecidablePred (· ∈ s)] [h : Nonempty s] :
    ((⊥ : s) : ℕ) = Nat.find (nonempty_subtype.1 h) 
goal: ↑⊥ = Nat.find ⋯

full_name: Nat.set_eq_univ
code: theorem set_eq_univ {S : Set ℕ} : S = Set.univ ↔ 0 ∈ S ∧ ∀ k : ℕ, k ∈ S → k + 1 ∈ S 
goal: S = Set.univ ↔ 0 ∈ S ∧ ∀ k ∈ S, k + 1 ∈ S

full_name: Nat.exists_not_and_succ_of_not_zero_of_exists
code: lemma exists_not_and_succ_of_not_zero_of_exists {p : ℕ → Prop} (H' : ¬ p 0) (H : ∃ n, p n) :
    ∃ n, ¬ p n ∧ p (n + 1) 
goal: ∃ n, ¬p n ∧ p (n + 1)
File: Mathlib/Data/Nat/SuccPred.lean

full_name: Nat.instSuccOrder
code: @[instance] abbrev instSuccOrder : SuccOrder ℕ 
goal: SuccOrder ℕ

full_name: Nat.instPredOrder
code: @[instance] abbrev instPredOrder : PredOrder ℕ 
goal: PredOrder ℕ

full_name: Nat.succ_eq_succ
code: @[simp]
theorem succ_eq_succ : Order.succ = succ 
goal: Order.succ = Nat.succ

full_name: Nat.pred_eq_pred
code: @[simp]
theorem pred_eq_pred : Order.pred = pred 
goal: Order.pred = Nat.pred

full_name: Nat.succ_iterate
code: theorem succ_iterate (a : ℕ) : ∀ n, succ^[n] a = a + n
  
goal: Nat.succ^[n] a = a + n

full_name: Nat.pred_iterate
code: theorem pred_iterate (a : ℕ) : ∀ n, pred^[n] a = a - n
  
goal: Nat.pred^[n] a = a - n

full_name: Nat.le_succ_iff_eq_or_le
code: lemma le_succ_iff_eq_or_le : m ≤ n.succ ↔ m = n.succ ∨ m ≤ n 
goal: m ≤ n.succ ↔ m = n.succ ∨ m ≤ n

full_name: Nat.instIsSuccArchimedean
code: instance : IsSuccArchimedean ℕ 
goal: IsSuccArchimedean ℕ

full_name: Nat.instIsPredArchimedean
code: instance : IsPredArchimedean ℕ 
goal: IsPredArchimedean ℕ

full_name: Nat.forall_ne_zero_iff
code: lemma forall_ne_zero_iff (P : ℕ → Prop) :
    (∀ i, i ≠ 0 → P i) ↔ (∀ i, P (i + 1)) 
goal: (∀ (i : ℕ), i ≠ 0 → P i) ↔ ∀ (i : ℕ), P (i + 1)

full_name: Nat.covBy_iff_succ_eq
code: protected theorem covBy_iff_succ_eq {m n : ℕ} : m ⋖ n ↔ m + 1 = n 
goal: m ⋖ n ↔ m + 1 = n

full_name: Fin.coe_covBy_iff
code: @[simp, norm_cast]
theorem Fin.coe_covBy_iff {n : ℕ} {a b : Fin n} : (a : ℕ) ⋖ b ↔ a ⋖ b 
goal: ↑a ⋖ ↑b ↔ a ⋖ b
File: Mathlib/Data/Nat/Hyperoperation.lean

full_name: hyperoperation
code: /-- Implementation of the hyperoperation sequence
where `hyperoperation n m k` is the `n`th hyperoperation between `m` and `k`.
-/
def hyperoperation : ℕ → ℕ → ℕ → ℕ
  
goal: ℕ → ℕ → ℕ → ℕ

full_name: hyperoperation_zero
code: @[simp]
theorem hyperoperation_zero (m : ℕ) : hyperoperation 0 m = Nat.succ 
goal: hyperoperation 0 m = Nat.succ

full_name: hyperoperation_ge_three_eq_one
code: theorem hyperoperation_ge_three_eq_one (n m : ℕ) : hyperoperation (n + 3) m 0 = 1 
goal: hyperoperation (n + 3) m 0 = 1

full_name: hyperoperation_recursion
code: theorem hyperoperation_recursion (n m k : ℕ) :
    hyperoperation (n + 1) m (k + 1) = hyperoperation n m (hyperoperation (n + 1) m k) 
goal: hyperoperation (n + 1) m (k + 1) = hyperoperation n m (hyperoperation (n + 1) m k)

full_name: hyperoperation_one
code: @[simp]
theorem hyperoperation_one : hyperoperation 1 = (· + ·) 
goal: hyperoperation 1 = fun x x_1 => x + x_1

full_name: hyperoperation_two
code: @[simp]
theorem hyperoperation_two : hyperoperation 2 = (· * ·) 
goal: hyperoperation 2 = fun x x_1 => x * x_1

full_name: hyperoperation_three
code: @[simp]
theorem hyperoperation_three : hyperoperation 3 = (· ^ ·) 
goal: hyperoperation 3 = fun x x_1 => x ^ x_1

full_name: hyperoperation_ge_two_eq_self
code: theorem hyperoperation_ge_two_eq_self (n m : ℕ) : hyperoperation (n + 2) m 1 = m 
goal: hyperoperation (n + 2) m 1 = m

full_name: hyperoperation_two_two_eq_four
code: theorem hyperoperation_two_two_eq_four (n : ℕ) : hyperoperation (n + 1) 2 2 = 4 
goal: hyperoperation (n + 1) 2 2 = 4

full_name: hyperoperation_ge_three_one
code: theorem hyperoperation_ge_three_one (n : ℕ) : ∀ k : ℕ, hyperoperation (n + 3) 1 k = 1 
goal: hyperoperation (n + 3) 1 k = 1

full_name: hyperoperation_ge_four_zero
code: theorem hyperoperation_ge_four_zero (n k : ℕ) :
    hyperoperation (n + 4) 0 k = if Even k then 1 else 0 
goal: hyperoperation (n + 4) 0 k = if Even k then 1 else 0
File: Mathlib/Data/Nat/MaxPowDiv.lean

full_name: Nat.maxPowDiv.go
code: /--
Tail recursive function which returns the largest `k : ℕ` such that `p ^ k ∣ n` for any `p : ℕ`.
`padicValNat_eq_maxPowDiv` allows the code generator to use this definition for `padicValNat`
-/
def maxPowDiv (p n : ℕ) : ℕ 
goal: ℕ

full_name: Nat.maxPowDiv
code: /--
Tail recursive function which returns the largest `k : ℕ` such that `p ^ k ∣ n` for any `p : ℕ`.
`padicValNat_eq_maxPowDiv` allows the code generator to use this definition for `padicValNat`
-/
def maxPowDiv (p n : ℕ) : ℕ 
goal: ℕ

full_name: Nat.maxPowDiv.go_succ
code: theorem go_succ {k p n : ℕ} : go (k+1) p n = go k p n + 1 
goal: Nat.maxPowDiv.go (k + 1) p n = Nat.maxPowDiv.go k p n + 1

full_name: Nat.maxPowDiv.zero_base
code: @[simp]
theorem zero_base {n : ℕ} : maxPowDiv 0 n = 0 
goal: Nat.maxPowDiv 0 n = 0

full_name: Nat.maxPowDiv.zero
code: @[simp]
theorem zero {p : ℕ} : maxPowDiv p 0 = 0 
goal: p.maxPowDiv 0 = 0

full_name: Nat.maxPowDiv.base_mul_eq_succ
code: theorem base_mul_eq_succ {p n : ℕ} (hp : 1 < p) (hn : 0 < n) :
    p.maxPowDiv (p*n) = p.maxPowDiv n + 1 
goal: p.maxPowDiv (p * n) = p.maxPowDiv n + 1

full_name: Nat.maxPowDiv.base_pow_mul
code: theorem base_pow_mul {p n exp : ℕ} (hp : 1 < p) (hn : 0 < n) :
    p.maxPowDiv (p ^ exp * n) = p.maxPowDiv n + exp 
goal: p.maxPowDiv (p ^ exp * n) = p.maxPowDiv n + exp

full_name: Nat.maxPowDiv.pow_dvd
code: theorem pow_dvd (p n : ℕ) : p ^ (p.maxPowDiv n) ∣ n 
goal: p ^ p.maxPowDiv n ∣ n

full_name: Nat.maxPowDiv.le_of_dvd
code: theorem le_of_dvd {p n pow : ℕ} (hp : 1 < p) (hn : 0 < n) (h : p ^ pow ∣ n) :
    pow ≤ p.maxPowDiv n 
goal: pow ≤ p.maxPowDiv n
File: Mathlib/Data/Nat/Dist.lean

full_name: Nat.dist
code: /-- Distance (absolute value of difference) between natural numbers. -/
def dist (n m : ℕ) 
goal: ℕ

full_name: Nat.dist_comm
code: theorem dist_comm (n m : ℕ) : dist n m = dist m n 
goal: n.dist m = m.dist n

full_name: Nat.dist_self
code: @[simp]
theorem dist_self (n : ℕ) : dist n n = 0 
goal: n.dist n = 0

full_name: Nat.eq_of_dist_eq_zero
code: theorem eq_of_dist_eq_zero {n m : ℕ} (h : dist n m = 0) : n = m 
goal: n = m

full_name: Nat.dist_eq_zero
code: theorem dist_eq_zero {n m : ℕ} (h : n = m) : dist n m = 0 
goal: n.dist m = 0

full_name: Nat.dist_eq_sub_of_le
code: theorem dist_eq_sub_of_le {n m : ℕ} (h : n ≤ m) : dist n m = m - n 
goal: n.dist m = m - n

full_name: Nat.dist_eq_sub_of_le_right
code: theorem dist_eq_sub_of_le_right {n m : ℕ} (h : m ≤ n) : dist n m = n - m 
goal: n.dist m = n - m

full_name: Nat.dist_tri_left
code: theorem dist_tri_left (n m : ℕ) : m ≤ dist n m + n 
goal: m ≤ n.dist m + n

full_name: Nat.dist_tri_right
code: theorem dist_tri_right (n m : ℕ) : m ≤ n + dist n m 
goal: m ≤ n + n.dist m

full_name: Nat.dist_tri_left'
code: theorem dist_tri_left' (n m : ℕ) : n ≤ dist n m + m 
goal: n ≤ n.dist m + m

full_name: Nat.dist_tri_right'
code: theorem dist_tri_right' (n m : ℕ) : n ≤ m + dist n m 
goal: n ≤ m + n.dist m

full_name: Nat.dist_zero_right
code: theorem dist_zero_right (n : ℕ) : dist n 0 = n 
goal: n.dist 0 = n

full_name: Nat.dist_zero_left
code: theorem dist_zero_left (n : ℕ) : dist 0 n = n 
goal: Nat.dist 0 n = n

full_name: Nat.dist_add_add_right
code: theorem dist_add_add_right (n k m : ℕ) : dist (n + k) (m + k) = dist n m 
goal: (n + k).dist (m + k) = n.dist m

full_name: Nat.dist_add_add_left
code: theorem dist_add_add_left (k n m : ℕ) : dist (k + n) (k + m) = dist n m 
goal: (k + n).dist (k + m) = n.dist m

full_name: Nat.dist_eq_intro
code: theorem dist_eq_intro {n m k l : ℕ} (h : n + m = k + l) : dist n k = dist l m 
goal: n.dist k = l.dist m

full_name: Nat.dist.triangle_inequality
code: theorem dist.triangle_inequality (n m k : ℕ) : dist n k ≤ dist n m + dist m k 
goal: n.dist k ≤ n.dist m + m.dist k

full_name: Nat.dist_mul_right
code: theorem dist_mul_right (n k m : ℕ) : dist (n * k) (m * k) = dist n m * k 
goal: (n * k).dist (m * k) = n.dist m * k

full_name: Nat.dist_mul_left
code: theorem dist_mul_left (k n m : ℕ) : dist (k * n) (k * m) = k * dist n m 
goal: (k * n).dist (k * m) = k * n.dist m

full_name: Nat.dist_eq_max_sub_min
code: theorem dist_eq_max_sub_min {i j : ℕ} : dist i j = (max i j) - min i j 
goal: i.dist j = max i j - min i j

full_name: Nat.dist_succ_succ
code: theorem dist_succ_succ {i j : Nat} : dist (succ i) (succ j) = dist i j 
goal: i.succ.dist j.succ = i.dist j

full_name: Nat.dist_pos_of_ne
code: theorem dist_pos_of_ne {i j : Nat} : i ≠ j → 0 < dist i j 
goal: i ≠ j → 0 < i.dist j
File: Mathlib/Data/Nat/GCD/BigOperators.lean

full_name: Nat.coprime_list_prod_left_iff
code: theorem coprime_list_prod_left_iff {l : List ℕ} {k : ℕ} :
    Coprime l.prod k ↔ ∀ n ∈ l, Coprime n k 
goal: l.prod.Coprime k ↔ ∀ n ∈ l, n.Coprime k

full_name: Nat.coprime_list_prod_right_iff
code: theorem coprime_list_prod_right_iff {k : ℕ} {l : List ℕ} :
    Coprime k l.prod ↔ ∀ n ∈ l, Coprime k n 
goal: k.Coprime l.prod ↔ ∀ n ∈ l, k.Coprime n

full_name: Nat.coprime_multiset_prod_left_iff
code: theorem coprime_multiset_prod_left_iff {m : Multiset ℕ} {k : ℕ} :
    Coprime m.prod k ↔ ∀ n ∈ m, Coprime n k 
goal: m.prod.Coprime k ↔ ∀ n ∈ m, n.Coprime k

full_name: Nat.coprime_multiset_prod_right_iff
code: theorem coprime_multiset_prod_right_iff {k : ℕ} {m : Multiset ℕ} :
    Coprime k m.prod ↔ ∀ n ∈ m, Coprime k n 
goal: k.Coprime m.prod ↔ ∀ n ∈ m, k.Coprime n

full_name: Nat.coprime_prod_left_iff
code: theorem coprime_prod_left_iff {t : Finset ι} {s : ι → ℕ} {x : ℕ} :
    Coprime (∏ i ∈ t, s i) x ↔ ∀ i ∈ t, Coprime (s i) x 
goal: (∏ i ∈ t, s i).Coprime x ↔ ∀ i ∈ t, (s i).Coprime x

full_name: Nat.coprime_prod_right_iff
code: theorem coprime_prod_right_iff {x : ℕ} {t : Finset ι} {s : ι → ℕ} :
    Coprime x (∏ i ∈ t, s i) ↔ ∀ i ∈ t, Coprime x (s i) 
goal: x.Coprime (∏ i ∈ t, s i) ↔ ∀ i ∈ t, x.Coprime (s i)

full_name: Nat.coprime_fintype_prod_left_iff
code: theorem coprime_fintype_prod_left_iff [Fintype ι] {s : ι → ℕ} {x : ℕ} :
    Coprime (∏ i, s i) x ↔ ∀ i, Coprime (s i) x 
goal: (∏ i : ι, s i).Coprime x ↔ ∀ (i : ι), (s i).Coprime x

full_name: Nat.coprime_fintype_prod_right_iff
code: theorem coprime_fintype_prod_right_iff [Fintype ι] {x : ℕ} {s : ι → ℕ} :
    Coprime x (∏ i, s i) ↔ ∀ i, Coprime x (s i) 
goal: x.Coprime (∏ i : ι, s i) ↔ ∀ (i : ι), x.Coprime (s i)
File: Mathlib/Data/Nat/Choose/Dvd.lean

full_name: Nat.Prime.dvd_choose_add
code: theorem dvd_choose_add (hp : Prime p) (hap : a < p) (hbp : b < p) (h : p ≤ a + b) :
    p ∣ choose (a + b) a 
goal: p ∣ (a + b).choose a

full_name: Nat.Prime.dvd_choose
code: lemma dvd_choose (hp : Prime p) (ha : a < p) (hab : b - a < p) (h : p ≤ b) : p ∣ choose b a 
goal: p ∣ b.choose a

full_name: Nat.Prime.dvd_choose_self
code: lemma dvd_choose_self (hp : Prime p) (hk : k ≠ 0) (hkp : k < p) : p ∣ choose p k 
goal: p ∣ p.choose k
File: Mathlib/Data/Nat/Choose/Cast.lean

full_name: Nat.cast_choose
code: theorem cast_choose {a b : ℕ} (h : a ≤ b) : (b.choose a : K) = b ! / (a ! * (b - a)!) 
goal: ↑(b.choose a) = ↑b ! / (↑a ! * ↑(b - a)!)

full_name: Nat.cast_add_choose
code: theorem cast_add_choose {a b : ℕ} : ((a + b).choose a : K) = (a + b)! / (a ! * b !) 
goal: ↑((a + b).choose a) = ↑(a + b)! / (↑a ! * ↑b !)

full_name: Nat.cast_choose_eq_ascPochhammer_div
code: theorem cast_choose_eq_ascPochhammer_div (a b : ℕ) :
    (a.choose b : K) = (ascPochhammer K b).eval ↑(a - (b - 1)) / b ! 
goal: ↑(a.choose b) = Polynomial.eval (↑(a - (b - 1))) (ascPochhammer K b) / ↑b !

full_name: Nat.cast_choose_two
code: theorem cast_choose_two (a : ℕ) : (a.choose 2 : K) = a * (a - 1) / 2 
goal: ↑(a.choose 2) = ↑a * (↑a - 1) / 2
File: Mathlib/Data/Nat/Choose/Vandermonde.lean

full_name: Nat.add_choose_eq
code: /-- Vandermonde's identity -/
theorem Nat.add_choose_eq (m n k : ℕ) :
    (m + n).choose k = ∑ ij ∈ antidiagonal k, m.choose ij.1 * n.choose ij.2 
goal: (m + n).choose k = ∑ ij ∈ Finset.antidiagonal k, m.choose ij.1 * n.choose ij.2
File: Mathlib/Data/Nat/Periodic.lean

full_name: Nat.periodic_gcd
code: theorem periodic_gcd (a : ℕ) : Periodic (gcd a) a 
goal: Function.Periodic a.gcd a

full_name: Nat.periodic_coprime
code: theorem periodic_coprime (a : ℕ) : Periodic (Coprime a) a 
goal: Function.Periodic a.Coprime a

full_name: Nat.periodic_mod
code: theorem periodic_mod (a : ℕ) : Periodic (fun n => n % a) a 
goal: Function.Periodic (fun n => n % a) a

full_name: Function.Periodic.map_mod_nat
code: theorem _root_.Function.Periodic.map_mod_nat {α : Type*} {f : ℕ → α} {a : ℕ} (hf : Periodic f a) :
    ∀ n, f (n % a) = f n 
goal: f (n % a) = f n

full_name: Nat.filter_multiset_Ico_card_eq_of_periodic
code: /-- An interval of length `a` filtered over a periodic predicate of period `a` has cardinality
equal to the number naturals below `a` for which `p a` is true. -/
theorem filter_multiset_Ico_card_eq_of_periodic (n a : ℕ) (p : ℕ → Prop) [DecidablePred p]
    (pp : Periodic p a) : card (filter p (Ico n (n + a))) = a.count p 
goal: Multiset.card (Multiset.filter p (Multiset.Ico n (n + a))) = Nat.count p a

full_name: Nat.filter_Ico_card_eq_of_periodic
code: /-- An interval of length `a` filtered over a periodic predicate of period `a` has cardinality
equal to the number naturals below `a` for which `p a` is true. -/
theorem filter_Ico_card_eq_of_periodic (n a : ℕ) (p : ℕ → Prop) [DecidablePred p]
    (pp : Periodic p a) : ((Ico n (n + a)).filter p).card = a.count p 
goal: (Finset.filter p (Finset.Ico n (n + a))).card = Nat.count p a
File: Mathlib/Data/Nat/Choose/Bounds.lean

full_name: Nat.choose_le_pow
code: theorem choose_le_pow (r n : ℕ) : (n.choose r : α) ≤ (n ^ r : α) / r ! 
goal: ↑(n.choose r) ≤ ↑n ^ r / ↑r !

full_name: Nat.pow_le_choose
code: theorem pow_le_choose (r n : ℕ) : ((n + 1 - r : ℕ) ^ r : α) / r ! ≤ n.choose r 
goal: ↑(n + 1 - r) ^ r / ↑r ! ≤ ↑(n.choose r)