tasksource/leandojo huggingface dataset:
Theorem: Ideal.map_pi
File: Mathlib/RingTheory/Ideal/Quotient.lean

tactic: classical
  cases nonempty_fintype ι
  rw [pi_eq_sum_univ x]
  simp only [Finset.sum_apply, smul_eq_mul, LinearMap.map_sum, Pi.smul_apply, LinearMap.map_smul]
  exact I.sum_mem fun j _ => I.mul_mem_right _ (hi j)
state_before: R : Type u
inst✝¹ : CommRing R
I : Ideal R
a b : R
S ι✝ : Type v
ι : Type u_1
inst✝ : Finite ι
ι' : Type w
x : ι → R
hi : ∀ (i : ι), x i ∈ I
f : (ι → R) →ₗ[R] ι' → R
i : ι'
⊢ ↑f x i ∈ I

tactic: cases nonempty_fintype ι
state_before: R : Type u
inst✝¹ : CommRing R
I : Ideal R
a b : R
S ι✝ : Type v
ι : Type u_1
inst✝ : Finite ι
ι' : Type w
x : ι → R
hi : ∀ (i : ι), x i ∈ I
f : (ι → R) →ₗ[R] ι' → R
i : ι'
⊢ ↑f x i ∈ I

tactic: rw [pi_eq_sum_univ x]
state_before: case intro
R : Type u
inst✝¹ : CommRing R
I : Ideal R
a b : R
S ι✝ : Type v
ι : Type u_1
inst✝ : Finite ι
ι' : Type w
x : ι → R
hi : ∀ (i : ι), x i ∈ I
f : (ι → R) →ₗ[R] ι' → R
i : ι'
val✝ : Fintype ι
⊢ ↑f x i ∈ I

tactic: simp only [Finset.sum_apply, smul_eq_mul, LinearMap.map_sum, Pi.smul_apply, LinearMap.map_smul]
state_before: case intro
R : Type u
inst✝¹ : CommRing R
I : Ideal R
a b : R
S ι✝ : Type v
ι : Type u_1
inst✝ : Finite ι
ι' : Type w
x : ι → R
hi : ∀ (i : ι), x i ∈ I
f : (ι → R) →ₗ[R] ι' → R
i : ι'
val✝ : Fintype ι
⊢ ↑f (∑ i : ι, x i • fun j => if i = j then 1 else 0) i ∈ I

tactic: exact I.sum_mem fun j _ => I.mul_mem_right _ (hi j)
state_before: case intro
R : Type u
inst✝¹ : CommRing R
I : Ideal R
a b : R
S ι✝ : Type v
ι : Type u_1
inst✝ : Finite ι
ι' : Type w
x : ι → R
hi : ∀ (i : ι), x i ∈ I
f : (ι → R) →ₗ[R] ι' → R
i : ι'
val✝ : Fintype ι
⊢ ∑ x_1 : ι, x x_1 * ↑f (fun j => if x_1 = j then 1 else 0) i ∈ I
Theorem: differentiable_sub_const_iff
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: simp only [sub_eq_add_neg, differentiable_add_const_iff]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.516215
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.516310
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
c : F
⊢ (Differentiable 𝕜 fun y => f y - c) ↔ Differentiable 𝕜 f
Theorem: Pell.yn_add
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: injection pellZd_add a1 m n with _ h
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
⊢ yn a1 (m + n) = xn a1 m * yn a1 n + yn a1 m * xn a1 n

tactic: zify
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
re_eq✝ : ↑(xn a1 (m + n)) = (pellZd a1 m).re * (pellZd a1 n).re + ↑(Pell.d a1) * (pellZd a1 m).im * (pellZd a1 n).im
h : ↑(yn a1 (m + n)) = (pellZd a1 m).re * (pellZd a1 n).im + (pellZd a1 m).im * (pellZd a1 n).re
⊢ yn a1 (m + n) = xn a1 m * yn a1 n + yn a1 m * xn a1 n

