ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib.Tactic.Ring.add_pf_add_overlap_zero
theorem add_pf_add_overlap_zero
    (h : IsNat (a₁ + b₁) (nat_lit 0)) (h₄ : a₂ + b₂ = c) : (a₁ + a₂ : R) + (b₁ + b₂) = c 
Arguments: {R : Type u_1} [CommSemiring R] {a₁ a₂ b₁ b₂ c : R} (h : Mathlib.Meta.NormNum.IsNat (a₁ + b₁) 0) (h₄ : a₂ + b₂ = c)
Goal: a₁ + a₂ + (b₁ + b₂) = c
-- Mathlib.Tactic.Ring.add_pf_add_lt
theorem add_pf_add_lt (a₁ : R) (_ : a₂ + b = c) : (a₁ + a₂) + b = a₁ + c 
Arguments: {R : Type u_1} [CommSemiring R] {a₂ b c : R} (a₁ : R)
Goal: a₂ + b = c → a₁ + a₂ + b = a₁ + c
-- Mathlib.Tactic.Ring.add_pf_add_gt
theorem add_pf_add_gt (b₁ : R) (_ : a + b₂ = c) : a + (b₁ + b₂) = b₁ + c 
Arguments: {R : Type u_1} [CommSemiring R] {a b₂ c : R} (b₁ : R)
Goal: a + b₂ = c → a + (b₁ + b₂) = b₁ + c
-- Mathlib.Tactic.Ring.one_mul
theorem one_mul (a : R) : (nat_lit 1).rawCast * a = a 
Arguments: {R : Type u_1} [CommSemiring R] (a : R)
Goal: Nat.rawCast 1 * a = a
-- Mathlib.Tactic.Ring.mul_one
theorem mul_one (a : R) : a * (nat_lit 1).rawCast = a 
Arguments: {R : Type u_1} [CommSemiring R] (a : R)
Goal: a * Nat.rawCast 1 = a
-- Mathlib.Tactic.Ring.mul_pf_left
theorem mul_pf_left (a₁ : R) (a₂) (_ : a₃ * b = c) :
    (a₁ ^ a₂ * a₃ : R) * b = a₁ ^ a₂ * c 
Arguments: {R : Type u_1} [CommSemiring R] {a₃ b c : R} (a₁ : R) (a₂ : ℕ)
Goal: a₃ * b = c → a₁ ^ a₂ * a₃ * b = a₁ ^ a₂ * c
-- Mathlib.Tactic.Ring.mul_pf_right
theorem mul_pf_right (b₁ : R) (b₂) (_ : a * b₃ = c) :
    a * (b₁ ^ b₂ * b₃) = b₁ ^ b₂ * c 
Arguments: {R : Type u_1} [CommSemiring R] {a b₃ c : R} (b₁ : R) (b₂ : ℕ)
Goal: a * b₃ = c → a * (b₁ ^ b₂ * b₃) = b₁ ^ b₂ * c
-- Mathlib.Tactic.Ring.mul_pp_pf_overlap
theorem mul_pp_pf_overlap {ea eb e : ℕ} (x : R) (_ : ea + eb = e) (_ : a₂ * b₂ = c) :
    (x ^ ea * a₂ : R) * (x ^ eb * b₂) = x ^ e * c 
Arguments: {R : Type u_1} [CommSemiring R] {a₂ b₂ c : R} {ea eb e : ℕ} (x : R)
Goal: ea + eb = e → a₂ * b₂ = c → x ^ ea * a₂ * (x ^ eb * b₂) = x ^ e * c
-- Mathlib.Tactic.Ring.mul_zero
theorem mul_zero (a : R) : a * 0 = 0 
Arguments: {R : Type u_1} [CommSemiring R] (a : R)
Goal: a * 0 = 0
-- Mathlib.Tactic.Ring.mul_add
theorem mul_add {d : R} (_ : (a : R) * b₁ = c₁) (_ : a * b₂ = c₂) (_ : c₁ + 0 + c₂ = d) :
    a * (b₁ + b₂) = d 
Arguments: {R : Type u_1} [CommSemiring R] {a b₁ b₂ c₁ c₂ d : R}
Goal: a * b₁ = c₁ → a * b₂ = c₂ → c₁ + 0 + c₂ = d → a * (b₁ + b₂) = d
-- Mathlib.Tactic.Ring.zero_mul
theorem zero_mul (b : R) : 0 * b = 0 
Arguments: {R : Type u_1} [CommSemiring R] (b : R)
Goal: 0 * b = 0
-- Mathlib.Tactic.Ring.add_mul
theorem add_mul {d : R} (_ : (a₁ : R) * b = c₁) (_ : a₂ * b = c₂) (_ : c₁ + c₂ = d) :
    (a₁ + a₂) * b = d 
