ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: RingHom.expChar
File: Mathlib/Algebra/CharP/ExpChar.lean

Proof steps:
state_before: R✝ : Type u
R : Type u_1
A : Type u_2
inst✝² : Semiring R
inst✝¹ : Semiring A
f : R →+* A
H : Function.Injective ⇑f
p : ℕ
inst✝ : ExpChar A p
⊢ ExpChar R p
state_after: no goals
tactic: cases ‹ExpChar A p› with
  | zero => haveI := f.charZero; exact .zero
  | prime hp => haveI := f.charP H p; exact .prime hp
Theorem: MeasureTheory.Measure.MutuallySingular.self_iff
File: Mathlib/MeasureTheory/Measure/MutuallySingular.lean

Proof steps:
state_before: α : Type u_1
m0 : MeasurableSpace α
μ✝ μ₁ μ₂ ν ν₁ ν₂ μ : Measure α
⊢ μ ⟂ₘ μ ↔ μ = 0
state_after: α : Type u_1
m0 : MeasurableSpace α
μ✝ μ₁ μ₂ ν ν₁ ν₂ μ : Measure α
⊢ μ ⟂ₘ μ → μ = 0
tactic: refine ⟨?_, fun h ↦ by (rw [h]; exact zero_left)⟩
state_before: α : Type u_1
m0 : MeasurableSpace α
μ✝ μ₁ μ₂ ν ν₁ ν₂ μ : Measure α
⊢ μ ⟂ₘ μ → μ = 0
state_after: case intro.intro.intro
α : Type u_1
m0 : MeasurableSpace α
μ✝ μ₁ μ₂ ν ν₁ ν₂ μ : Measure α
s : Set α
hs : MeasurableSet s
hμs : μ s = 0
hμs_compl : μ sᶜ = 0
⊢ μ = 0
tactic: rintro ⟨s, hs, hμs, hμs_compl⟩
state_before: case intro.intro.intro
α : Type u_1
m0 : MeasurableSpace α
μ✝ μ₁ μ₂ ν ν₁ ν₂ μ : Measure α
s : Set α
hs : MeasurableSet s
hμs : μ s = 0
hμs_compl : μ sᶜ = 0
⊢ μ = 0
state_after: case intro.intro.intro
α : Type u_1
m0 : MeasurableSpace α
μ✝ μ₁ μ₂ ν ν₁ ν₂ μ : Measure α
s : Set α
hs : MeasurableSet s
hμs : μ s = 0
hμs_compl : μ sᶜ = 0
⊢ μ univ = 0
tactic: suffices μ Set.univ = 0 by rwa [measure_univ_eq_zero] at this
state_before: case intro.intro.intro
α : Type u_1
m0 : MeasurableSpace α
μ✝ μ₁ μ₂ ν ν₁ ν₂ μ : Measure α
s : Set α
hs : MeasurableSet s
hμs : μ s = 0
hμs_compl : μ sᶜ = 0
⊢ μ univ = 0
state_after: no goals
tactic: rw [← Set.union_compl_self s, measure_union disjoint_compl_right hs.compl, hμs, hμs_compl,
    add_zero]
Theorem: CategoryTheory.Equivalence.cancel_unit_right_assoc'
File: Mathlib/CategoryTheory/Equivalence.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
e : C ≌ D
W X X' Y Y' Z : C
f : W ⟶ X
g : X ⟶ Y
h : Y ⟶ Z
f' : W ⟶ X'
g' : X' ⟶ Y'
h' : Y' ⟶ Z
⊢ f ≫ g ≫ h ≫ e.unit.app Z = f' ≫ g' ≫ h' ≫ e.unit.app Z ↔ f ≫ g ≫ h = f' ≫ g' ≫ h'
state_after: no goals
tactic: simp only [← Category.assoc, cancel_mono]
Theorem: MvPolynomial.totalDegree_zero
File: Mathlib/Algebra/MvPolynomial/Degrees.lean