tactic: rw [h]
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
re_eq✝ : ↑(xn a1 (m + n)) = (pellZd a1 m).re * (pellZd a1 n).re + ↑(Pell.d a1) * (pellZd a1 m).im * (pellZd a1 n).im
h : ↑(yn a1 (m + n)) = (pellZd a1 m).re * (pellZd a1 n).im + (pellZd a1 m).im * (pellZd a1 n).re
⊢ ↑(yn a1 (m + n)) = ↑(xn a1 m) * ↑(yn a1 n) + ↑(yn a1 m) * ↑(xn a1 n)

tactic: simp [pellZd]
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
re_eq✝ : ↑(xn a1 (m + n)) = (pellZd a1 m).re * (pellZd a1 n).re + ↑(Pell.d a1) * (pellZd a1 m).im * (pellZd a1 n).im
h : ↑(yn a1 (m + n)) = (pellZd a1 m).re * (pellZd a1 n).im + (pellZd a1 m).im * (pellZd a1 n).re
⊢ (pellZd a1 m).re * (pellZd a1 n).im + (pellZd a1 m).im * (pellZd a1 n).re =
    ↑(xn a1 m) * ↑(yn a1 n) + ↑(yn a1 m) * ↑(xn a1 n)
Theorem: FreeAbelianGroup.lift.add'
File: Mathlib/GroupTheory/FreeAbelianGroup.lean

tactic: refine' FreeAbelianGroup.induction_on a _ _ _ _
state_before: α✝ : Type u
α : Type u_1
β : Type u_2
inst✝ : AddCommGroup β
a : FreeAbelianGroup α
f g : α → β
⊢ ↑(↑lift (f + g)) a = ↑(↑lift f) a + ↑(↑lift g) a

tactic: simp only [(lift _).map_zero, zero_add]
state_before: case refine'_1
α✝ : Type u
α : Type u_1
β : Type u_2
inst✝ : AddCommGroup β
a : FreeAbelianGroup α
f g : α → β
⊢ ↑(↑lift (f + g)) 0 = ↑(↑lift f) 0 + ↑(↑lift g) 0

tactic: intro x
state_before: case refine'_2
α✝ : Type u
α : Type u_1
β : Type u_2
inst✝ : AddCommGroup β
a : FreeAbelianGroup α
f g : α → β
⊢ ∀ (x : α), ↑(↑lift (f + g)) (of x) = ↑(↑lift f) (of x) + ↑(↑lift g) (of x)

tactic: simp only [lift.of, Pi.add_apply]
state_before: case refine'_2
α✝ : Type u
α : Type u_1
β : Type u_2
inst✝ : AddCommGroup β
a : FreeAbelianGroup α
f g : α → β
x : α
⊢ ↑(↑lift (f + g)) (of x) = ↑(↑lift f) (of x) + ↑(↑lift g) (of x)

tactic: intro x _
state_before: case refine'_3
α✝ : Type u
α : Type u_1
β : Type u_2
inst✝ : AddCommGroup β
a : FreeAbelianGroup α
f g : α → β
⊢ ∀ (x : α),
    ↑(↑lift (f + g)) (of x) = ↑(↑lift f) (of x) + ↑(↑lift g) (of x) →
      ↑(↑lift (f + g)) (-of x) = ↑(↑lift f) (-of x) + ↑(↑lift g) (-of x)

tactic: simp only [map_neg, lift.of, Pi.add_apply, neg_add]
state_before: case refine'_3
α✝ : Type u
α : Type u_1
β : Type u_2
inst✝ : AddCommGroup β
a : FreeAbelianGroup α
f g : α → β
x : α
a✝ : ↑(↑lift (f + g)) (of x) = ↑(↑lift f) (of x) + ↑(↑lift g) (of x)
⊢ ↑(↑lift (f + g)) (-of x) = ↑(↑lift f) (-of x) + ↑(↑lift g) (-of x)