Arguments: {R : Type u_1} [CommSemiring R] {a₁ a₂ b c₁ c₂ d : R}
Goal: a₁ * b = c₁ → a₂ * b = c₂ → c₁ + c₂ = d → (a₁ + a₂) * b = d
-- Mathlib.Tactic.Ring.natCast_nat
theorem natCast_nat (n) : ((Nat.rawCast n : ℕ) : R) = Nat.rawCast n 
Arguments: {R : Type u_1} [CommSemiring R] (n : ℕ)
Goal: ↑n.rawCast = n.rawCast
-- Mathlib.Tactic.Ring.natCast_mul
theorem natCast_mul {a₁ a₃ : ℕ} (a₂) (_ : ((a₁ : ℕ) : R) = b₁)
    (_ : ((a₃ : ℕ) : R) = b₃) : ((a₁ ^ a₂ * a₃ : ℕ) : R) = b₁ ^ a₂ * b₃ 
Arguments: {R : Type u_1} [CommSemiring R] {b₁ b₃ : R} {a₁ a₃ : ℕ} (a₂ : ℕ)
Goal: ↑a₁ = b₁ → ↑a₃ = b₃ → ↑(a₁ ^ a₂ * a₃) = b₁ ^ a₂ * b₃
-- Mathlib.Tactic.Ring.natCast_zero
theorem natCast_zero : ((0 : ℕ) : R) = 0 
Arguments: {R : Type u_1} [CommSemiring R]
Goal: ↑0 = 0
-- Mathlib.Tactic.Ring.natCast_add
theorem natCast_add {a₁ a₂ : ℕ}
    (_ : ((a₁ : ℕ) : R) = b₁) (_ : ((a₂ : ℕ) : R) = b₂) : ((a₁ + a₂ : ℕ) : R) = b₁ + b₂ 