Proof steps:
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
⊢ totalDegree 0 = 0
state_after: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
⊢ (C 0).totalDegree = 0
tactic: rw [← C_0]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
⊢ (C 0).totalDegree = 0
state_after: no goals
tactic: exact totalDegree_C (0 : R)
Theorem: abs_lt_iff_mul_self_lt
File: Mathlib/Algebra/Order/Ring/Abs.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
n : ℕ
a b c : α
⊢ |a| < |b| ↔ a * a < b * b
state_after: α : Type u_1
inst✝ : LinearOrderedRing α
n : ℕ
a b c : α
⊢ |a| < |b| ↔ |a| * |a| < |b| * |b|
tactic: rw [← abs_mul_abs_self, ← abs_mul_abs_self b]
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
n : ℕ
a b c : α
⊢ |a| < |b| ↔ |a| * |a| < |b| * |b|
state_after: no goals
tactic: exact mul_self_lt_mul_self_iff (abs_nonneg a) (abs_nonneg b)
Theorem: Complex.cosh_three_mul
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℂ
⊢ cosh (3 * x) = 4 * cosh x ^ 3 - 3 * cosh x
state_after: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cosh (3 * x) = 4 * cosh x ^ 3 - 3 * cosh x
tactic: have h1 : x + 2 * x = 3 * x := by ring
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cosh (3 * x) = 4 * cosh x ^ 3 - 3 * cosh x
state_after: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cosh x * cosh (2 * x) + sinh x * sinh (2 * x) = 4 * cosh x ^ 3 - 3 * cosh x
tactic: rw [← h1, cosh_add x (2 * x)]
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cosh x * cosh (2 * x) + sinh x * sinh (2 * x) = 4 * cosh x ^ 3 - 3 * cosh x
state_after: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cosh x * (cosh x ^ 2 + sinh x ^ 2) + sinh x * (2 * sinh x * cosh x) = 4 * cosh x ^ 3 - 3 * cosh x
tactic: simp only [cosh_two_mul, sinh_two_mul]
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cosh x * (cosh x ^ 2 + sinh x ^ 2) + sinh x * (2 * sinh x * cosh x) = 4 * cosh x ^ 3 - 3 * cosh x
state_after: x y : ℂ
h1 : x + 2 * x = 3 * x
h2 : sinh x * (2 * sinh x * cosh x) = 2 * cosh x * sinh x ^ 2
⊢ cosh x * (cosh x ^ 2 + sinh x ^ 2) + sinh x * (2 * sinh x * cosh x) = 4 * cosh x ^ 3 - 3 * cosh x
tactic: have h2 : sinh x * (2 * sinh x * cosh x) = 2 * cosh x * sinh x ^ 2 := by ring
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
h2 : sinh x * (2 * sinh x * cosh x) = 2 * cosh x * sinh x ^ 2
⊢ cosh x * (cosh x ^ 2 + sinh x ^ 2) + sinh x * (2 * sinh x * cosh x) = 4 * cosh x ^ 3 - 3 * cosh x
state_after: x y : ℂ
h1 : x + 2 * x = 3 * x
h2 : sinh x * (2 * sinh x * cosh x) = 2 * cosh x * sinh x ^ 2
⊢ cosh x * (cosh x ^ 2 + (cosh x ^ 2 - 1)) + 2 * cosh x * (cosh x ^ 2 - 1) = 4 * cosh x ^ 3 - 3 * cosh x
tactic: rw [h2, sinh_sq]
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
h2 : sinh x * (2 * sinh x * cosh x) = 2 * cosh x * sinh x ^ 2
⊢ cosh x * (cosh x ^ 2 + (cosh x ^ 2 - 1)) + 2 * cosh x * (cosh x ^ 2 - 1) = 4 * cosh x ^ 3 - 3 * cosh x
state_after: no goals
tactic: ring
Theorem: CategoryTheory.Limits.Cocones.whiskeringEquivalence_functor
File: Mathlib/CategoryTheory/Limits/Cones.lean

Proof steps:
state_before: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
e : K ≌ J
s : Cocone (e.functor ⋙ F)
k : K
⊢ (((whiskering e.inverse ⋙
                    precompose
                      (F.leftUnitor.inv ≫ whiskerRight e.counitIso.inv F ≫ (e.inverse.associator e.functor F).inv)) ⋙
                  whiskering e.functor).obj
              s).ι.app
        k ≫
      (Iso.refl
          (((whiskering e.inverse ⋙
                    precompose
                      (F.leftUnitor.inv ≫ whiskerRight e.counitIso.inv F ≫ (e.inverse.associator e.functor F).inv)) ⋙
                  whiskering e.functor).obj
              s).pt).hom =
    ((𝟭 (Cocone (e.functor ⋙ F))).obj s).ι.app k