tactic: intro x y hx hy
state_before: case refine'_4
α✝ : Type u
α : Type u_1
β : Type u_2
inst✝ : AddCommGroup β
a : FreeAbelianGroup α
f g : α → β
⊢ ∀ (x y : FreeAbelianGroup α),
    ↑(↑lift (f + g)) x = ↑(↑lift f) x + ↑(↑lift g) x →
      ↑(↑lift (f + g)) y = ↑(↑lift f) y + ↑(↑lift g) y →
        ↑(↑lift (f + g)) (x + y) = ↑(↑lift f) (x + y) + ↑(↑lift g) (x + y)

tactic: simp only [(lift _).map_add, hx, hy, add_add_add_comm]
state_before: case refine'_4
α✝ : Type u
α : Type u_1
β : Type u_2
inst✝ : AddCommGroup β
a : FreeAbelianGroup α
f g : α → β
x y : FreeAbelianGroup α
hx : ↑(↑lift (f + g)) x = ↑(↑lift f) x + ↑(↑lift g) x
hy : ↑(↑lift (f + g)) y = ↑(↑lift f) y + ↑(↑lift g) y
⊢ ↑(↑lift (f + g)) (x + y) = ↑(↑lift f) (x + y) + ↑(↑lift g) (x + y)
Theorem: UnionFind.model'
File: Mathlib/Data/UnionFind.lean

tactic: let ⟨n, m, hm⟩ := self.model
state_before: α : Type u_1
self : UnionFind α
⊢ ∃ m, UFModel.Models self.arr m

tactic: cases hm.size_eq
state_before: α : Type u_1
self : UnionFind α
n : ℕ
m : UFModel n
hm : UFModel.Models self.arr m
⊢ ∃ m, UFModel.Models self.arr m

tactic: exact ⟨m, hm⟩
state_before: case refl
α : Type u_1
self : UnionFind α
m : UFModel (Array.size self.arr)
hm : UFModel.Models self.arr m
⊢ ∃ m, UFModel.Models self.arr m
Theorem: MvPolynomial.eval_indicator_apply_eq_zero
File: Mathlib/FieldTheory/Finite/Polynomial.lean

tactic: obtain ⟨i, hi⟩ : ∃ i, a i ≠ b i := by rwa [Ne, Function.funext_iff, not_forall] at h
state_before: K : Type u_1
σ : Type u_2
inst✝² : Fintype K
inst✝¹ : Fintype σ
inst✝ : Field K
a b : σ → K
h : a ≠ b
⊢ ↑(eval a) (indicator b) = 0

tactic: simp only [indicator, map_prod, map_sub, map_one, map_pow, eval_X, eval_C, sub_self,
  Finset.prod_eq_zero_iff]
state_before: case intro
K : Type u_1
σ : Type u_2
inst✝² : Fintype K
inst✝¹ : Fintype σ
inst✝ : Field K
a b : σ → K
h : a ≠ b
i : σ
hi : a i ≠ b i
⊢ ↑(eval a) (indicator b) = 0

tactic: refine' ⟨i, Finset.mem_univ _, _⟩
state_before: case intro
K : Type u_1
σ : Type u_2
inst✝² : Fintype K
inst✝¹ : Fintype σ
inst✝ : Field K
a b : σ → K
h : a ≠ b
i : σ
hi : a i ≠ b i
⊢ ∃ a_1, a_1 ∈ Finset.univ ∧ 1 - (a a_1 - b a_1) ^ (Fintype.card K - 1) = 0

tactic: rw [FiniteField.pow_card_sub_one_eq_one, sub_self]
state_before: case intro
K : Type u_1
σ : Type u_2
inst✝² : Fintype K
inst✝¹ : Fintype σ
inst✝ : Field K
a b : σ → K
h : a ≠ b
i : σ
hi : a i ≠ b i
⊢ 1 - (a i - b i) ^ (Fintype.card K - 1) = 0

tactic: rwa [Ne, sub_eq_zero]
state_before: case intro.ha
K : Type u_1
σ : Type u_2
inst✝² : Fintype K
inst✝¹ : Fintype σ
inst✝ : Field K
a b : σ → K
h : a ≠ b
i : σ
hi : a i ≠ b i
⊢ a i - b i ≠ 0