Arguments: {R : Type u_1} [CommSemiring R] {b₁ b₂ : R} {a₁ a₂ : ℕ}
Goal: ↑a₁ = b₁ → ↑a₂ = b₂ → ↑(a₁ + a₂) = b₁ + b₂
-- Mathlib.Tactic.Ring.smul_nat
theorem smul_nat {a b c : ℕ} (_ : (a * b : ℕ) = c) : a • b = c 
Arguments: {a b c : ℕ}
Goal: a * b = c → a • b = c
-- Mathlib.Tactic.Ring.smul_eq_cast
theorem smul_eq_cast {a : ℕ} (_ : ((a : ℕ) : R) = a') (_ : a' * b = c) : a • b = c 
Arguments: {R : Type u_1} [CommSemiring R] {a' b c : R} {a : ℕ}
Goal: ↑a = a' → a' * b = c → a • b = c
-- Mathlib.Tactic.Ring.neg_one_mul
theorem neg_one_mul {R} [Ring R] {a b : R} (_ : (Int.negOfNat (nat_lit 1)).rawCast * a = b) :
    -a = b 
Arguments: {R : Type u_2} [Ring R] {a b : R}
Goal: (Int.negOfNat 1).rawCast * a = b → -a = b
-- Mathlib.Tactic.Ring.neg_mul
theorem neg_mul {R} [Ring R] (a₁ : R) (a₂) {a₃ b : R}
    (_ : -a₃ = b) : -(a₁ ^ a₂ * a₃) = a₁ ^ a₂ * b 
Arguments: {R : Type u_2} [Ring R] (a₁ : R) (a₂ : ℕ) {a₃ b : R}
Goal: -a₃ = b → -(a₁ ^ a₂ * a₃) = a₁ ^ a₂ * b
-- Mathlib.Tactic.Ring.neg_zero
theorem neg_zero {R} [Ring R] : -(0 : R) = 0 
Arguments: {R : Type u_2} [Ring R]
Goal: -0 = 0
-- Mathlib.Tactic.Ring.neg_add
theorem neg_add {R} [Ring R] {a₁ a₂ b₁ b₂ : R}
    (_ : -a₁ = b₁) (_ : -a₂ = b₂) : -(a₁ + a₂) = b₁ + b₂ 
Arguments: {R : Type u_2} [Ring R] {a₁ a₂ b₁ b₂ : R}
Goal: -a₁ = b₁ → -a₂ = b₂ → -(a₁ + a₂) = b₁ + b₂
-- Mathlib.Tactic.Ring.sub_pf
theorem sub_pf {R} [Ring R] {a b c d : R}
    (_ : -b = c) (_ : a + c = d) : a - b = d 
Arguments: {R : Type u_2} [Ring R] {a b c d : R}
Goal: -b = c → a + c = d → a - b = d
-- Mathlib.Tactic.Ring.pow_prod_atom
theorem pow_prod_atom (a : R) (b) : a ^ b = (a + 0) ^ b * (nat_lit 1).rawCast 
Arguments: {R : Type u_1} [CommSemiring R] (a : R) (b : ℕ)
Goal: a ^ b = (a + 0) ^ b * Nat.rawCast 1
-- Mathlib.Tactic.Ring.pow_atom
theorem pow_atom (a : R) (b) : a ^ b = a ^ b * (nat_lit 1).rawCast + 0 
Arguments: {R : Type u_1} [CommSemiring R] (a : R) (b : ℕ)
Goal: a ^ b = a ^ b * Nat.rawCast 1 + 0
-- Mathlib.Tactic.Ring.const_pos
theorem const_pos (n : ℕ) (h : Nat.ble 1 n = true) : 0 < (n.rawCast : ℕ) 
Arguments: (n : ℕ) (h : Nat.ble 1 n = true)
Goal: 0 < n.rawCast
-- Mathlib.Tactic.Ring.mul_exp_pos
theorem mul_exp_pos {a₁ a₂ : ℕ} (n) (h₁ : 0 < a₁) (h₂ : 0 < a₂) : 0 < a₁ ^ n * a₂ 
Arguments: {a₁ a₂ : ℕ} (n : ℕ) (h₁ : 0 < a₁) (h₂ : 0 < a₂)
Goal: 0 < a₁ ^ n * a₂
-- Mathlib.Tactic.Ring.add_pos_left
theorem add_pos_left {a₁ : ℕ} (a₂) (h : 0 < a₁) : 0 < a₁ + a₂ 
Arguments: {a₁ : ℕ} (a₂ : ℕ) (h : 0 < a₁)
Goal: 0 < a₁ + a₂
-- Mathlib.Tactic.Ring.add_pos_right
theorem add_pos_right {a₂ : ℕ} (a₁) (h : 0 < a₂) : 0 < a₁ + a₂ 
Arguments: {a₂ : ℕ} (a₁ : ℕ) (h : 0 < a₂)
Goal: 0 < a₁ + a₂
-- Mathlib.Tactic.Ring.pow_one
theorem pow_one (a : R) : a ^ nat_lit 1 = a 
Arguments: {R : Type u_1} [CommSemiring R] (a : R)
Goal: a ^ 1 = a
-- Mathlib.Tactic.Ring.pow_bit0
theorem pow_bit0 {k : ℕ} (_ : (a : R) ^ k = b) (_ : b * b = c) :
    a ^ (Nat.mul (nat_lit 2) k) = c 
Arguments: {R : Type u_1} [CommSemiring R] {a b c : R} {k : ℕ}
Goal: a ^ k = b → b * b = c → a ^ Nat.mul 2 k = c
-- Mathlib.Tactic.Ring.pow_bit1
theorem pow_bit1 {k : ℕ} {d : R} (_ : (a : R) ^ k = b) (_ : b * b = c) (_ : c * a = d) :
    a ^ (Nat.add (Nat.mul (nat_lit 2) k) (nat_lit 1)) = d 
Arguments: {R : Type u_1} [CommSemiring R] {a b c : R} {k : ℕ} {d : R}
Goal: a ^ k = b → b * b = c → c * a = d → a ^ (Nat.mul 2 k).add 1 = d
-- Mathlib.Tactic.Ring.one_pow
theorem one_pow (b : ℕ) : ((nat_lit 1).rawCast : R) ^ b = (nat_lit 1).rawCast 
Arguments: {R : Type u_1} [CommSemiring R] (b : ℕ)
Goal: Nat.rawCast 1 ^ b = Nat.rawCast 1
-- Mathlib.Tactic.Ring.mul_pow
theorem mul_pow {ea₁ b c₁ : ℕ} {xa₁ : R}
    (_ : ea₁ * b = c₁) (_ : a₂ ^ b = c₂) : (xa₁ ^ ea₁ * a₂ : R) ^ b = xa₁ ^ c₁ * c₂ 
Arguments: {R : Type u_1} [CommSemiring R] {a₂ c₂ : R} {ea₁ b c₁ : ℕ} {xa₁ : R}
Goal: ea₁ * b = c₁ → a₂ ^ b = c₂ → (xa₁ ^ ea₁ * a₂) ^ b = xa₁ ^ c₁ * c₂
-- Mathlib.Tactic.Ring.coeff_one
theorem coeff_one (k : ℕ) : k.rawCast = (nat_lit 1).rawCast * k 
Arguments: (k : ℕ)
Goal: k.rawCast = Nat.rawCast 1 * k
-- Mathlib.Tactic.Ring.coeff_mul
theorem coeff_mul {a₃ c₂ k : ℕ}
    (a₁ a₂ : ℕ) (_ : a₃ = c₂ * k) : a₁ ^ a₂ * a₃ = (a₁ ^ a₂ * c₂) * k 
Arguments: {a₃ c₂ k : ℕ} (a₁ a₂ : ℕ)
Goal: a₃ = c₂ * k → a₁ ^ a₂ * a₃ = a₁ ^ a₂ * c₂ * k
-- Mathlib.Tactic.Ring.pow_one_cast
theorem pow_one_cast (a : R) : a ^ (nat_lit 1).rawCast = a 
Arguments: {R : Type u_1} [CommSemiring R] (a : R)
Goal: a ^ Nat.rawCast 1 = a
-- Mathlib.Tactic.Ring.zero_pow
theorem zero_pow {b : ℕ} (_ : 0 < b) : (0 : R) ^ b = 0 
Arguments: {R : Type u_1} [CommSemiring R] {b : ℕ}
Goal: 0 < b → 0 ^ b = 0
-- Mathlib.Tactic.Ring.single_pow
theorem single_pow {b : ℕ} (_ : (a : R) ^ b = c) : (a + 0) ^ b = c + 0 
Arguments: {R : Type u_1} [CommSemiring R] {a c : R} {b : ℕ}
Goal: a ^ b = c → (a + 0) ^ b = c + 0
-- Mathlib.Tactic.Ring.pow_nat
theorem pow_nat {b c k : ℕ} {d e : R} (_ : b = c * k) (_ : a ^ c = d) (_ : d ^ k = e) :
    (a : R) ^ b = e 
Arguments: {R : Type u_1} [CommSemiring R] {a : R} {b c k : ℕ} {d e : R}
Goal: b = c * k → a ^ c = d → d ^ k = e → a ^ b = e
-- Mathlib.Tactic.Ring.pow_zero
theorem pow_zero (a : R) : a ^ 0 = (nat_lit 1).rawCast + 0 
Arguments: {R : Type u_1} [CommSemiring R] (a : R)
Goal: a ^ 0 = Nat.rawCast 1 + 0
-- Mathlib.Tactic.Ring.pow_add
theorem pow_add {b₁ b₂ : ℕ} {d : R}
    (_ : a ^ b₁ = c₁) (_ : a ^ b₂ = c₂) (_ : c₁ * c₂ = d) : (a : R) ^ (b₁ + b₂) = d 
Arguments: {R : Type u_1} [CommSemiring R] {a c₁ c₂ : R} {b₁ b₂ : ℕ} {d : R}
Goal: a ^ b₁ = c₁ → a ^ b₂ = c₂ → c₁ * c₂ = d → a ^ (b₁ + b₂) = d
-- Mathlib.Tactic.Ring.cast_pos
theorem cast_pos {n : ℕ} : IsNat (a : R) n → a = n.rawCast + 0
  
Arguments: {R : Type u_1} [CommSemiring R] {a : R} {n : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat a n → a = n.rawCast + 0
-- Mathlib.Tactic.Ring.cast_zero
theorem cast_zero : IsNat (a : R) (nat_lit 0) → a = 0
  
Arguments: {R : Type u_1} [CommSemiring R] {a : R}
Goal: Mathlib.Meta.NormNum.IsNat a 0 → a = 0
-- Mathlib.Tactic.Ring.cast_neg
theorem cast_neg {n : ℕ} {R} [Ring R] {a : R} :
    IsInt a (.negOfNat n) → a = (Int.negOfNat n).rawCast + 0
  
Arguments: {n : ℕ} {R : Type u_2} [Ring R] {a : R}
Goal: Mathlib.Meta.NormNum.IsInt a (Int.negOfNat n) → a = (Int.negOfNat n).rawCast + 0
-- Mathlib.Tactic.Ring.cast_rat
theorem cast_rat {n : ℤ} {d : ℕ} {R} [DivisionRing R] {a : R} :
    IsRat a n d → a = Rat.rawCast n d + 0
  
Arguments: {n : ℤ} {d : ℕ} {R : Type u_2} [DivisionRing R] {a : R}
Goal: Mathlib.Meta.NormNum.IsRat a n d → a = Rat.rawCast n d + 0
-- Mathlib.Tactic.Ring.toProd_pf
theorem toProd_pf (p : (a : R) = a') :
    a = a' ^ (nat_lit 1).rawCast * (nat_lit 1).rawCast 
Arguments: {R : Type u_1} [CommSemiring R] {a a' : R} (p : a = a')
Goal: a = a' ^ Nat.rawCast 1 * Nat.rawCast 1
-- Mathlib.Tactic.Ring.atom_pf
theorem atom_pf (a : R) : a = a ^ (nat_lit 1).rawCast * (nat_lit 1).rawCast + 0 
Arguments: {R : Type u_1} [CommSemiring R] (a : R)
Goal: a = a ^ Nat.rawCast 1 * Nat.rawCast 1 + 0
-- Mathlib.Tactic.Ring.atom_pf'
theorem atom_pf' (p : (a : R) = a') :
    a = a' ^ (nat_lit 1).rawCast * (nat_lit 1).rawCast + 0 
Arguments: {R : Type u_1} [CommSemiring R] {a a' : R} (p : a = a')
Goal: a = a' ^ Nat.rawCast 1 * Nat.rawCast 1 + 0
-- Mathlib.Tactic.Ring.inv_mul
theorem inv_mul {R} [DivisionRing R] {a₁ a₂ a₃ b₁ b₃ c}
    (_ : (a₁⁻¹ : R) = b₁) (_ : (a₃⁻¹ : R) = b₃)
    (_ : b₃ * (b₁ ^ a₂ * (nat_lit 1).rawCast) = c) :
    (a₁ ^ a₂ * a₃ : R)⁻¹ = c 
Arguments: {R : Type u_2} [DivisionRing R] {a₁ : R} {a₂ : ℕ} {a₃ b₁ b₃ c : R}
Goal: a₁⁻¹ = b₁ → a₃⁻¹ = b₃ → b₃ * (b₁ ^ a₂ * Nat.rawCast 1) = c → (a₁ ^ a₂ * a₃)⁻¹ = c
-- Mathlib.Tactic.Ring.inv_zero
nonrec theorem inv_zero {R} [DivisionRing R] : (0 : R)⁻¹ = 0 
Arguments: {R : Type u_2} [DivisionRing R]
Goal: 0⁻¹ = 0
-- Mathlib.Tactic.Ring.inv_single
theorem inv_single {R} [DivisionRing R] {a b : R}
    (_ : (a : R)⁻¹ = b) : (a + 0)⁻¹ = b + 0 
Arguments: {R : Type u_2} [DivisionRing R] {a b : R}
Goal: a⁻¹ = b → (a + 0)⁻¹ = b + 0
-- Mathlib.Tactic.Ring.inv_add
theorem inv_add {a₁ a₂ : ℕ} (_ : ((a₁ : ℕ) : R) = b₁) (_ : ((a₂ : ℕ) : R) = b₂) :
    ((a₁ + a₂ : ℕ) : R) = b₁ + b₂ 
Arguments: {R : Type u_1} [CommSemiring R] {b₁ b₂ : R} {a₁ a₂ : ℕ}
Goal: ↑a₁ = b₁ → ↑a₂ = b₂ → ↑(a₁ + a₂) = b₁ + b₂
-- Mathlib.Tactic.Ring.div_pf
theorem div_pf {R} [DivisionRing R] {a b c d : R} (_ : b⁻¹ = c) (_ : a * c = d) : a / b = d 
Arguments: {R : Type u_2} [DivisionRing R] {a b c d : R}
Goal: b⁻¹ = c → a * c = d → a / b = d
-- Mathlib.Tactic.Ring.add_congr
theorem add_congr (_ : a = a') (_ : b = b') (_ : a' + b' = c) : (a + b : R) = c 
Arguments: {R : Type u_1} [CommSemiring R] {a a' b b' c : R}
Goal: a = a' → b = b' → a' + b' = c → a + b = c
-- Mathlib.Tactic.Ring.mul_congr
theorem mul_congr (_ : a = a') (_ : b = b') (_ : a' * b' = c) : (a * b : R) = c 
Arguments: {R : Type u_1} [CommSemiring R] {a a' b b' c : R}
Goal: a = a' → b = b' → a' * b' = c → a * b = c
-- Mathlib.Tactic.Ring.nsmul_congr
theorem nsmul_congr {a a' : ℕ} (_ : (a : ℕ) = a') (_ : b = b') (_ : a' • b' = c) :
    (a • (b : R)) = c 
Arguments: {R : Type u_1} [CommSemiring R] {b b' c : R} {a a' : ℕ}
Goal: a = a' → b = b' → a' • b' = c → a • b = c
-- Mathlib.Tactic.Ring.pow_congr
theorem pow_congr {b b' : ℕ} (_ : a = a') (_ : b = b')
    (_ : a' ^ b' = c) : (a ^ b : R) = c 
Arguments: {R : Type u_1} [CommSemiring R] {a a' c : R} {b b' : ℕ}
Goal: a = a' → b = b' → a' ^ b' = c → a ^ b = c
-- Mathlib.Tactic.Ring.neg_congr
theorem neg_congr {R} [Ring R] {a a' b : R} (_ : a = a')
    (_ : -a' = b) : (-a : R) = b 
Arguments: {R : Type u_2} [Ring R] {a a' b : R}
Goal: a = a' → -a' = b → -a = b
-- Mathlib.Tactic.Ring.sub_congr
theorem sub_congr {R} [Ring R] {a a' b b' c : R} (_ : a = a') (_ : b = b')
    (_ : a' - b' = c) : (a - b : R) = c 
Arguments: {R : Type u_2} [Ring R] {a a' b b' c : R}
Goal: a = a' → b = b' → a' - b' = c → a - b = c
-- Mathlib.Tactic.Ring.inv_congr
theorem inv_congr {R} [DivisionRing R] {a a' b : R} (_ : a = a')
    (_ : a'⁻¹ = b) : (a⁻¹ : R) = b 
Arguments: {R : Type u_2} [DivisionRing R] {a a' b : R}
Goal: a = a' → a'⁻¹ = b → a⁻¹ = b
-- Mathlib.Tactic.Ring.div_congr
theorem div_congr {R} [DivisionRing R] {a a' b b' c : R} (_ : a = a') (_ : b = b')
    (_ : a' / b' = c) : (a / b : R) = c 
Arguments: {R : Type u_2} [DivisionRing R] {a a' b b' c : R}
Goal: a = a' → b = b' → a' / b' = c → a / b = c
-- Mathlib.Tactic.Ring.CSLift.inj
class CSLift (α : Type u) (β : outParam (Type u)) where
    lift : α → β
    inj : Function.Injective lift
Arguments: {α : Type u} {β : outParam (Type u)} [self : Mathlib.Tactic.Ring.CSLift α β]
Goal: Function.Injective Mathlib.Tactic.Ring.CSLift.lift
-- Mathlib.Tactic.Ring.CSLiftVal.eq
class CSLiftVal {α} {β : outParam (Type u)} [CSLift α β] (a : α) (b : outParam β) : Prop where
    eq : b = CSLift.lift a
Arguments: {α : Type u} {β : outParam (Type u)} [Mathlib.Tactic.Ring.CSLift α β] {a : α} {b : outParam β} [self : Mathlib.Tactic.Ring.CSLiftVal a b]
Goal: b = Mathlib.Tactic.Ring.CSLift.lift a
-- Mathlib.Tactic.Ring.of_lift
theorem of_lift {α β} [inst : CSLift α β] {a b : α} {a' b' : β}
    [h1 : CSLiftVal a a'] [h2 : CSLiftVal b b'] (h : a' = b') : a = b 
Arguments: {α β : Type u_2} [inst : Mathlib.Tactic.Ring.CSLift α β] {a b : α} {a' b' : β} [h1 : Mathlib.Tactic.Ring.CSLiftVal a a'] [h2 : Mathlib.Tactic.Ring.CSLiftVal b b'] (h : a' = b')
Goal: a = b
-- Mathlib.Tactic.Ring.of_eq
theorem of_eq {α} {a b c : α} (_ : (a : α) = c) (_ : b = c) : a = b 
Arguments: {α : Sort u_2} {a b c : α}
Goal: a = c → b = c → a = b
-- Nat.dist_eq
theorem dist_eq (x y : ℕ) : dist x y = |(x : ℝ) - y| 
Arguments: (x y : ℕ)
Goal: dist x y = |↑x - ↑y|
-- Nat.dist_coe_int
theorem dist_coe_int (x y : ℕ) : dist (x : ℤ) (y : ℤ) = dist x y 
Arguments: (x y : ℕ)
Goal: dist ↑x ↑y = dist x y
-- Nat.dist_cast_real
@[norm_cast, simp]
theorem dist_cast_real (x y : ℕ) : dist (x : ℝ) y = dist x y 
Arguments: (x y : ℕ)
Goal: dist ↑x ↑y = dist x y
-- Nat.pairwise_one_le_dist
theorem pairwise_one_le_dist : Pairwise fun m n : ℕ => 1 ≤ dist m n 
Goal: Pairwise fun m n => 1 ≤ dist m n
-- Nat.uniformEmbedding_coe_real
theorem uniformEmbedding_coe_real : UniformEmbedding ((↑) : ℕ → ℝ) 
Goal: UniformEmbedding Nat.cast
-- Nat.closedEmbedding_coe_real
theorem closedEmbedding_coe_real : ClosedEmbedding ((↑) : ℕ → ℝ) 
Goal: ClosedEmbedding Nat.cast
-- Nat.preimage_ball
theorem preimage_ball (x : ℕ) (r : ℝ) : (↑) ⁻¹' ball (x : ℝ) r = ball x r 
Arguments: (x : ℕ) (r : ℝ)
Goal: Nat.cast ⁻¹' Metric.ball (↑x) r = Metric.ball x r
-- Nat.preimage_closedBall
theorem preimage_closedBall (x : ℕ) (r : ℝ) : (↑) ⁻¹' closedBall (x : ℝ) r = closedBall x r 
Arguments: (x : ℕ) (r : ℝ)
Goal: Nat.cast ⁻¹' Metric.closedBall (↑x) r = Metric.closedBall x r
-- Nat.closedBall_eq_Icc
theorem closedBall_eq_Icc (x : ℕ) (r : ℝ) : closedBall x r = Icc ⌈↑x - r⌉₊ ⌊↑x + r⌋₊ 
Arguments: (x : ℕ) (r : ℝ)
Goal: Metric.closedBall x r = Set.Icc ⌈↑x - r⌉₊ ⌊↑x + r⌋₊
-- preCantorSet_zero
@[simp] lemma preCantorSet_zero : preCantorSet 0 = Set.Icc 0 1 
Goal: preCantorSet 0 = Set.Icc 0 1
-- preCantorSet_succ
@[simp] lemma preCantorSet_succ (n : ℕ) :
    preCantorSet (n + 1) = (· / 3) '' preCantorSet n ∪ (fun x ↦ (2 + x) / 3) '' preCantorSet n 
Arguments: (n : ℕ)
Goal: preCantorSet (n + 1) = (fun x => x / 3) '' preCantorSet n ∪ (fun x => (2 + x) / 3) '' preCantorSet n
-- quarters_mem_preCantorSet
lemma quarters_mem_preCantorSet (n : ℕ) : 1/4 ∈ preCantorSet n ∧ 3/4 ∈ preCantorSet n 
Arguments: (n : ℕ)
Goal: 1 / 4 ∈ preCantorSet n ∧ 3 / 4 ∈ preCantorSet n
-- quarter_mem_preCantorSet
lemma quarter_mem_preCantorSet (n : ℕ) : 1/4 ∈ preCantorSet n 
Arguments: (n : ℕ)
Goal: 1 / 4 ∈ preCantorSet n
-- quarter_mem_cantorSet
theorem quarter_mem_cantorSet : 1/4 ∈ cantorSet 
Goal: 1 / 4 ∈ cantorSet
-- zero_mem_preCantorSet
lemma zero_mem_preCantorSet (n : ℕ) : 0 ∈ preCantorSet n 
Arguments: (n : ℕ)
Goal: 0 ∈ preCantorSet n
-- zero_mem_cantorSet
theorem zero_mem_cantorSet : 0 ∈ cantorSet 
Goal: 0 ∈ cantorSet
-- cantorSet_subset_unitInterval
lemma cantorSet_subset_unitInterval : cantorSet ⊆ Set.Icc 0 1 
Goal: cantorSet ⊆ Set.Icc 0 1
-- isClosed_preCantorSet
lemma isClosed_preCantorSet (n : ℕ) : IsClosed (preCantorSet n) 
Arguments: (n : ℕ)
Goal: IsClosed (preCantorSet n)
-- isClosed_cantorSet
lemma isClosed_cantorSet : IsClosed cantorSet 
Goal: IsClosed cantorSet
-- isCompact_cantorSet
lemma isCompact_cantorSet : IsCompact cantorSet 
Goal: IsCompact cantorSet
-- Rat.dist_eq
theorem dist_eq (x y : ℚ) : dist x y = |(x : ℝ) - y| 
Arguments: (x y : ℚ)
Goal: dist x y = |↑x - ↑y|
-- Rat.dist_cast
@[norm_cast, simp]
theorem dist_cast (x y : ℚ) : dist (x : ℝ) y = dist x y 
Arguments: (x y : ℚ)
Goal: dist ↑x ↑y = dist x y
-- Rat.uniformContinuous_coe_real
theorem uniformContinuous_coe_real : UniformContinuous ((↑) : ℚ → ℝ) 
Goal: UniformContinuous Rat.cast
-- Rat.uniformEmbedding_coe_real
theorem uniformEmbedding_coe_real : UniformEmbedding ((↑) : ℚ → ℝ) 
Goal: UniformEmbedding Rat.cast
-- Rat.denseEmbedding_coe_real
theorem denseEmbedding_coe_real : DenseEmbedding ((↑) : ℚ → ℝ) 
Goal: DenseEmbedding Rat.cast
-- Rat.embedding_coe_real
theorem embedding_coe_real : Embedding ((↑) : ℚ → ℝ) 
Goal: Embedding Rat.cast
-- Rat.continuous_coe_real
theorem continuous_coe_real : Continuous ((↑) : ℚ → ℝ) 
Goal: Continuous Rat.cast
-- Nat.dist_cast_rat
@[norm_cast, simp]
theorem Nat.dist_cast_rat (x y : ℕ) : dist (x : ℚ) y = dist x y 
Arguments: (x y : ℕ)
Goal: dist ↑x ↑y = dist x y
-- Nat.uniformEmbedding_coe_rat
theorem Nat.uniformEmbedding_coe_rat : UniformEmbedding ((↑) : ℕ → ℚ) 
Goal: UniformEmbedding Nat.cast
-- Nat.closedEmbedding_coe_rat
theorem Nat.closedEmbedding_coe_rat : ClosedEmbedding ((↑) : ℕ → ℚ) 
Goal: ClosedEmbedding Nat.cast
-- Int.dist_cast_rat
@[norm_cast, simp]
theorem Int.dist_cast_rat (x y : ℤ) : dist (x : ℚ) y = dist x y 
Arguments: (x y : ℤ)
Goal: dist ↑x ↑y = dist x y
-- Int.uniformEmbedding_coe_rat
theorem Int.uniformEmbedding_coe_rat : UniformEmbedding ((↑) : ℤ → ℚ) 
Goal: UniformEmbedding Int.cast
-- Int.closedEmbedding_coe_rat
theorem Int.closedEmbedding_coe_rat : ClosedEmbedding ((↑) : ℤ → ℚ) 
Goal: ClosedEmbedding Int.cast
-- Rat.uniformContinuous_add
theorem uniformContinuous_add : UniformContinuous fun p : ℚ × ℚ => p.1 + p.2 
Goal: UniformContinuous fun p => p.1 + p.2
-- Rat.uniformContinuous_neg
theorem uniformContinuous_neg : UniformContinuous (@Neg.neg ℚ _) 
Goal: UniformContinuous Neg.neg
-- Rat.uniformContinuous_abs
theorem uniformContinuous_abs : UniformContinuous (abs : ℚ → ℚ) 
Goal: UniformContinuous abs
-- Rat.totallyBounded_Icc
nonrec theorem totallyBounded_Icc (a b : ℚ) : TotallyBounded (Icc a b) 
Arguments: (a b : ℚ)
Goal: TotallyBounded (Set.Icc a b)
-- IsGδ.setOf_irrational
protected theorem IsGδ.setOf_irrational : IsGδ { x | Irrational x } 
Goal: IsGδ {x | Irrational x}
-- dense_irrational
theorem dense_irrational : Dense { x : ℝ | Irrational x } 
Goal: Dense {x | Irrational x}
-- eventually_residual_irrational
theorem eventually_residual_irrational : ∀ᶠ x in residual ℝ, Irrational x 
Goal: ∀ᶠ (x : ℝ) in residual ℝ, Irrational x
-- Irrational.eventually_forall_le_dist_cast_div
theorem eventually_forall_le_dist_cast_div (hx : Irrational x) (n : ℕ) :
    ∀ᶠ ε : ℝ in 𝓝 0, ∀ m : ℤ, ε ≤ dist x (m / n) 
Arguments: {x : ℝ} (hx : Irrational x) (n : ℕ)
Goal: ∀ᶠ (ε : ℝ) in 𝓝 0, ∀ (m : ℤ), ε ≤ dist x (↑m / ↑n)
-- Irrational.eventually_forall_le_dist_cast_div_of_denom_le
theorem eventually_forall_le_dist_cast_div_of_denom_le (hx : Irrational x) (n : ℕ) :
    ∀ᶠ ε : ℝ in 𝓝 0, ∀ k ≤ n, ∀ (m : ℤ), ε ≤ dist x (m / k) 
Arguments: {x : ℝ} (hx : Irrational x) (n : ℕ)
Goal: ∀ᶠ (ε : ℝ) in 𝓝 0, ∀ k ≤ n, ∀ (m : ℤ), ε ≤ dist x (↑m / ↑k)
-- Irrational.eventually_forall_le_dist_cast_rat_of_den_le
theorem eventually_forall_le_dist_cast_rat_of_den_le (hx : Irrational x) (n : ℕ) :
    ∀ᶠ ε : ℝ in 𝓝 0, ∀ r : ℚ, r.den ≤ n → ε ≤ dist x r 
Arguments: {x : ℝ} (hx : Irrational x) (n : ℕ)
Goal: ∀ᶠ (ε : ℝ) in 𝓝 0, ∀ (r : ℚ), r.den ≤ n → ε ≤ dist x ↑r
-- closure_Ioi'
theorem closure_Ioi' {a : α} (h : (Ioi a).Nonempty) : closure (Ioi a) = Ici a 
Arguments: {α : Type u_1} [TopologicalSpace α] [LinearOrder α] [OrderTopology α] [DenselyOrdered α] {a : α} (h : (Set.Ioi a).Nonempty)
Goal: closure (Set.Ioi a) = Set.Ici a
-- closure_Ioi
@[simp]
theorem closure_Ioi (a : α) [NoMaxOrder α] : closure (Ioi a) = Ici a 
Arguments: {α : Type u_1} [TopologicalSpace α] [LinearOrder α] [OrderTopology α] [DenselyOrdered α] (a : α) [NoMaxOrder α]
Goal: closure (Set.Ioi a) = Set.Ici a
-- closure_Iio'
theorem closure_Iio' (h : (Iio a).Nonempty) : closure (Iio a) = Iic a 
Arguments: {α : Type u_1} [TopologicalSpace α] [LinearOrder α] [OrderTopology α] [DenselyOrdered α] {a : α} (h : (Set.Iio a).Nonempty)
Goal: closure (Set.Iio a) = Set.Iic a
-- closure_Iio
@[simp]
theorem closure_Iio (a : α) [NoMinOrder α] : closure (Iio a) = Iic a 
Arguments: {α : Type u_1} [TopologicalSpace α] [LinearOrder α] [OrderTopology α] [DenselyOrdered α] (a : α) [NoMinOrder α]
Goal: closure (Set.Iio a) = Set.Iic a
-- closure_Ioo
@[simp]
theorem closure_Ioo {a b : α} (hab : a ≠ b) : closure (Ioo a b) = Icc a b 
Arguments: {α : Type u_1} [TopologicalSpace α] [LinearOrder α] [OrderTopology α] [DenselyOrdered α] {a b : α} (hab : a ≠ b)
Goal: closure (Set.Ioo a b) = Set.Icc a b
-- closure_Ioc
@[simp]
theorem closure_Ioc {a b : α} (hab : a ≠ b) : closure (Ioc a b) = Icc a b 
Arguments: {α : Type u_1} [TopologicalSpace α] [LinearOrder α] [OrderTopology α] [DenselyOrdered α] {a b : α} (hab : a ≠ b)
Goal: closure (Set.Ioc a b) = Set.Icc a b
-- closure_Ico
@[simp]
theorem closure_Ico {a b : α} (hab : a ≠ b) : closure (Ico a b) = Icc a b 
Arguments: {α : Type u_1} [TopologicalSpace α] [LinearOrder α] [OrderTopology α] [DenselyOrdered α] {a b : α} (hab : a ≠ b)
Goal: closure (Set.Ico a b) = Set.Icc a b
-- interior_Ici'
@[simp]
theorem interior_Ici' {a : α} (ha : (Iio a).Nonempty) : interior (Ici a) = Ioi a 
Arguments: {α : Type u_1} [TopologicalSpace α] [LinearOrder α] [OrderTopology α] [DenselyOrdered α] {a : α} (ha : (Set.Iio a).Nonempty)
Goal: interior (Set.Ici a) = Set.Ioi a
-- interior_Ici
theorem interior_Ici [NoMinOrder α] {a : α} : interior (Ici a) = Ioi a 
Arguments: {α : Type u_1} [TopologicalSpace α] [LinearOrder α] [OrderTopology α] [DenselyOrdered α] [NoMinOrder α] {a : α}
Goal: interior (Set.Ici a) = Set.Ioi a
-- interior_Iic'
@[simp]
theorem interior_Iic' {a : α} (ha : (Ioi a).Nonempty) : interior (Iic a) = Iio a 
Arguments: {α : Type u_1} [TopologicalSpace α] [LinearOrder α] [OrderTopology α] [DenselyOrdered α] {a : α} (ha : (Set.Ioi a).Nonempty)
Goal: interior (Set.Iic a) = Set.Iio a
-- interior_Iic
theorem interior_Iic [NoMaxOrder α] {a : α} : interior (Iic a) = Iio a 
Arguments: {α : Type u_1} [TopologicalSpace α] [LinearOrder α] [OrderTopology α] [DenselyOrdered α] [NoMaxOrder α] {a : α}
Goal: interior (Set.Iic a) = Set.Iio a