state_after: no goals
tactic: simpa [e.counitInv_app_functor k] using s.w (e.unit.app k)
Theorem: edist_congr_left
File: Mathlib/Topology/EMetricSpace/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x y z : α
h : edist x y = 0
⊢ edist z x = edist z y
state_after: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x y z : α
h : edist x y = 0
⊢ edist x z = edist y z
tactic: rw [edist_comm z x, edist_comm z y]
state_before: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x y z : α
h : edist x y = 0
⊢ edist x z = edist y z
state_after: no goals
tactic: apply edist_congr_right h
Theorem: CategoryTheory.Limits.PreservesLimitPair.iso_inv_snd
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/BinaryProducts.lean

Proof steps:
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
G : C ⥤ D
P X Y Z : C
f : P ⟶ X
g : P ⟶ Y
inst✝² : HasBinaryProduct X Y
inst✝¹ : HasBinaryProduct (G.obj X) (G.obj Y)
inst✝ : PreservesLimit (pair X Y) G
⊢ (iso G X Y).inv ≫ G.map prod.snd = prod.snd
state_after: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
G : C ⥤ D
P X Y Z : C
f : P ⟶ X
g : P ⟶ Y
inst✝² : HasBinaryProduct X Y
inst✝¹ : HasBinaryProduct (G.obj X) (G.obj Y)
inst✝ : PreservesLimit (pair X Y) G
⊢ 𝟙 (G.obj (X ⨯ Y)) ≫ G.map prod.snd = (iso G X Y).hom ≫ prod.snd
tactic: rw [← Iso.cancel_iso_hom_left (PreservesLimitPair.iso G X Y), ← Category.assoc, Iso.hom_inv_id]
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
G : C ⥤ D
P X Y Z : C
f : P ⟶ X
g : P ⟶ Y
inst✝² : HasBinaryProduct X Y
inst✝¹ : HasBinaryProduct (G.obj X) (G.obj Y)
inst✝ : PreservesLimit (pair X Y) G
⊢ 𝟙 (G.obj (X ⨯ Y)) ≫ G.map prod.snd = (iso G X Y).hom ≫ prod.snd
state_after: no goals
tactic: simp
Theorem: MvPolynomial.degreeOf_C_mul_le
File: Mathlib/Algebra/MvPolynomial/Degrees.lean

Proof steps:
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
i : σ
c : R
⊢ degreeOf i (C c * p) ≤ degreeOf i p
state_after: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
i : σ
c : R
⊢ Multiset.count i (C c * p).degrees ≤ Multiset.count i p.degrees
tactic: unfold degreeOf
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
i : σ
c : R
⊢ Multiset.count i (C c * p).degrees ≤ Multiset.count i p.degrees
state_after: case h.e'_4.h.e'_4
R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
i : σ
c : R
⊢ p.degrees = (C c).degrees + p.degrees
tactic: convert Multiset.count_le_of_le i <| degrees_mul (C c) p
state_before: case h.e'_4.h.e'_4
R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
i : σ
c : R
⊢ p.degrees = (C c).degrees + p.degrees
state_after: no goals
tactic: simp [degrees_C]
Theorem: CategoryTheory.instCategorySimplicialObject_comp_app
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
⊢ Category.{?u.61, max u v} (SimplicialObject C)
state_after: C : Type u
inst✝ : Category.{v, u} C
⊢ Category.{?u.61, max u v} (SimplexCategoryᵒᵖ ⥤ C)
tactic: dsimp only [SimplicialObject]
state_before: C : Type u
inst✝ : Category.{v, u} C
⊢ Category.{?u.61, max u v} (SimplexCategoryᵒᵖ ⥤ C)
state_after: no goals
tactic: infer_instance
Theorem: EllipticCurve.ofJ'_j
File: Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean

Proof steps:
state_before: R : Type u
inst✝² : CommRing R
E : EllipticCurve R
j : R
inst✝¹ : Invertible j
inst✝ : Invertible (j - 1728)
⊢ (ofJ' j).j = j
state_after: R : Type u
inst✝² : CommRing R
E : EllipticCurve R
j : R
inst✝¹ : Invertible j
inst✝ : Invertible (j - 1728)
⊢ j * (j ^ 2 * (j - 1728) ^ 9) = (j * (j - 1728) ^ 3) ^ 3
tactic: field_simp [EllipticCurve.j, ofJ', @val_unitOfInvertible _ _ _ <| invertibleMul ..,
    WeierstrassCurve.ofJ_c₄]
state_before: R : Type u
inst✝² : CommRing R
E : EllipticCurve R
j : R
inst✝¹ : Invertible j
inst✝ : Invertible (j - 1728)
⊢ j * (j ^ 2 * (j - 1728) ^ 9) = (j * (j - 1728) ^ 3) ^ 3
state_after: no goals
tactic: ring1
Theorem: AddSubsemigroup.mem_sup_left
File: Mathlib/Algebra/Group/Subsemigroup/Membership.lean

Proof steps:
state_before: ι : Sort u_1
M : Type u_2
A : Type u_3
B : Type u_4
inst✝ : Mul M
S T : Subsemigroup M
⊢ ∀ {x : M}, x ∈ S → x ∈ S ⊔ T
state_after: ι : Sort u_1
M : Type u_2
A : Type u_3
B : Type u_4
inst✝ : Mul M
S T : Subsemigroup M
this : S ≤ S ⊔ T
⊢ ∀ {x : M}, x ∈ S → x ∈ S ⊔ T
tactic: have : S ≤ S ⊔ T := le_sup_left
state_before: ι : Sort u_1
M : Type u_2
A : Type u_3
B : Type u_4
inst✝ : Mul M
S T : Subsemigroup M
this : S ≤ S ⊔ T
⊢ ∀ {x : M}, x ∈ S → x ∈ S ⊔ T
state_after: no goals
tactic: tauto
Theorem: Substring.Valid.foldl
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: α : Type u_1
f : α → Char → α
init : α
x✝ : Substring
h✝ : x✝.Valid
w✝² w✝¹ w✝ : List Char
h : ValidFor w✝² w✝¹ w✝ x✝
⊢ Substring.foldl f init x✝ = List.foldl f init x✝.toString.data
state_after: no goals
tactic: simp [h.foldl, h.toString]
Theorem: ModularGroup.lcRow0Extend_symm_apply
File: Mathlib/NumberTheory/Modular.lean

Proof steps:
state_before: g : SL(2, ℤ)
z : ℍ
cd : Fin 2 → ℤ
hcd : IsCoprime (cd 0) (cd 1)
⊢ (Fin 2 → ℝ) ≃ₗ[ℝ] Fin 2 → ℝ
state_after: g : SL(2, ℤ)
z : ℍ
cd : Fin 2 → ℤ
hcd : IsCoprime (cd 0) (cd 1)
⊢ ↑(cd 0) ^ 2 + (-↑(cd 1)) ^ 2 ≠ 0
tactic: refine
        LinearMap.GeneralLinearGroup.generalLinearEquiv ℝ (Fin 2 → ℝ)
          (GeneralLinearGroup.toLinear (planeConformalMatrix (cd 0 : ℝ) (-(cd 1 : ℝ)) ?_))
state_before: g : SL(2, ℤ)
z : ℍ
cd : Fin 2 → ℤ
hcd : IsCoprime (cd 0) (cd 1)
⊢ ↑(cd 0) ^ 2 + (-↑(cd 1)) ^ 2 ≠ 0
state_after: g : SL(2, ℤ)
z : ℍ
cd : Fin 2 → ℤ
hcd : IsCoprime (cd 0) (cd 1)
⊢ ¬cd 0 ^ 2 + (-cd 1) ^ 2 = 0
tactic: norm_cast
state_before: g : SL(2, ℤ)
z : ℍ
cd : Fin 2 → ℤ
hcd : IsCoprime (cd 0) (cd 1)
⊢ ¬cd 0 ^ 2 + (-cd 1) ^ 2 = 0
state_after: g : SL(2, ℤ)
z : ℍ
cd : Fin 2 → ℤ
hcd : IsCoprime (cd 0) (cd 1)
⊢ ¬cd 0 ^ 2 + cd 1 ^ 2 = 0
tactic: rw [neg_sq]
state_before: g : SL(2, ℤ)
z : ℍ
cd : Fin 2 → ℤ
hcd : IsCoprime (cd 0) (cd 1)
⊢ ¬cd 0 ^ 2 + cd 1 ^ 2 = 0
state_after: no goals
tactic: exact hcd.sq_add_sq_ne_zero
Theorem: Nat.divisorsAntidiagonal_one
File: Mathlib/NumberTheory/Divisors.lean

Proof steps:
state_before: n : ℕ
⊢ divisorsAntidiagonal 1 = {(1, 1)}
state_after: case a
n : ℕ
a✝ : ℕ × ℕ
⊢ a✝ ∈ divisorsAntidiagonal 1 ↔ a✝ ∈ {(1, 1)}
tactic: ext
state_before: case a
n : ℕ
a✝ : ℕ × ℕ
⊢ a✝ ∈ divisorsAntidiagonal 1 ↔ a✝ ∈ {(1, 1)}
state_after: no goals
tactic: simp [mul_eq_one, Prod.ext_iff]
Theorem: Real.eulerMascheroniSeq_lt_eulerMascheroniConstant
File: Mathlib/NumberTheory/Harmonic/EulerMascheroni.lean

Proof steps:
state_before: n : ℕ
⊢ eulerMascheroniSeq n < eulerMascheroniConstant
state_after: n : ℕ
⊢ eulerMascheroniSeq n.succ ≤ eulerMascheroniConstant
tactic: refine (strictMono_eulerMascheroniSeq (Nat.lt_succ_self n)).trans_le ?_
state_before: n : ℕ
⊢ eulerMascheroniSeq n.succ ≤ eulerMascheroniConstant
state_after: no goals
tactic: apply strictMono_eulerMascheroniSeq.monotone.ge_of_tendsto tendsto_eulerMascheroniSeq
Theorem: cmpUsing_eq_lt
File: Mathlib/Data/Ordering/Lemmas.lean

Proof steps:
state_before: α : Type u
lt : α → α → Prop
inst✝ : DecidableRel lt
a b : α
⊢ (cmpUsing lt a b = Ordering.lt) = lt a b
state_after: no goals
tactic: simp only [cmpUsing, Ordering.ite_eq_lt_distrib, ite_self, if_false_right, and_true]
Theorem: Finset.truncatedSup_empty
File: Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : SemilatticeSup α
inst✝⁴ : OrderTop α
inst✝³ : DecidableRel fun x x_1 => x ≤ x_1
inst✝² : SemilatticeSup β
inst✝¹ : BoundedOrder β
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s t : Finset α
a✝ b a : α
⊢ a ∉ lowerClosure ↑∅
state_after: no goals
tactic: simp
Theorem: Nat.choose_self
File: Mathlib/Data/Nat/Choose/Basic.lean

Proof steps:
state_before: n : ℕ
⊢ n.choose n = 1
state_after: no goals
tactic: induction n <;> simp [*, choose, choose_eq_zero_of_lt (lt_succ_self _)]
Theorem: Filter.EventuallyEq.fderivWithin_eq
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

Proof steps:
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_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
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
hs : f₁ =ᶠ[𝓝[s] x] f
hx : f₁ x = f x
⊢ fderivWithin 𝕜 f₁ s x = fderivWithin 𝕜 f s x
state_after: no goals
tactic: simp only [fderivWithin, hs.hasFDerivWithinAt_iff hx]
Theorem: Pi.single_add_single_eq_single_add_single
File: Mathlib/Algebra/Group/Pi/Lemmas.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x y : (i : I) → f i
i j : I
inst✝¹ : DecidableEq I
M : Type u_3
inst✝ : CommMonoid M
k l m n : I
u v : M
hu : u ≠ 1
hv : v ≠ 1
⊢ mulSingle k u * mulSingle l v = mulSingle m u * mulSingle n v ↔
    k = m ∧ l = n ∨ u = v ∧ k = n ∧ l = m ∨ u * v = 1 ∧ k = l ∧ m = n
state_after: case refine_1
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x y : (i : I) → f i
i j : I
inst✝¹ : DecidableEq I
M : Type u_3
inst✝ : CommMonoid M
k l m n : I
u v : M
hu : u ≠ 1
hv : v ≠ 1
h : mulSingle k u * mulSingle l v = mulSingle m u * mulSingle n v
⊢ k = m ∧ l = n ∨ u = v ∧ k = n ∧ l = m ∨ u * v = 1 ∧ k = l ∧ m = n

case refine_2
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x y : (i : I) → f i
i j : I
inst✝¹ : DecidableEq I
M : Type u_3
inst✝ : CommMonoid M
k l m n : I
u v : M
hu : u ≠ 1
hv : v ≠ 1
⊢ k = m ∧ l = n ∨ u = v ∧ k = n ∧ l = m ∨ u * v = 1 ∧ k = l ∧ m = n →
    mulSingle k u * mulSingle l v = mulSingle m u * mulSingle n v
tactic: refine ⟨fun h => ?_, ?_⟩
Theorem: HasFPowerSeriesAt.iterate_dslope_fslope_ne_zero
File: Mathlib/Analysis/Analytic/IsolatedZeros.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n : ℕ
z z₀ : 𝕜
hp : HasFPowerSeriesAt f p z₀
h : p ≠ 0
⊢ (swap dslope z₀)^[p.order] f z₀ ≠ 0
state_after: 𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n : ℕ
z z₀ : 𝕜
hp : HasFPowerSeriesAt f p z₀
h : p ≠ 0
⊢ (fslope^[p.order] p 0) 1 ≠ 0
tactic: rw [← coeff_zero (has_fpower_series_iterate_dslope_fslope p.order hp) 1]
state_before: 𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n : ℕ
z z₀ : 𝕜
hp : HasFPowerSeriesAt f p z₀
h : p ≠ 0
⊢ (fslope^[p.order] p 0) 1 ≠ 0
state_after: no goals
tactic: simpa [coeff_eq_zero] using apply_order_ne_zero h
Theorem: CategoryTheory.Limits.coconeOfIsSplitEpi_pt
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
inst✝ : IsSplitEpi f
⊢ 𝟙 X ≫ f = (f ≫ section_ f) ≫ f
state_after: no goals
tactic: simp
Theorem: Subgroup.is_normal_topologicalClosure
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G✝ : Type w
H : Type x
α : Type u
β : Type v
inst✝⁷ : TopologicalSpace G✝
inst✝⁶ : Group G✝
inst✝⁵ : TopologicalGroup G✝
inst✝⁴ : TopologicalSpace α
f : α → G✝
s : Set α
x : α
G : Type u_1
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
N : Subgroup G
inst✝ : N.Normal
n : G
hn : n ∈ N.topologicalClosure
g : G
⊢ g * n * g⁻¹ ∈ N.topologicalClosure
state_after: G✝ : Type w
H : Type x
α : Type u
β : Type v
inst✝⁷ : TopologicalSpace G✝
inst✝⁶ : Group G✝
inst✝⁵ : TopologicalGroup G✝
inst✝⁴ : TopologicalSpace α
f : α → G✝
s : Set α
x : α
G : Type u_1
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
N : Subgroup G
inst✝ : N.Normal
n : G
hn : n ∈ N.topologicalClosure
g : G
⊢ MapsTo (fun h => g * h * g⁻¹) ↑N ↑N
tactic: apply map_mem_closure (TopologicalGroup.continuous_conj g) hn
state_before: G✝ : Type w
H : Type x
α : Type u
β : Type v
inst✝⁷ : TopologicalSpace G✝
inst✝⁶ : Group G✝
inst✝⁵ : TopologicalGroup G✝
inst✝⁴ : TopologicalSpace α
f : α → G✝
s : Set α
x : α
G : Type u_1
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
N : Subgroup G
inst✝ : N.Normal
n : G
hn : n ∈ N.topologicalClosure
g : G
⊢ MapsTo (fun h => g * h * g⁻¹) ↑N ↑N
state_after: no goals
tactic: exact fun m hm => Subgroup.Normal.conj_mem inferInstance m hm g
Theorem: Finset.sum_filter_count_eq_countP
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝² : CommMonoid β
inst✝¹ : DecidableEq α
p : α → Prop
inst✝ : DecidablePred p
l : List α
⊢ ∑ x ∈ filter p l.toFinset, count x l = countP (fun b => decide (p b)) l
state_after: no goals
tactic: simp [Finset.sum, sum_map_count_dedup_filter_eq_countP p l]
Theorem: MeasureTheory.OuterMeasure.comap_iSup
File: Mathlib/MeasureTheory/OuterMeasure/Operations.lean

Proof steps:
state_before: α : Type u_1
β✝ : Type u_2
m✝ : OuterMeasure α
β : Type u_3
ι : Sort u_4
f : α → β
m : ι → OuterMeasure β
s : Set α
⊢ ((comap f) (⨆ i, m i)) s = (⨆ i, (comap f) (m i)) s
state_after: no goals
tactic: simp only [comap_apply, iSup_apply]
Theorem: Int.units_div_eq_mul
File: Mathlib/Data/Int/Order/Units.lean

Proof steps:
state_before: u₁ u₂ : ℤˣ
⊢ u₁ / u₂ = u₁ * u₂
state_after: no goals
tactic: rw [div_eq_mul_inv, units_inv_eq_self]
Theorem: Equiv.piCongrLeft'_symm_apply_apply
File: Mathlib/Logic/Equiv/Basic.lean

Proof steps:
state_before: α : Sort u_2
β : Sort u_3
P✝ : α → Sort w
e✝ : α ≃ β
P : α → Sort u_1
e : α ≃ β
g : (b : β) → P (e.symm b)
b : β
⊢ (piCongrLeft' P e).symm g (e.symm b) = g b
state_after: α : Sort u_2
β : Sort u_3
P✝ : α → Sort w
e✝ : α ≃ β
P : α → Sort u_1
e : α ≃ β
g : (b : β) → P (e.symm b)
b : β
⊢ ⋯ ▸ g (e (e.symm b)) = g b
tactic: change Eq.ndrec _ _ = _
state_before: α : Sort u_2
β : Sort u_3
P✝ : α → Sort w
e✝ : α ≃ β
P : α → Sort u_1
e : α ≃ β
g : (b : β) → P (e.symm b)
b : β
⊢ ⋯ ▸ g (e (e.symm b)) = g b
state_after: α : Sort u_2
β : Sort u_3
P✝ : α → Sort w
e✝ : α ≃ β
P : α → Sort u_1
e : α ≃ β
g : (b : β) → P (e.symm b)
b : β
hZa : e.symm (e (e.symm b)) = e.symm b
⊢ hZa ▸ g (e (e.symm b)) = g b
tactic: generalize_proofs hZa
state_before: α : Sort u_2
β : Sort u_3
P✝ : α → Sort w
e✝ : α ≃ β
P : α → Sort u_1
e : α ≃ β
g : (b : β) → P (e.symm b)
b : β
hZa : e.symm (e (e.symm b)) = e.symm b
⊢ hZa ▸ g (e (e.symm b)) = g b
state_after: α : Sort u_2
β : Sort u_3
P✝ : α → Sort w
e✝ : α ≃ β
P : α → Sort u_1
e : α ≃ β
g : (b : β) → P (e.symm b)
b : β
⊢ ∀ (hZa : e.symm (e (e.symm b)) = e.symm b), hZa ▸ g (e (e.symm b)) = g b
tactic: revert hZa
state_before: α : Sort u_2
β : Sort u_3
P✝ : α → Sort w
e✝ : α ≃ β
P : α → Sort u_1
e : α ≃ β
g : (b : β) → P (e.symm b)
b : β
⊢ ∀ (hZa : e.symm (e (e.symm b)) = e.symm b), hZa ▸ g (e (e.symm b)) = g b
state_after: α : Sort u_2
β : Sort u_3
P✝ : α → Sort w
e✝ : α ≃ β
P : α → Sort u_1
e : α ≃ β
g : (b : β) → P (e.symm b)
b : β
⊢ ∀ (hZa : e.symm b = e.symm b), hZa ▸ g b = g b
tactic: rw [e.apply_symm_apply b]
state_before: α : Sort u_2
β : Sort u_3
P✝ : α → Sort w
e✝ : α ≃ β
P : α → Sort u_1
e : α ≃ β
g : (b : β) → P (e.symm b)
b : β
⊢ ∀ (hZa : e.symm b = e.symm b), hZa ▸ g b = g b
state_after: no goals
tactic: simp