tactic: rwa [Ne, Function.funext_iff, not_forall] at h
state_before: K : Type u_1
σ : Type u_2
inst✝² : Fintype K
inst✝¹ : Fintype σ
inst✝ : Field K
a b : σ → K
h : a ≠ b
⊢ ∃ i, a i ≠ b i
Theorem: FirstOrder.Language.card_functions_sum_skolem₁
File: Mathlib/ModelTheory/Skolem.lean

tactic: simp only [card_functions_sum, skolem₁_Functions, mk_sigma, sum_add_distrib']
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : Structure L M
⊢ (#(n : ℕ) × Functions (Language.sum L (skolem₁ L)) n) = (#(n : ℕ) × BoundedFormula L Empty (n + 1))

tactic: conv_lhs => enter [2, 1, i]; rw [lift_id'.{u, v}]
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : Structure L M
⊢ ((sum fun i => lift (#Functions L i)) + sum fun i => lift (#BoundedFormula L Empty (i + 1))) =
    sum fun i => #BoundedFormula L Empty (i + 1)

tactic: rw [add_comm, add_eq_max, max_eq_left]
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : Structure L M
⊢ ((sum fun i => lift (#Functions L i)) + sum fun i => #BoundedFormula L Empty (i + 1)) =
    sum fun i => #BoundedFormula L Empty (i + 1)

tactic: refine' sum_le_sum _ _ fun n => _
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : Structure L M
⊢ (sum fun i => lift (#Functions L i)) ≤ sum fun i => #BoundedFormula L Empty (i + 1)

tactic: rw [← lift_le.{_, max u v}, lift_lift, lift_mk_le.{_, _, v}]
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : Structure L M
n : ℕ
⊢ lift (#Functions L n) ≤ (#BoundedFormula L Empty (n + 1))

tactic: refine' ⟨⟨fun f => (func f default).bdEqual (func f default), fun f g h => _⟩⟩
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : Structure L M
n : ℕ
⊢ Nonempty (Functions L n ↪ BoundedFormula L Empty (n + 1))

tactic: rcases h with ⟨rfl, ⟨rfl⟩⟩
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : Structure L M
n : ℕ
f g : Functions L n
h : (fun f => func f default =' func f default) f = (fun f => func f default =' func f default) g
⊢ f = g

tactic: rfl
state_before: case refl
L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : Structure L M
n : ℕ
f : Functions L n
⊢ f = f

tactic: rw [← mk_sigma]
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : Structure L M
⊢ ℵ₀ ≤ sum fun i => #BoundedFormula L Empty (i + 1)

tactic: exact infinite_iff.1 (Infinite.of_injective (fun n => ⟨n, ⊥⟩) fun x y xy =>
  (Sigma.mk.inj_iff.1 xy).1)
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : Structure L M
⊢ ℵ₀ ≤ (#(i : ℕ) × BoundedFormula L Empty (i + 1))
Theorem: Lean.Data.AC.insert_nonEmpty
File: src/lean/Init/Data/AC.lean

tactic: induction xs with
| nil => simp [insert]
| cons x xs _  => simp [insert]; split <;> simp
state_before: x : Nat
xs : List Nat
⊢ insert x xs ≠ []

tactic: simp [insert]
state_before: case nil
x : Nat
⊢ insert x [] ≠ []

tactic: simp [insert]
state_before: case cons
x✝ x : Nat
xs : List Nat
tail_ih✝ : insert x✝ xs ≠ []
⊢ insert x✝ (x :: xs) ≠ []

tactic: split <;> simp
state_before: case cons
x✝ x : Nat
xs : List Nat
tail_ih✝ : insert x✝ xs ≠ []
⊢ ¬(if x✝ < x then x✝ :: x :: xs else x :: insert x✝ xs) = []
Theorem: Real.toNNReal_div
File: Mathlib/Data/Real/NNReal.lean

tactic: rw [div_eq_mul_inv, div_eq_mul_inv, ← Real.toNNReal_inv, ← Real.toNNReal_mul hx]
state_before: x y : ℝ
hx : 0 ≤ x
⊢ toNNReal (x / y) = toNNReal x / toNNReal y
Theorem: CategoryTheory.Limits.isIso_π_of_isInitial
File: Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean

tactic: ext
state_before: C : Type u₁
inst✝² : Category C
J : Type u
inst✝¹ : Category J
j : J
I : IsInitial j
F : J ⥤ C
inst✝ : HasLimit F
⊢ limit.π F j ≫ limit.lift F (coneOfDiagramInitial I F) = 𝟙 (limit F)

tactic: simp
state_before: case w
C : Type u₁
inst✝² : Category C
J : Type u
inst✝¹ : Category J
j : J
I : IsInitial j
F : J ⥤ C
inst✝ : HasLimit F
j✝ : J
⊢ (limit.π F j ≫ limit.lift F (coneOfDiagramInitial I F)) ≫ limit.π F j✝ = 𝟙 (limit F) ≫ limit.π F j✝

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
J : Type u
inst✝¹ : Category J
j : J
I : IsInitial j
F : J ⥤ C
inst✝ : HasLimit F
⊢ limit.lift F (coneOfDiagramInitial I F) ≫ limit.π F j = 𝟙 (F.obj j)
Theorem: PowerSeries.trunc_add
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: simp only [coeff_trunc, AddMonoidHom.map_add, Polynomial.coeff_add]
state_before: R : Type u_1
inst✝ : CommSemiring R
n : ℕ
φ ψ : PowerSeries R
m : ℕ
⊢ Polynomial.coeff (trunc n (φ + ψ)) m = Polynomial.coeff (trunc n φ + trunc n ψ) m

tactic: split_ifs with H
state_before: R : Type u_1
inst✝ : CommSemiring R
n : ℕ
φ ψ : PowerSeries R
m : ℕ
⊢ (if m < n then ↑(coeff R m) (φ + ψ) else 0) =
    (if m < n then ↑(coeff R m) φ else 0) + if m < n then ↑(coeff R m) ψ else 0

tactic: rfl
state_before: case inl
R : Type u_1
inst✝ : CommSemiring R
n : ℕ
φ ψ : PowerSeries R
m : ℕ
H : m < n
⊢ ↑(coeff R m) (φ + ψ) = ↑(coeff R m) φ + ↑(coeff R m) ψ

tactic: rw [zero_add]
state_before: case inr
R : Type u_1
inst✝ : CommSemiring R
n : ℕ
φ ψ : PowerSeries R
m : ℕ
H : ¬m < n
⊢ 0 = 0 + 0
Theorem: Asymptotics.isBigO_top
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: rw [isBigO_iff]
state_before: α : Type u_1
β : Type ?u.285372
E : Type u_2
F : Type u_3
G : Type ?u.285381
E' : Type ?u.285384
F' : Type ?u.285387
G' : Type ?u.285390
E'' : Type ?u.285393
F'' : Type ?u.285396
G'' : Type ?u.285399
R : Type ?u.285402
R' : Type ?u.285405
𝕜 : Type ?u.285408
𝕜' : Type ?u.285411
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
⊢ f =O[⊤] g ↔ ∃ C, ∀ (x : α), ‖f x‖ ≤ C * ‖g x‖

tactic: rfl
state_before: α : Type u_1
β : Type ?u.285372
E : Type u_2
F : Type u_3
G : Type ?u.285381
E' : Type ?u.285384
F' : Type ?u.285387
G' : Type ?u.285390
E'' : Type ?u.285393
F'' : Type ?u.285396
G'' : Type ?u.285399
R : Type ?u.285402
R' : Type ?u.285405
𝕜 : Type ?u.285408
𝕜' : Type ?u.285411
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
⊢ (∃ c, ∀ᶠ (x : α) in ⊤, ‖f x‖ ≤ c * ‖g x‖) ↔ ∃ C, ∀ (x : α), ‖f x‖ ≤ C * ‖g x‖
Theorem: Complex.exp_neg
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← mul_right_inj' (exp_ne_zero x), ← exp_add]
state_before: x y : ℂ
⊢ exp (-x) = (exp x)⁻¹

tactic: simp [mul_inv_cancel (exp_ne_zero x)]
state_before: x y : ℂ
⊢ exp (x + -x) = exp x * (exp x)⁻¹
Theorem: Convex.eqOn_of_fderivWithin_eq
File: Mathlib/Analysis/Calculus/MeanValue.lean

tactic: suffices f x - g x = f y - g y by rwa [hfgx, sub_self, eq_comm, sub_eq_zero] at this
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
F : Type ?u.256230
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
𝕜 : Type u_2
G : Type u_3
inst✝³ : IsROrC 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → G
C : ℝ
s : Set E
x y✝ : E
f' g' : E → E →L[𝕜] G
φ : E →L[𝕜] G
hs : Convex ℝ s
hf : DifferentiableOn 𝕜 f s
hg : DifferentiableOn 𝕜 g s
hs' : UniqueDiffOn 𝕜 s
hf' : ∀ (x : E), x ∈ s → fderivWithin 𝕜 f s x = fderivWithin 𝕜 g s x
hx : x ∈ s
hfgx : f x = g x
y : E
hy : y ∈ s
⊢ f y = g y

tactic: refine' hs.is_const_of_fderivWithin_eq_zero (hf.sub hg) (fun z hz => _) hx hy
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
F : Type ?u.256230
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
𝕜 : Type u_2
G : Type u_3
inst✝³ : IsROrC 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → G
C : ℝ
s : Set E
x y✝ : E
f' g' : E → E →L[𝕜] G
φ : E →L[𝕜] G
hs : Convex ℝ s
hf : DifferentiableOn 𝕜 f s
hg : DifferentiableOn 𝕜 g s
hs' : UniqueDiffOn 𝕜 s
hf' : ∀ (x : E), x ∈ s → fderivWithin 𝕜 f s x = fderivWithin 𝕜 g s x
hx : x ∈ s
hfgx : f x = g x
y : E
hy : y ∈ s
⊢ f x - g x = f y - g y

tactic: rw [fderivWithin_sub (hs' _ hz) (hf _ hz) (hg _ hz), sub_eq_zero, hf' _ hz]
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
F : Type ?u.256230
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
𝕜 : Type u_2
G : Type u_3
inst✝³ : IsROrC 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → G
C : ℝ
s : Set E
x y✝ : E
f' g' : E → E →L[𝕜] G
φ : E →L[𝕜] G
hs : Convex ℝ s
hf : DifferentiableOn 𝕜 f s
hg : DifferentiableOn 𝕜 g s
hs' : UniqueDiffOn 𝕜 s
hf' : ∀ (x : E), x ∈ s → fderivWithin 𝕜 f s x = fderivWithin 𝕜 g s x
hx : x ∈ s
hfgx : f x = g x
y : E
hy : y ∈ s
z : E
hz : z ∈ s
⊢ fderivWithin 𝕜 (fun y => f y - g y) s z = 0

tactic: rwa [hfgx, sub_self, eq_comm, sub_eq_zero] at this
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
F : Type ?u.256230
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
𝕜 : Type u_2
G : Type u_3
inst✝³ : IsROrC 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → G
C : ℝ
s : Set E
x y✝ : E
f' g' : E → E →L[𝕜] G
φ : E →L[𝕜] G
hs : Convex ℝ s
hf : DifferentiableOn 𝕜 f s
hg : DifferentiableOn 𝕜 g s
hs' : UniqueDiffOn 𝕜 s
hf' : ∀ (x : E), x ∈ s → fderivWithin 𝕜 f s x = fderivWithin 𝕜 g s x
hx : x ∈ s
hfgx : f x = g x
y : E
hy : y ∈ s
this : f x - g x = f y - g y
⊢ f y = g y
Theorem: Basis.equiv_apply
File: Mathlib/LinearAlgebra/Basis.lean

tactic: simp [Basis.equiv]
state_before: ι : Type u_2
ι' : Type u_5
R : Type u_3
R₂ : Type ?u.546971
K : Type ?u.546974
M : Type u_4
M' : Type u_1
M'' : Type ?u.546983
V : Type u
V' : Type ?u.546988
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid M'
inst✝² : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
b' : Basis ι' R M'
e : ι ≃ ι'
inst✝¹ : AddCommMonoid M''
inst✝ : Module R M''
⊢ ↑(Basis.equiv b b' e) (↑b i) = ↑b' (↑e i)
Theorem: Filter.map_inf_principal_preimage
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [mem_map', mem_inf_principal, mem_setOf_eq, mem_preimage]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.318879
ι : Sort x
f : α → β
s : Set β
l : Filter α
t : Set β
⊢ t ∈ map f (l ⊓ 𝓟 (f ⁻¹' s)) ↔ t ∈ map f l ⊓ 𝓟 s
Theorem: HahnSeries.mul_single_zero_coeff
File: Mathlib/RingTheory/HahnSeries.lean

tactic: rw [← add_zero a, mul_single_coeff_add, add_zero]
state_before: Γ : Type u_2
R : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
r : R
x : HahnSeries Γ R
a : Γ
⊢ coeff (x * ↑(single 0) r) a = coeff x a * r
Theorem: hamming_zero_eq_dist
File: Mathlib/InformationTheory/Hamming.lean

tactic: rw [eq_comm, hammingDist_eq_zero]
state_before: α : Type ?u.10710
ι : Type u_1
β : ι → Type u_2
inst✝² : Fintype ι
inst✝¹ : (i : ι) → DecidableEq (β i)
γ : ι → Type ?u.10742
inst✝ : (i : ι) → DecidableEq (γ i)
x y : (i : ι) → β i
⊢ 0 = hammingDist x y ↔ x = y
Theorem: Metric.subsingleton_closedBall
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rcases hr.lt_or_eq with (hr | rfl)
state_before: α : Type u
β : Type v
X : Type ?u.552898
ι : Type ?u.552901
inst✝¹ : PseudoMetricSpace α
γ : Type w
inst✝ : MetricSpace γ
x✝ : γ
s : Set γ
x : γ
r : ℝ
hr : r ≤ 0
⊢ Set.Subsingleton (closedBall x r)

tactic: rw [closedBall_eq_empty.2 hr]
state_before: case inl
α : Type u
β : Type v
X : Type ?u.552898
ι : Type ?u.552901
inst✝¹ : PseudoMetricSpace α
γ : Type w
inst✝ : MetricSpace γ
x✝ : γ
s : Set γ
x : γ
r : ℝ
hr✝ : r ≤ 0
hr : r < 0
⊢ Set.Subsingleton (closedBall x r)

tactic: exact subsingleton_empty
state_before: case inl
α : Type u
β : Type v
X : Type ?u.552898
ι : Type ?u.552901
inst✝¹ : PseudoMetricSpace α
γ : Type w
inst✝ : MetricSpace γ
x✝ : γ
s : Set γ
x : γ
r : ℝ
hr✝ : r ≤ 0
hr : r < 0
⊢ Set.Subsingleton ∅

tactic: rw [closedBall_zero]
state_before: case inr
α : Type u
β : Type v
X : Type ?u.552898
ι : Type ?u.552901
inst✝¹ : PseudoMetricSpace α
γ : Type w
inst✝ : MetricSpace γ
x✝ : γ
s : Set γ
x : γ
hr : 0 ≤ 0
⊢ Set.Subsingleton (closedBall x 0)

tactic: exact subsingleton_singleton
state_before: case inr
α : Type u
β : Type v
X : Type ?u.552898
ι : Type ?u.552901
inst✝¹ : PseudoMetricSpace α
γ : Type w
inst✝ : MetricSpace γ
x✝ : γ
s : Set γ
x : γ
hr : 0 ≤ 0
⊢ Set.Subsingleton {x}
Theorem: CategoryTheory.Abelian.Pseudoelement.comp_apply
File: Mathlib/CategoryTheory/Abelian/Pseudoelements.lean

tactic: simp only [app]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Abelian C
P Q R : C
f : P ⟶ Q
g : Q ⟶ R
a : Pseudoelement P
x : Over P
⊢ (fun g_1 => app (f ≫ g) g_1) x ≈ (fun g_1 => app g g_1) ((fun g => app f g) x)

tactic: rw [← Category.assoc, Over.coe_hom]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Abelian C
P Q R : C
f : P ⟶ Q
g : Q ⟶ R
a : Pseudoelement P
x : Over P
⊢ Over.mk (x.hom ≫ f ≫ g) ≈ Over.mk ((Over.mk (x.hom ≫ f)).hom ≫ g)
Theorem: SimpleGraph.Walk.getVert_of_length_le
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: rfl
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v u✝ : V
i : ℕ
hi : length nil ≤ i
⊢ getVert nil i = u✝

tactic: cases i
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : ∀ {i : ℕ}, length p✝ ≤ i → getVert p✝ i = w✝
i : ℕ
hi : length (cons h✝ p✝) ≤ i
⊢ getVert (cons h✝ p✝) i = w✝

tactic: cases hi
state_before: case cons.zero
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : ∀ {i : ℕ}, length p✝ ≤ i → getVert p✝ i = w✝
hi : length (cons h✝ p✝) ≤ Nat.zero
⊢ getVert (cons h✝ p✝) Nat.zero = w✝

tactic: exact ih (Nat.succ_le_succ_iff.1 hi)
state_before: case cons.succ
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : ∀ {i : ℕ}, length p✝ ≤ i → getVert p✝ i = w✝
n✝ : ℕ
hi : length (cons h✝ p✝) ≤ Nat.succ n✝
⊢ getVert (cons h✝ p✝) (Nat.succ n✝) = w✝
Theorem: Multiset.lt_cons_self
File: Mathlib/Data/Multiset/Basic.lean

tactic: simpa [lt_iff_le_and_ne]
state_before: α : Type u_1
β : Type ?u.35311
γ : Type ?u.35314
s✝ t : Multiset α
a✝ : α
s : Multiset α
a : α
l : List α
this : l <+~ a :: l ∧ ¬l ~ a :: l
⊢ Quot.mk Setoid.r l < a ::ₘ Quot.mk Setoid.r l
Theorem: multiplicity.not_finite_iff_forall
File: Mathlib/RingTheory/Multiplicity.lean

tactic: rw [_root_.pow_zero]
state_before: α : Type u_1
inst✝ : Monoid α
a b : α
h : ¬Finite a b
n : ℕ
⊢ a ^ zero ∣ b

tactic: exact one_dvd _
state_before: α : Type u_1
inst✝ : Monoid α
a b : α
h : ¬Finite a b
n : ℕ
⊢ 1 ∣ b

tactic: simpa [Finite, Classical.not_not] using h
state_before: α : Type u_1
inst✝ : Monoid α
a b : α
h : ¬Finite a b
n : ℕ
⊢ ∀ (n : ℕ), a ^ succ n ∣ b

tactic: simp [Finite, multiplicity, Classical.not_not]
state_before: α : Type u_1
inst✝ : Monoid α
a b : α
⊢ (∀ (n : ℕ), a ^ n ∣ b) → ¬Finite a b

tactic: tauto
state_before: α : Type u_1
inst✝ : Monoid α
a b : α
⊢ (∀ (n : ℕ), a ^ n ∣ b) → ∀ (x : ℕ), a ^ (x + 1) ∣ b
Theorem: Nat.count_one
File: Mathlib/Data/Nat/Count.lean

tactic: simp [count_succ]
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
⊢ count p 1 = if p 0 then 1 else 0
Theorem: List.range'_concat
File: Std/Data/List/Lemmas.lean

tactic: rw [Nat.add_comm n 1]
state_before: step s n : Nat
⊢ range' s (n + 1) step = range' s n step ++ [s + step * n]

tactic: exact (range'_append s n 1 step).symm
state_before: step s n : Nat
⊢ range' s (1 + n) step = range' s n step ++ [s + step * n]