ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib.Meta.NormNum.isRat_lt_false
theorem isRat_lt_false [LinearOrderedRing α] {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 α] {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
-- Mathlib.Meta.NormNum.isNat_lt_true
theorem isNat_lt_true [OrderedSemiring α] [CharZero α] : {a b : α} → {a' b' : ℕ} →
    IsNat a a' → IsNat b b' → Nat.ble b' a' = false → a < b
  
Arguments: {α : Type u_1} [OrderedSemiring α] [CharZero α] {a b : α} {a' b' : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat a a' → Mathlib.Meta.NormNum.IsNat b b' → b'.ble a' = false → a < b
-- Mathlib.Meta.NormNum.isNat_le_false
theorem isNat_le_false [OrderedSemiring α] [CharZero α] {a b : α} {a' b' : ℕ}
    (ha : IsNat a a') (hb : IsNat b b') (h : Nat.ble a' b' = false) : ¬a ≤ b 
Arguments: {α : Type u_1} [OrderedSemiring α] [CharZero α] {a b : α} {a' b' : ℕ} (ha : Mathlib.Meta.NormNum.IsNat a a') (hb : Mathlib.Meta.NormNum.IsNat b b') (h : a'.ble b' = false)
Goal: ¬a ≤ b
-- Mathlib.Meta.NormNum.isInt_le_true
theorem isInt_le_true [OrderedRing α] : {a b : α} → {a' b' : ℤ} →
    IsInt a a' → IsInt b b' → decide (a' ≤ b') → a ≤ b
  
Arguments: {α : Type u_1} [OrderedRing α] {a b : α} {a' b' : ℤ}
Goal: Mathlib.Meta.NormNum.IsInt a a' → Mathlib.Meta.NormNum.IsInt b b' → decide (a' ≤ b') = true → a ≤ b
-- Mathlib.Meta.NormNum.isInt_lt_true
theorem isInt_lt_true [OrderedRing α] [Nontrivial α] : {a b : α} → {a' b' : ℤ} →
    IsInt a a' → IsInt b b' → decide (a' < b') → a < b
  
Arguments: {α : Type u_1} [OrderedRing α] [Nontrivial α] {a b : α} {a' b' : ℤ}
Goal: Mathlib.Meta.NormNum.IsInt a a' → Mathlib.Meta.NormNum.IsInt b b' → decide (a' < b') = true → a < b
-- Mathlib.Meta.NormNum.isInt_le_false
theorem isInt_le_false [OrderedRing α] [Nontrivial α] {a b : α} {a' b' : ℤ}
    (ha : IsInt a a') (hb : IsInt b b') (h : decide (b' < a')) : ¬a ≤ b 
Arguments: {α : Type u_1} [OrderedRing α] [Nontrivial α] {a b : α} {a' b' : ℤ} (ha : Mathlib.Meta.NormNum.IsInt a a') (hb : Mathlib.Meta.NormNum.IsInt b b') (h : decide (b' < a') = true)
Goal: ¬a ≤ b
-- Mathlib.Meta.NormNum.isInt_lt_false
theorem isInt_lt_false [OrderedRing α] {a b : α} {a' b' : ℤ}
    (ha : IsInt a a') (hb : IsInt b b') (h : decide (b' ≤ a')) : ¬a < b 
Arguments: {α : Type u_1} [OrderedRing α] {a b : α} {a' b' : ℤ} (ha : Mathlib.Meta.NormNum.IsInt a a') (hb : Mathlib.Meta.NormNum.IsInt b b') (h : decide (b' ≤ a') = true)
Goal: ¬a < b
-- Mathlib.Tactic.Zify.natCast_eq
@[zify_simps] lemma natCast_eq (a b : Nat) : a = b ↔ (a : Int) = (b : Int) 
Arguments: (a b : ℕ)
Goal: a = b ↔ ↑a = ↑b
-- Mathlib.Tactic.Zify.natCast_le
@[zify_simps] lemma natCast_le (a b : Nat) : a ≤ b ↔ (a : Int) ≤ (b : Int) 
Arguments: (a b : ℕ)
Goal: a ≤ b ↔ ↑a ≤ ↑b
-- Mathlib.Tactic.Zify.natCast_lt
@[zify_simps] lemma natCast_lt (a b : Nat) : a < b ↔ (a : Int) < (b : Int) 
Arguments: (a b : ℕ)
Goal: a < b ↔ ↑a < ↑b
-- Mathlib.Tactic.Zify.natCast_ne
@[zify_simps] lemma natCast_ne (a b : Nat) : a ≠ b ↔ (a : Int) ≠ (b : Int) 
Arguments: (a b : ℕ)
Goal: a ≠ b ↔ ↑a ≠ ↑b
-- Mathlib.Tactic.Zify.natCast_dvd
@[zify_simps] lemma natCast_dvd (a b : Nat) : a ∣ b ↔ (a : Int) ∣ (b : Int) 
Arguments: (a b : ℕ)
Goal: a ∣ b ↔ ↑a ∣ ↑b
-- Mathlib.Tactic.Zify.Nat.cast_sub_of_add_le
@[norm_cast] theorem Nat.cast_sub_of_add_le {m n k} (h : m + k ≤ n) :
    ((n - m : ℕ) : R) = n - m 
Arguments: {R : Type u_1} [AddGroupWithOne R] {m n k : ℕ} (h : m + k ≤ n)
Goal: ↑(n - m) = ↑n - ↑m
-- Mathlib.Tactic.Zify.Nat.cast_sub_of_lt
@[norm_cast] theorem Nat.cast_sub_of_lt {m n} (h : m < n) :
    ((n - m : ℕ) : R) = n - m 
Arguments: {R : Type u_1} [AddGroupWithOne R] {m n : ℕ} (h : m < n)
Goal: ↑(n - m) = ↑n - ↑m
-- Mathlib.Tactic.NoncommRing.nat_lit_mul_eq_nsmul
lemma nat_lit_mul_eq_nsmul [n.AtLeastTwo] : no_index (OfNat.ofNat n) * r = n • r 
Arguments: {R : Type u_1} [NonAssocSemiring R] (r : R) (n : ℕ) [n.AtLeastTwo]
Goal: OfNat.ofNat n * r = n • r
-- Mathlib.Tactic.NoncommRing.mul_nat_lit_eq_nsmul
lemma mul_nat_lit_eq_nsmul [n.AtLeastTwo] : r * no_index (OfNat.ofNat n) = n • r 
Arguments: {R : Type u_1} [NonAssocSemiring R] (r : R) (n : ℕ) [n.AtLeastTwo]
Goal: r * OfNat.ofNat n = n • r
-- Mathlib.Meta.NormNum.IsInt.raw_refl
theorem IsInt.raw_refl (n : ℤ) : IsInt n n 
Arguments: (n : ℤ)
Goal: Mathlib.Meta.NormNum.IsInt n n
-- Mathlib.Meta.NormNum.isNat_zero
theorem isNat_zero (α) [AddMonoidWithOne α] : IsNat (Zero.zero : α) (nat_lit 0) 
Arguments: (α : Type u_1) [AddMonoidWithOne α]
Goal: Mathlib.Meta.NormNum.IsNat Zero.zero 0
-- Mathlib.Meta.NormNum.isNat_one
theorem isNat_one (α) [AddMonoidWithOne α] : IsNat (One.one : α) (nat_lit 1) 
Arguments: (α : Type u_1) [AddMonoidWithOne α]
Goal: Mathlib.Meta.NormNum.IsNat One.one 1
-- Mathlib.Meta.NormNum.isNat_ofNat
theorem isNat_ofNat (α : Type u) [AddMonoidWithOne α] {a : α} {n : ℕ}
    (h : n = a) : IsNat a n 
Arguments: (α : Type u) [AddMonoidWithOne α] {a : α} {n : ℕ} (h : ↑n = a)
Goal: Mathlib.Meta.NormNum.IsNat a n
-- Mathlib.Meta.NormNum.isNat_intOfNat
theorem isNat_intOfNat : {n n' : ℕ} → IsNat n n' → IsNat (Int.ofNat n) n'
  
Arguments: {n n' : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat n n' → Mathlib.Meta.NormNum.IsNat (Int.ofNat n) n'
-- Mathlib.Meta.NormNum.isNat_natAbs_pos
theorem isNat_natAbs_pos : {n : ℤ} → {a : ℕ} → IsNat n a → IsNat n.natAbs a
  
Arguments: {n : ℤ} {a : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat n a → Mathlib.Meta.NormNum.IsNat n.natAbs a
-- Mathlib.Meta.NormNum.isNat_natAbs_neg
theorem isNat_natAbs_neg : {n : ℤ} → {a : ℕ} → IsInt n (.negOfNat a) → IsNat n.natAbs a
  
Arguments: {n : ℤ} {a : ℕ}
Goal: Mathlib.Meta.NormNum.IsInt n (Int.negOfNat a) → Mathlib.Meta.NormNum.IsNat n.natAbs a
-- Mathlib.Meta.NormNum.isNat_natCast
theorem isNat_natCast {R} [AddMonoidWithOne R] (n m : ℕ) :
    IsNat n m → IsNat (n : R) m 
Arguments: {R : Type u_1} [AddMonoidWithOne R] (n m : ℕ)
Goal: Mathlib.Meta.NormNum.IsNat n m → Mathlib.Meta.NormNum.IsNat (↑n) m
-- Mathlib.Meta.NormNum.isNat_intCast
theorem isNat_intCast {R} [Ring R] (n : ℤ) (m : ℕ) :
    IsNat n m → IsNat (n : R) m 
Arguments: {R : Type u_1} [Ring R] (n : ℤ) (m : ℕ)
Goal: Mathlib.Meta.NormNum.IsNat n m → Mathlib.Meta.NormNum.IsNat (↑n) m
-- Mathlib.Meta.NormNum.isintCast
theorem isintCast {R} [Ring R] (n m : ℤ) :
    IsInt n m → IsInt (n : R) m 
Arguments: {R : Type u_1} [Ring R] (n m : ℤ)
Goal: Mathlib.Meta.NormNum.IsInt n m → Mathlib.Meta.NormNum.IsInt (↑n) m
-- Mathlib.Meta.NormNum.isNat_add
theorem isNat_add {α} [AddMonoidWithOne α] : ∀ {f : α → α → α} {a b : α} {a' b' c : ℕ},
    f = HAdd.hAdd → IsNat a a' → IsNat b b' → Nat.add a' b' = c → IsNat (f a b) c
  
Arguments: {α : Type u_1} [AddMonoidWithOne α] {f : α → α → α} {a b : α} {a' b' c : ℕ}
Goal: f = HAdd.hAdd →
  Mathlib.Meta.NormNum.IsNat a a' →
    Mathlib.Meta.NormNum.IsNat b b' → a'.add b' = c → Mathlib.Meta.NormNum.IsNat (f a b) c
-- Mathlib.Meta.NormNum.isInt_add
theorem isInt_add {α} [Ring α] : ∀ {f : α → α → α} {a b : α} {a' b' c : ℤ},
    f = HAdd.hAdd → IsInt a a' → IsInt b b' → Int.add a' b' = c → IsInt (f a b) c
  
Arguments: {α : Type u_1} [Ring α] {f : α → α → α} {a b : α} {a' b' c : ℤ}
Goal: f = HAdd.hAdd →
  Mathlib.Meta.NormNum.IsInt a a' →
    Mathlib.Meta.NormNum.IsInt b b' → a'.add b' = c → Mathlib.Meta.NormNum.IsInt (f a b) c
-- Mathlib.Meta.NormNum.isRat_add
theorem isRat_add {α} [Ring α] {f : α → α → α} {a b : α} {na nb nc : ℤ} {da db dc k : ℕ} :
    f = HAdd.hAdd → IsRat a na da → IsRat b nb db →
    Int.add (Int.mul na db) (Int.mul nb da) = Int.mul k nc →
    Nat.mul da db = Nat.mul k dc →
    IsRat (f a b) nc dc 
Arguments: {α : Type u_1} [Ring α] {f : α → α → α} {a b : α} {na nb nc : ℤ} {da db dc k : ℕ}
Goal: f = HAdd.hAdd →
  Mathlib.Meta.NormNum.IsRat a na da →
    Mathlib.Meta.NormNum.IsRat b nb db →
      (na.mul ↑db).add (nb.mul ↑da) = (↑k).mul nc → da.mul db = k.mul dc → Mathlib.Meta.NormNum.IsRat (f a b) nc dc
-- Mathlib.Meta.NormNum.isInt_neg
theorem isInt_neg {α} [Ring α] : ∀ {f : α → α} {a : α} {a' b : ℤ},
    f = Neg.neg → IsInt a a' → Int.neg a' = b → IsInt (-a) b
  
Arguments: {α : Type u_1} [Ring α] {f : α → α} {a : α} {a' b : ℤ}
Goal: f = Neg.neg → Mathlib.Meta.NormNum.IsInt a a' → a'.neg = b → Mathlib.Meta.NormNum.IsInt (-a) b
-- Mathlib.Meta.NormNum.isRat_neg
theorem isRat_neg {α} [Ring α] : ∀ {f : α → α} {a : α} {n n' : ℤ} {d : ℕ},
    f = Neg.neg → IsRat a n d → Int.neg n = n' → IsRat (-a) n' d
  
Arguments: {α : Type u_1} [Ring α] {f : α → α} {a : α} {n n' : ℤ} {d : ℕ}
Goal: f = Neg.neg → Mathlib.Meta.NormNum.IsRat a n d → n.neg = n' → Mathlib.Meta.NormNum.IsRat (-a) n' d
-- Mathlib.Meta.NormNum.isInt_sub
theorem isInt_sub {α} [Ring α] : ∀ {f : α → α → α} {a b : α} {a' b' c : ℤ},
    f = HSub.hSub → IsInt a a' → IsInt b b' → Int.sub a' b' = c → IsInt (f a b) c
  
Arguments: {α : Type u_1} [Ring α] {f : α → α → α} {a b : α} {a' b' c : ℤ}
Goal: f = HSub.hSub →
  Mathlib.Meta.NormNum.IsInt a a' →
    Mathlib.Meta.NormNum.IsInt b b' → a'.sub b' = c → Mathlib.Meta.NormNum.IsInt (f a b) c
-- Mathlib.Meta.NormNum.isRat_sub
theorem isRat_sub {α} [Ring α] {f : α → α → α} {a b : α} {na nb nc : ℤ} {da db dc k : ℕ}
    (hf : f = HSub.hSub) (ra : IsRat a na da) (rb : IsRat b nb db)
    (h₁ : Int.sub (Int.mul na db) (Int.mul nb da) = Int.mul k nc)
    (h₂ : Nat.mul da db = Nat.mul k dc) :
    IsRat (f a b) nc dc 
Arguments: {α : Type u_1} [Ring α] {f : α → α → α} {a b : α} {na nb nc : ℤ} {da db dc k : ℕ} (hf : f = HSub.hSub) (ra : Mathlib.Meta.NormNum.IsRat a na da) (rb : Mathlib.Meta.NormNum.IsRat b nb db) (h₁ : (na.mul ↑db).sub (nb.mul ↑da) = (↑k).mul nc) (h₂ : da.mul db = k.mul dc)
Goal: Mathlib.Meta.NormNum.IsRat (f a b) nc dc
-- Mathlib.Meta.NormNum.isNat_mul
theorem isNat_mul {α} [Semiring α] : ∀ {f : α → α → α} {a b : α} {a' b' c : ℕ},
    f = HMul.hMul → IsNat a a' → IsNat b b' → Nat.mul a' b' = c → IsNat (a * b) c
  
Arguments: {α : Type u_1} [Semiring α] {f : α → α → α} {a b : α} {a' b' c : ℕ}
Goal: f = HMul.hMul →
  Mathlib.Meta.NormNum.IsNat a a' →
    Mathlib.Meta.NormNum.IsNat b b' → a'.mul b' = c → Mathlib.Meta.NormNum.IsNat (a * b) c
-- Mathlib.Meta.NormNum.isInt_mul
theorem isInt_mul {α} [Ring α] : ∀ {f : α → α → α} {a b : α} {a' b' c : ℤ},
    f = HMul.hMul → IsInt a a' → IsInt b b' → Int.mul a' b' = c → IsInt (a * b) c
  
Arguments: {α : Type u_1} [Ring α] {f : α → α → α} {a b : α} {a' b' c : ℤ}
Goal: f = HMul.hMul →
  Mathlib.Meta.NormNum.IsInt a a' →
    Mathlib.Meta.NormNum.IsInt b b' → a'.mul b' = c → Mathlib.Meta.NormNum.IsInt (a * b) c
-- Mathlib.Meta.NormNum.isRat_mul
theorem isRat_mul {α} [Ring α] {f : α → α → α} {a b : α} {na nb nc : ℤ} {da db dc k : ℕ} :
    f = HMul.hMul → IsRat a na da → IsRat b nb db →
    Int.mul na nb = Int.mul k nc →
    Nat.mul da db = Nat.mul k dc →
    IsRat (f a b) nc dc 
Arguments: {α : Type u_1} [Ring α] {f : α → α → α} {a b : α} {na nb nc : ℤ} {da db dc k : ℕ}
Goal: f = HMul.hMul →
  Mathlib.Meta.NormNum.IsRat a na da →
    Mathlib.Meta.NormNum.IsRat b nb db →
      na.mul nb = (↑k).mul nc → da.mul db = k.mul dc → Mathlib.Meta.NormNum.IsRat (f a b) nc dc
-- Mathlib.Meta.NormNum.isRat_div
theorem isRat_div {α : Type u} [DivisionRing α] : {a b : α} → {cn : ℤ} → {cd : ℕ} →
    IsRat (a * b⁻¹) cn cd → IsRat (a / b) cn cd
  
Arguments: {α : Type u} [DivisionRing α] {a b : α} {cn : ℤ} {cd : ℕ}
Goal: Mathlib.Meta.NormNum.IsRat (a * b⁻¹) cn cd → Mathlib.Meta.NormNum.IsRat (a / b) cn cd
-- Mathlib.Meta.NormNum.isNat_eq_true
theorem isNat_eq_true [AddMonoidWithOne α] : {a b : α} → {c : ℕ} →
    IsNat a c → IsNat b c → a = b
  
Arguments: {α : Type u} [AddMonoidWithOne α] {a b : α} {c : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat a c → Mathlib.Meta.NormNum.IsNat b c → a = b
-- Mathlib.Meta.NormNum.ble_eq_false
theorem ble_eq_false {x y : ℕ} : x.ble y = false ↔ y < x 
Arguments: {x y : ℕ}
Goal: x.ble y = false ↔ y < x
-- Mathlib.Meta.NormNum.isInt_eq_true
theorem isInt_eq_true [Ring α] : {a b : α} → {z : ℤ} → IsInt a z → IsInt b z → a = b
  
Arguments: {α : Type u} [Ring α] {a b : α} {z : ℤ}
Goal: Mathlib.Meta.NormNum.IsInt a z → Mathlib.Meta.NormNum.IsInt b z → a = b
-- Mathlib.Meta.NormNum.isRat_eq_true
theorem isRat_eq_true [Ring α] : {a b : α} → {n : ℤ} → {d : ℕ} →
    IsRat a n d → IsRat b n d → a = b
  
Arguments: {α : Type u} [Ring α] {a b : α} {n : ℤ} {d : ℕ}
Goal: Mathlib.Meta.NormNum.IsRat a n d → Mathlib.Meta.NormNum.IsRat b n d → a = b
-- Mathlib.Meta.NormNum.eq_of_true
theorem eq_of_true {a b : Prop} (ha : a) (hb : b) : a = b 
Arguments: {a b : Prop} (ha : a) (hb : b)
Goal: a = b
-- Mathlib.Meta.NormNum.ne_of_false_of_true
theorem ne_of_false_of_true {a b : Prop} (ha : ¬a) (hb : b) : a ≠ b 
Arguments: {a b : Prop} (ha : ¬a) (hb : b)
Goal: a ≠ b
-- Mathlib.Meta.NormNum.ne_of_true_of_false
theorem ne_of_true_of_false {a b : Prop} (ha : a) (hb : ¬b) : a ≠ b 
Arguments: {a b : Prop} (ha : a) (hb : ¬b)
Goal: a ≠ b
-- Mathlib.Meta.NormNum.eq_of_false
theorem eq_of_false {a b : Prop} (ha : ¬a) (hb : ¬b) : a = b 
Arguments: {a b : Prop} (ha : ¬a) (hb : ¬b)
Goal: a = b
-- Mathlib.Meta.NormNum.isNat_natSucc
theorem isNat_natSucc : {a : ℕ} → {a' c : ℕ} →
    IsNat a a' → Nat.succ a' = c → IsNat (a.succ) c
  
Arguments: {a a' c : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat a a' → a'.succ = c → Mathlib.Meta.NormNum.IsNat a.succ c
-- Mathlib.Meta.NormNum.isNat_natSub
theorem isNat_natSub : {a b : ℕ} → {a' b' c : ℕ} →
    IsNat a a' → IsNat b b' → Nat.sub a' b' = c → IsNat (a - b) c
  
Arguments: {a b a' b' c : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat a a' → Mathlib.Meta.NormNum.IsNat b b' → a'.sub b' = c → Mathlib.Meta.NormNum.IsNat (a - b) c
-- Mathlib.Meta.NormNum.isNat_natMod
theorem isNat_natMod : {a b : ℕ} → {a' b' c : ℕ} →
    IsNat a a' → IsNat b b' → Nat.mod a' b' = c → IsNat (a % b) c
  
Arguments: {a b a' b' c : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat a a' → Mathlib.Meta.NormNum.IsNat b b' → a'.mod b' = c → Mathlib.Meta.NormNum.IsNat (a % b) c
-- Mathlib.Meta.NormNum.isNat_natDiv
theorem isNat_natDiv : {a b : ℕ} → {a' b' c : ℕ} →
    IsNat a a' → IsNat b b' → Nat.div a' b' = c → IsNat (a / b) c
  
Arguments: {a b a' b' c : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat a a' → Mathlib.Meta.NormNum.IsNat b b' → a'.div b' = c → Mathlib.Meta.NormNum.IsNat (a / b) c
-- Mathlib.Meta.NormNum.isNat_dvd_true
theorem isNat_dvd_true : {a b : ℕ} → {a' b' : ℕ} →
    IsNat a a' → IsNat b b' → Nat.mod b' a' = nat_lit 0 → a ∣ b
  
Arguments: {a b a' b' : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat a a' → Mathlib.Meta.NormNum.IsNat b b' → b'.mod a' = 0 → a ∣ b
-- Mathlib.Meta.NormNum.isNat_dvd_false
theorem isNat_dvd_false : {a b : ℕ} → {a' b' c : ℕ} →
    IsNat a a' → IsNat b b' → Nat.mod b' a' = Nat.succ c → ¬a ∣ b
  
Arguments: {a b a' b' c : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat a a' → Mathlib.Meta.NormNum.IsNat b b' → b'.mod a' = c.succ → ¬a ∣ b
-- Mathlib.Meta.List.range_zero'
lemma List.range_zero' {n : ℕ} (pn : NormNum.IsNat n 0) :
    List.range n = [] 
Arguments: {n : ℕ} (pn : Mathlib.Meta.NormNum.IsNat n 0)
Goal: List.range n = []
-- Mathlib.Meta.List.range_succ_eq_map'
lemma List.range_succ_eq_map' {n nn n' : ℕ} (pn : NormNum.IsNat n nn) (pn' : nn = Nat.succ n') :
    List.range n = 0 :: List.map Nat.succ (List.range n') 
Arguments: {n nn n' : ℕ} (pn : Mathlib.Meta.NormNum.IsNat n nn) (pn' : nn = n'.succ)
Goal: List.range n = 0 :: List.map Nat.succ (List.range n')
-- Mathlib.Meta.Multiset.insert_eq_cons
lemma Multiset.insert_eq_cons {α : Type*} (a : α) (s : Multiset α) :
    insert a s = Multiset.cons a s 
Arguments: {α : Type u_1} (a : α) (s : Multiset α)
Goal: insert a s = a ::ₘ s
-- Mathlib.Meta.Multiset.range_zero'
lemma Multiset.range_zero' {n : ℕ} (pn : NormNum.IsNat n 0) :
    Multiset.range n = 0 
Arguments: {n : ℕ} (pn : Mathlib.Meta.NormNum.IsNat n 0)
Goal: Multiset.range n = 0
-- Mathlib.Meta.Multiset.range_succ'
lemma Multiset.range_succ' {n nn n' : ℕ} (pn : NormNum.IsNat n nn) (pn' : nn = Nat.succ n') :
    Multiset.range n = n' ::ₘ Multiset.range n' 
Arguments: {n nn n' : ℕ} (pn : Mathlib.Meta.NormNum.IsNat n nn) (pn' : nn = n'.succ)
Goal: Multiset.range n = n' ::ₘ Multiset.range n'
-- Mathlib.Meta.Finset.insert_eq_cons
lemma Finset.insert_eq_cons {α : Type*} [DecidableEq α] (a : α) (s : Finset α) (h : a ∉ s) :
    insert a s = Finset.cons a s h 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (s : Finset α) (h : a ∉ s)
Goal: insert a s = Finset.cons a s h
-- Mathlib.Meta.Finset.range_zero'
lemma Finset.range_zero' {n : ℕ} (pn : NormNum.IsNat n 0) :
    Finset.range n = {} 
Arguments: {n : ℕ} (pn : Mathlib.Meta.NormNum.IsNat n 0)
Goal: Finset.range n = ∅
-- Mathlib.Meta.Finset.range_succ'
lemma Finset.range_succ' {n nn n' : ℕ} (pn : NormNum.IsNat n nn) (pn' : nn = Nat.succ n') :
    Finset.range n = Finset.cons n' (Finset.range n') Finset.not_mem_range_self 
Arguments: {n nn n' : ℕ} (pn : Mathlib.Meta.NormNum.IsNat n nn) (pn' : nn = n'.succ)
Goal: Finset.range n = Finset.cons n' (Finset.range n') ⋯
-- Mathlib.Meta.Finset.univ_eq_elems
lemma Finset.univ_eq_elems {α : Type*} [Fintype α] (elems : Finset α)
    (complete : ∀ x : α, x ∈ elems) :
    Finset.univ = elems 
Arguments: {α : Type u_1} [Fintype α] (elems : Finset α) (complete : ∀ (x : α), x ∈ elems)
Goal: Finset.univ = elems
-- Mathlib.Meta.NormNum.Finset.sum_empty
protected lemma Finset.sum_empty {β α : Type*} [CommSemiring β] (f : α → β) :
    IsNat (Finset.sum ∅ f) 0 
Arguments: {β : Type u_1} {α : Type u_2} [CommSemiring β] (f : α → β)
Goal: Mathlib.Meta.NormNum.IsNat (∅.sum f) 0
-- Mathlib.Meta.NormNum.Finset.prod_empty
protected lemma Finset.prod_empty {β α : Type*} [CommSemiring β] (f : α → β) :
    IsNat (Finset.prod ∅ f) 1 
Arguments: {β : Type u_1} {α : Type u_2} [CommSemiring β] (f : α → β)
Goal: Mathlib.Meta.NormNum.IsNat (∅.prod f) 1
-- Mathlib.Tactic.Group.zpow_trick
@[to_additive]
theorem zpow_trick {G : Type*} [Group G] (a b : G) (n m : ℤ) :
    a * b ^ n * b ^ m = a * b ^ (n + m) 
Arguments: {G : Type u_1} [Group G] (a b : G) (n m : ℤ)
Goal: a * b ^ n * b ^ m = a * b ^ (n + m)
-- Mathlib.Tactic.Group.zsmul_trick
@[to_additive]
theorem zpow_trick {G : Type*} [Group G] (a b : G) (n m : ℤ) :
    a * b ^ n * b ^ m = a * b ^ (n + m) 
Arguments: {G : Type u_1} [AddGroup G] (a b : G) (n m : ℤ)
Goal: a + n • b + m • b = a + (n + m) • b
-- Mathlib.Tactic.Group.zpow_trick_one
@[to_additive]
theorem zpow_trick_one {G : Type*} [Group G] (a b : G) (m : ℤ) :
    a * b * b ^ m = a * b ^ (m + 1) 
Arguments: {G : Type u_1} [Group G] (a b : G) (m : ℤ)
Goal: a * b * b ^ m = a * b ^ (m + 1)
-- Mathlib.Tactic.Group.zsmul_trick_zero
@[to_additive]
theorem zpow_trick_one {G : Type*} [Group G] (a b : G) (m : ℤ) :
    a * b * b ^ m = a * b ^ (m + 1) 
Arguments: {G : Type u_1} [AddGroup G] (a b : G) (m : ℤ)
Goal: a + b + m • b = a + (m + 1) • b
-- Mathlib.Tactic.Group.zsmul_trick_zero'
@[to_additive]
theorem zpow_trick_one' {G : Type*} [Group G] (a b : G) (n : ℤ) :
    a * b ^ n * b = a * b ^ (n + 1) 
Arguments: {G : Type u_1} [AddGroup G] (a b : G) (n : ℤ)
Goal: a + n • b + b = a + (n + 1) • b
-- Mathlib.Tactic.Group.zpow_trick_one'
@[to_additive]
theorem zpow_trick_one' {G : Type*} [Group G] (a b : G) (n : ℤ) :
    a * b ^ n * b = a * b ^ (n + 1) 
Arguments: {G : Type u_1} [Group G] (a b : G) (n : ℤ)
Goal: a * b ^ n * b = a * b ^ (n + 1)
-- Mathlib.Tactic.Contrapose.mtr
lemma mtr {p q : Prop} : (¬ q → ¬ p) → (p → q) 
Arguments: {p q : Prop}
Goal: (¬q → ¬p) → p → q
-- _private.Mathlib.Tactic.CongrExclamation.0.implies_congr'
private theorem implies_congr' {α α' : Sort u} {β β' : Sort v} (h : α = α') (h' : α' → β = β') :
    (α → β) = (α' → β') 
Arguments: {α α' : Sort u} {β β' : Sort v} (h : α = α') (h' : α' → β = β')
Goal: (α → β) = (α' → β')
-- FastSubsingleton.helim
protected theorem FastSubsingleton.helim {α β : Sort u} [FastSubsingleton α]
    (h₂ : α = β) (a : α) (b : β) : HEq a b 
Arguments: {α β : Sort u} [Lean.Meta.FastSubsingleton α] (h₂ : α = β) (a : α) (b : β)
Goal: HEq a b
-- _private.Mathlib.Tactic.CongrExclamation.0.heq_imp_of_eq_imp
private theorem heq_imp_of_eq_imp {α : Sort*} {x y : α} {p : HEq x y → Prop}
    (h : (he : x = y) → p (heq_of_eq he)) (he : HEq x y) : p he 
Arguments: {α : Sort u_1} {x y : α} {p : HEq x y → Prop} (h : ∀ (he : x = y), p ⋯) (he : HEq x y)
Goal: p he
-- _private.Mathlib.Tactic.CongrExclamation.0.eq_imp_of_iff_imp
private theorem eq_imp_of_iff_imp {x y : Prop} {p : x = y → Prop}
    (h : (he : x ↔ y) → p (propext he)) (he : x = y) : p he 
Arguments: {x y : Prop} {p : x = y → Prop} (h : ∀ (he : x ↔ y), p ⋯) (he : x = y)
Goal: p he
-- CategoryTheory.eq_whisker'
theorem eq_whisker' {X Y : C} {f g : X ⟶ Y} (w : f = g) {Z : C} (h : Y ⟶ Z) :
    f ≫ h = g ≫ h 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y : C} {f g : X ⟶ Y} (w : f = g) {Z : C} (h : Y ⟶ Z)
Goal: CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g h
-- SzemerediRegularity.biUnion_star_subset_nonuniformWitness
theorem biUnion_star_subset_nonuniformWitness :
    (star hP G ε hU V).biUnion id ⊆ G.nonuniformWitness ε U V 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] {P : Finpartition Finset.univ} (hP : P.IsEquipartition) (G : SimpleGraph α) [DecidableRel G.Adj] (ε : ℝ) {U : Finset α} (hU : U ∈ P.parts) (V : Finset α)
Goal: (SzemerediRegularity.star hP G ε hU V).biUnion id ⊆ G.nonuniformWitness ε U V
-- SzemerediRegularity.star_subset_chunk
theorem star_subset_chunk : star hP G ε hU V ⊆ (chunk hP G ε hU).parts 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] {P : Finpartition Finset.univ} {hP : P.IsEquipartition} {G : SimpleGraph α} [DecidableRel G.Adj] {ε : ℝ} {U : Finset α} {hU : U ∈ P.parts} {V : Finset α}
Goal: SzemerediRegularity.star hP G ε hU V ⊆ (SzemerediRegularity.chunk hP G ε hU).parts
-- _private.Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk.0.SzemerediRegularity.card_nonuniformWitness_sdiff_biUnion_star
private theorem card_nonuniformWitness_sdiff_biUnion_star (hV : V ∈ P.parts) (hUV : U ≠ V)
    (h₂ : ¬G.IsUniform ε U V) :
    (G.nonuniformWitness ε U V \ (star hP G ε hU V).biUnion id).card ≤
    2 ^ (P.parts.card - 1) * m 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] {P : Finpartition Finset.univ} {hP : P.IsEquipartition} {G : SimpleGraph α} [DecidableRel G.Adj] {ε : ℝ} {U : Finset α} {hU : U ∈ P.parts} {V : Finset α} (hV : V ∈ P.parts) (hUV : U ≠ V) (h₂ : ¬G.IsUniform ε U V)
Goal: (G.nonuniformWitness ε U V \ (SzemerediRegularity.star hP G ε hU V).biUnion id).card ≤
  2 ^ (P.parts.card - 1) * (Fintype.card α / SzemerediRegularity.stepBound P.parts.card)
-- _private.Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk.0.SzemerediRegularity.one_sub_eps_mul_card_nonuniformWitness_le_card_star
private theorem one_sub_eps_mul_card_nonuniformWitness_le_card_star (hV : V ∈ P.parts)
    (hUV : U ≠ V) (hunif : ¬G.IsUniform ε U V) (hPε : ↑100 ≤ ↑4 ^ P.parts.card * ε ^ 5)
    (hε₁ : ε ≤ 1) :
    (1 - ε / 10) * (G.nonuniformWitness ε U V).card ≤ ((star hP G ε hU V).biUnion id).card 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] {P : Finpartition Finset.univ} {hP : P.IsEquipartition} {G : SimpleGraph α} [DecidableRel G.Adj] {ε : ℝ} {U : Finset α} {hU : U ∈ P.parts} {V : Finset α} (hV : V ∈ P.parts) (hUV : U ≠ V) (hunif : ¬G.IsUniform ε U V) (hPε : 100 ≤ 4 ^ P.parts.card * ε ^ 5) (hε₁ : ε ≤ 1)
Goal: (1 - ε / 10) * ↑(G.nonuniformWitness ε U V).card ≤ ↑((SzemerediRegularity.star hP G ε hU V).biUnion id).card
-- SzemerediRegularity.card_chunk
theorem card_chunk (hm : m ≠ 0) : (chunk hP G ε hU).parts.card = 4 ^ P.parts.card 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] {P : Finpartition Finset.univ} {hP : P.IsEquipartition} {G : SimpleGraph α} [DecidableRel G.Adj] {ε : ℝ} {U : Finset α} {hU : U ∈ P.parts} (hm : Fintype.card α / SzemerediRegularity.stepBound P.parts.card ≠ 0)
Goal: (SzemerediRegularity.chunk hP G ε hU).parts.card = 4 ^ P.parts.card