ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.MonoidalCategory.whisker_assoc
File: Mathlib/CategoryTheory/Monoidal/Category.lean

Proof steps:
state_before: C : Type u
𝒞 : Category.{v, u} C
inst✝ : MonoidalCategory C
X Y Y' : C
f : Y ⟶ Y'
Z : C
⊢ (X ◁ f) ▷ Z = (α_ X Y Z).hom ≫ X ◁ f ▷ Z ≫ (α_ X Y' Z).inv
state_after: C : Type u
𝒞 : Category.{v, u} C
inst✝ : MonoidalCategory C
X Y Y' : C
f : Y ⟶ Y'
Z : C
⊢ (𝟙 X ⊗ f) ⊗ 𝟙 Z = (α_ X Y Z).hom ≫ (𝟙 X ⊗ f ⊗ 𝟙 Z) ≫ (α_ X Y' Z).inv
tactic: simp only [← id_tensorHom, ← tensorHom_id]
state_before: C : Type u
𝒞 : Category.{v, u} C
inst✝ : MonoidalCategory C
X Y Y' : C
f : Y ⟶ Y'
Z : C
⊢ (𝟙 X ⊗ f) ⊗ 𝟙 Z = (α_ X Y Z).hom ≫ (𝟙 X ⊗ f ⊗ 𝟙 Z) ≫ (α_ X Y' Z).inv
state_after: C : Type u
𝒞 : Category.{v, u} C
inst✝ : MonoidalCategory C
X Y Y' : C
f : Y ⟶ Y'
Z : C
⊢ (𝟙 X ⊗ f) ⊗ 𝟙 Z = (((𝟙 X ⊗ f) ⊗ 𝟙 Z) ≫ (α_ X Y' Z).hom) ≫ (α_ X Y' Z).inv
tactic: rw [← assoc, ← associator_naturality]
state_before: C : Type u
𝒞 : Category.{v, u} C
inst✝ : MonoidalCategory C
X Y Y' : C
f : Y ⟶ Y'
Z : C
⊢ (𝟙 X ⊗ f) ⊗ 𝟙 Z = (((𝟙 X ⊗ f) ⊗ 𝟙 Z) ≫ (α_ X Y' Z).hom) ≫ (α_ X Y' Z).inv
state_after: no goals
tactic: simp
Theorem: Set.toFinset_eq_univ
File: Mathlib/Data/Fintype/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
inst✝¹ : Fintype α
inst✝ : Fintype ↑s
⊢ s.toFinset = Finset.univ ↔ s = univ
state_after: no goals
tactic: rw [← coe_inj, coe_toFinset, coe_univ]
Theorem: fourierSubalgebra_coe
File: Mathlib/Analysis/Fourier/AddCircle.lean

Proof steps:
state_before: T : ℝ
⊢ Subalgebra.toSubmodule fourierSubalgebra.toSubalgebra = span ℂ (range fourier)
state_after: case hs
T : ℝ
⊢ ↑(Submonoid.closure (range fourier)) ⊆ ↑(span ℂ (range fourier))
tactic: apply adjoin_eq_span_of_subset
state_before: case hs
T : ℝ
⊢ ↑(Submonoid.closure (range fourier)) ⊆ ↑(span ℂ (range fourier))
state_after: case hs
T : ℝ
⊢ ↑(Submonoid.closure (range fourier)) ⊆ range fourier
tactic: refine Subset.trans ?_ Submodule.subset_span
state_before: case hs
T : ℝ
⊢ ↑(Submonoid.closure (range fourier)) ⊆ range fourier
state_after: case hs
T : ℝ
x : C(AddCircle T, ℂ)
hx : x ∈ ↑(Submonoid.closure (range fourier))
⊢ x ∈ range fourier
tactic: intro x hx
state_before: case hs
T : ℝ
x : C(AddCircle T, ℂ)
hx : x ∈ ↑(Submonoid.closure (range fourier))
⊢ x ∈ range fourier
state_after: case hs.refine_1
T : ℝ
x : C(AddCircle T, ℂ)
hx : x ∈ ↑(Submonoid.closure (range fourier))
⊢ fourier 0 = 1

case hs.refine_2
T : ℝ
x : C(AddCircle T, ℂ)
hx : x ∈ ↑(Submonoid.closure (range fourier))
⊢ ∀ (x y : C(AddCircle T, ℂ)), x ∈ range fourier → y ∈ range fourier → x * y ∈ range fourier
tactic: refine Submonoid.closure_induction hx (fun _ => id) ⟨0, ?_⟩ ?_
Theorem: CategoryTheory.StructuredArrow.isoMk_hom_left_down_down
File: Mathlib/CategoryTheory/Comma/StructuredArrow.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
f f' : StructuredArrow S T
g : f.right ≅ f'.right
w : autoParam (f.hom ≫ T.map g.hom = f'.hom) _auto✝
⊢ f.left = f'.left
state_after: no goals
tactic: ext
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
f f' : StructuredArrow S T
g : f.right ≅ f'.right
w : autoParam (f.hom ≫ T.map g.hom = f'.hom) _auto✝
⊢ (Functor.fromPUnit S).map (eqToIso ⋯).hom ≫ f'.hom = f.hom ≫ T.map g.hom
state_after: no goals
tactic: simpa using w.symm
Theorem: Ordinal.natCast_inj
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: m n : ℕ
⊢ ↑m = ↑n ↔ m = n
state_after: no goals
tactic: simp only [le_antisymm_iff, natCast_le]
Theorem: Finset.imageZeroHom_apply
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁴ : One α
s : Finset α
a : α
inst✝³ : DecidableEq β
inst✝² : One β
inst✝¹ : FunLike F α β
inst✝ : OneHomClass F α β
f : F
⊢ image (⇑f) 1 = 1
state_after: no goals
tactic: rw [image_one, map_one, singleton_one]
Theorem: Complex.hasStrictFDerivAt_cpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

Proof steps:
state_before: p : ℂ × ℂ
hp : p.1 ∈ slitPlane
⊢ HasStrictFDerivAt (fun x => x.1 ^ x.2)
    ((p.2 * p.1 ^ (p.2 - 1)) • ContinuousLinearMap.fst ℂ ℂ ℂ + (p.1 ^ p.2 * log p.1) • ContinuousLinearMap.snd ℂ ℂ ℂ) p
state_after: p : ℂ × ℂ
hp : p.1 ∈ slitPlane
A : p.1 ≠ 0
⊢ HasStrictFDerivAt (fun x => x.1 ^ x.2)
    ((p.2 * p.1 ^ (p.2 - 1)) • ContinuousLinearMap.fst ℂ ℂ ℂ + (p.1 ^ p.2 * log p.1) • ContinuousLinearMap.snd ℂ ℂ ℂ) p
tactic: have A : p.1 ≠ 0 := slitPlane_ne_zero hp
state_before: p : ℂ × ℂ
hp : p.1 ∈ slitPlane
A : p.1 ≠ 0
⊢ HasStrictFDerivAt (fun x => x.1 ^ x.2)
    ((p.2 * p.1 ^ (p.2 - 1)) • ContinuousLinearMap.fst ℂ ℂ ℂ + (p.1 ^ p.2 * log p.1) • ContinuousLinearMap.snd ℂ ℂ ℂ) p
state_after: p : ℂ × ℂ
hp : p.1 ∈ slitPlane
A : p.1 ≠ 0
this : (fun x => x.1 ^ x.2) =ᶠ[𝓝 p] fun x => cexp (log x.1 * x.2)
⊢ HasStrictFDerivAt (fun x => x.1 ^ x.2)
    ((p.2 * p.1 ^ (p.2 - 1)) • ContinuousLinearMap.fst ℂ ℂ ℂ + (p.1 ^ p.2 * log p.1) • ContinuousLinearMap.snd ℂ ℂ ℂ) p
tactic: have : (fun x : ℂ × ℂ => x.1 ^ x.2) =ᶠ[𝓝 p] fun x => exp (log x.1 * x.2) :=
    ((isOpen_ne.preimage continuous_fst).eventually_mem A).mono fun p hp =>
      cpow_def_of_ne_zero hp _
state_before: p : ℂ × ℂ
hp : p.1 ∈ slitPlane
A : p.1 ≠ 0
this : (fun x => x.1 ^ x.2) =ᶠ[𝓝 p] fun x => cexp (log x.1 * x.2)
⊢ HasStrictFDerivAt (fun x => x.1 ^ x.2)
    ((p.2 * p.1 ^ (p.2 - 1)) • ContinuousLinearMap.fst ℂ ℂ ℂ + (p.1 ^ p.2 * log p.1) • ContinuousLinearMap.snd ℂ ℂ ℂ) p
state_after: p : ℂ × ℂ
hp : p.1 ∈ slitPlane
A : p.1 ≠ 0
this : (fun x => x.1 ^ x.2) =ᶠ[𝓝 p] fun x => cexp (log x.1 * x.2)
⊢ HasStrictFDerivAt (fun x => x.1 ^ x.2)
    (p.1 ^ p.2 • (p.2 / p.1) • ContinuousLinearMap.fst ℂ ℂ ℂ + p.1 ^ p.2 • log p.1 • ContinuousLinearMap.snd ℂ ℂ ℂ) p
tactic: rw [cpow_sub _ _ A, cpow_one, mul_div_left_comm, mul_smul, mul_smul]
state_before: p : ℂ × ℂ
hp : p.1 ∈ slitPlane
A : p.1 ≠ 0
this : (fun x => x.1 ^ x.2) =ᶠ[𝓝 p] fun x => cexp (log x.1 * x.2)
⊢ HasStrictFDerivAt (fun x => x.1 ^ x.2)
    (p.1 ^ p.2 • (p.2 / p.1) • ContinuousLinearMap.fst ℂ ℂ ℂ + p.1 ^ p.2 • log p.1 • ContinuousLinearMap.snd ℂ ℂ ℂ) p
state_after: p : ℂ × ℂ
hp : p.1 ∈ slitPlane
A : p.1 ≠ 0
this : (fun x => x.1 ^ x.2) =ᶠ[𝓝 p] fun x => cexp (log x.1 * x.2)
⊢ HasStrictFDerivAt (fun x => cexp (log x.1 * x.2))
    (p.1 ^ p.2 • (p.2 / p.1) • ContinuousLinearMap.fst ℂ ℂ ℂ + p.1 ^ p.2 • log p.1 • ContinuousLinearMap.snd ℂ ℂ ℂ) p
tactic: refine HasStrictFDerivAt.congr_of_eventuallyEq ?_ this.symm
state_before: p : ℂ × ℂ
hp : p.1 ∈ slitPlane
A : p.1 ≠ 0
this : (fun x => x.1 ^ x.2) =ᶠ[𝓝 p] fun x => cexp (log x.1 * x.2)
⊢ HasStrictFDerivAt (fun x => cexp (log x.1 * x.2))
    (p.1 ^ p.2 • (p.2 / p.1) • ContinuousLinearMap.fst ℂ ℂ ℂ + p.1 ^ p.2 • log p.1 • ContinuousLinearMap.snd ℂ ℂ ℂ) p
state_after: no goals
tactic: simpa only [cpow_def_of_ne_zero A, div_eq_mul_inv, mul_smul, add_comm, smul_add] using
    ((hasStrictFDerivAt_fst.clog hp).mul hasStrictFDerivAt_snd).cexp
Theorem: Fin.coe_eq_castSucc
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
a : Fin n
⊢ ↑↑a = a.castSucc
state_after: case h
n m : ℕ
a : Fin n
⊢ ↑↑↑a = ↑a.castSucc
tactic: ext
state_before: case h
n m : ℕ
a : Fin n
⊢ ↑↑↑a = ↑a.castSucc
state_after: no goals
tactic: exact val_cast_of_lt (Nat.lt.step a.is_lt)
Theorem: AddMonoid.Coprod.sum_mk_fst_snd
File: Mathlib/GroupTheory/Coprod/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
inst✝¹ : Monoid M
inst✝ : Monoid N
x : M ∗ N
⊢ (fst x, snd x) = toProd x
state_after: no goals
tactic: rw [← fst_prod_snd, MonoidHom.prod_apply]
Theorem: Finset.prod_partition
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 β
R : Setoid α
inst✝ : DecidableRel Setoid.r
⊢ ∏ x ∈ s, f x = ∏ xbar ∈ image Quotient.mk'' s, ∏ y ∈ filter (fun x => ⟦x⟧ = xbar) s, f y
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoid β
R : Setoid α
inst✝ : DecidableRel Setoid.r
x : α
_hx : x ∈ s
⊢ ∏ y ∈ filter (fun x_1 => ⟦x_1⟧ = Quotient.mk'' x) s, f y =
    ∏ x ∈ filter (fun c' => Quotient.mk'' c' = Quotient.mk'' x) s, f x
tactic: refine (Finset.prod_image' f fun x _hx => ?_).symm
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 β
R : Setoid α
inst✝ : DecidableRel Setoid.r
x : α
_hx : x ∈ s
⊢ ∏ y ∈ filter (fun x_1 => ⟦x_1⟧ = Quotient.mk'' x) s, f y =
    ∏ x ∈ filter (fun c' => Quotient.mk'' c' = Quotient.mk'' x) s, f x
state_after: no goals
tactic: rfl
Theorem: Homeomorph.comap_nhds_eq
File: Mathlib/Topology/Homeomorph.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
h : X ≃ₜ Y
y : Y
⊢ comap (⇑h) (𝓝 y) = 𝓝 (h.symm y)
state_after: no goals
tactic: rw [h.nhds_eq_comap, h.apply_symm_apply]
Theorem: LieSubmodule.independent_iff_coe_toSubmodule
File: Mathlib/Algebra/Lie/Submodule.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N✝ N' : LieSubmodule R L M
I J : LieIdeal R L
ι : Type u_1
N : ι → LieSubmodule R L M
⊢ CompleteLattice.Independent N ↔ CompleteLattice.Independent fun i => ↑(N i)
state_after: no goals
tactic: simp [CompleteLattice.independent_def, disjoint_iff_coe_toSubmodule]
Theorem: List.concat_eq_reverse_cons
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a : α
l : List α
⊢ l.concat a = (a :: l.reverse).reverse
state_after: no goals
tactic: simp only [concat_eq_append, reverse_cons, reverse_reverse]
Theorem: NNReal.IsConjExponent.inv_inv
File: Mathlib/Data/Real/ConjExponents.lean

Proof steps:
state_before: a b p q : ℝ≥0
h : p.IsConjExponent q
ha : a ≠ 0
hb : b ≠ 0
hab : a + b = 1
⊢ a < 1
state_after: a b p q : ℝ≥0
h : p.IsConjExponent q
ha : a ≠ 0
hb : b ≠ 0
hab : a + b = 1
⊢ a < a + b
tactic: rw [← hab]
state_before: a b p q : ℝ≥0
h : p.IsConjExponent q
ha : a ≠ 0
hb : b ≠ 0
hab : a + b = 1
⊢ a < a + b
state_after: no goals
tactic: exact lt_add_of_pos_right _ hb.bot_lt
state_before: a b p q : ℝ≥0
h : p.IsConjExponent q
ha : a ≠ 0
hb : b ≠ 0
hab : a + b = 1
⊢ a⁻¹⁻¹ + b⁻¹⁻¹ = 1
state_after: no goals
tactic: simpa only [inv_inv] using hab
Theorem: exists_one_lt_mul_of_lt
File: Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean

Proof steps:
state_before: α : Type u
inst✝ : CanonicallyOrderedCommMonoid α
a b c d : α
h : a < b
⊢ ∃ c x, a * c = b
state_after: case intro
α : Type u
inst✝ : CanonicallyOrderedCommMonoid α
a b c✝ d : α
h : a < b
c : α
hc : b = a * c
⊢ ∃ c x, a * c = b
tactic: obtain ⟨c, hc⟩ := le_iff_exists_mul.1 h.le
state_before: case intro
α : Type u
inst✝ : CanonicallyOrderedCommMonoid α
a b c✝ d : α
h : a < b
c : α
hc : b = a * c
⊢ ∃ c x, a * c = b
state_after: case intro
α : Type u
inst✝ : CanonicallyOrderedCommMonoid α
a b c✝ d : α
h : a < b
c : α
hc : b = a * c
⊢ c ≠ 1
tactic: refine ⟨c, one_lt_iff_ne_one.2 ?_, hc.symm⟩
state_before: case intro
α : Type u
inst✝ : CanonicallyOrderedCommMonoid α
a b c✝ d : α
h : a < b
c : α
hc : b = a * c
⊢ c ≠ 1
state_after: case intro
α : Type u
inst✝ : CanonicallyOrderedCommMonoid α
a b c d : α
h : a < b
hc : b = a * 1
⊢ False
tactic: rintro rfl
state_before: case intro
α : Type u
inst✝ : CanonicallyOrderedCommMonoid α
a b c d : α
h : a < b
hc : b = a * 1
⊢ False
state_after: no goals
tactic: simp [hc, lt_irrefl] at h
Theorem: Valued.norm_nonneg
File: Mathlib/Topology/Algebra/Valued/NormedValued.lean

Proof steps:
state_before: K : Type u_1
hK : NormedField K
h : IsNonarchimedean (sorryAx (K → ℝ) true)
L : Type u_2
inst✝¹ : Field L
Γ₀ : Type u_3
inst✝ : LinearOrderedCommGroupWithZero Γ₀
val : Valued L Γ₀
hv : v.RankOne
x : L
⊢ 0 ≤ norm x
state_after: no goals
tactic: simp only [norm, NNReal.zero_le_coe]
Theorem: CliffordAlgebra.contractRight_one
File: Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean

Proof steps:
state_before: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
⊢ (contractRight 1) d = 0
state_after: no goals
tactic: simpa only [map_one] using contractRight_algebraMap Q d 1
Theorem: AddMonoidHom.toIntLinearMap_injective
File: Mathlib/Algebra/Module/LinearMap/Defs.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
k : Type u_5
S : Type u_6
S₃ : Type u_7
T : Type u_8
M : Type u_9
M₁ : Type u_10
M₂ : Type u_11
M₃ : Type u_12
N₁ : Type u_13
N₂ : Type u_14
N₃ : Type u_15
ι : Type u_16
inst✝¹ : AddCommGroup M
inst✝ : AddCommGroup M₂
⊢ Injective toIntLinearMap
state_after: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
k : Type u_5
S : Type u_6
S₃ : Type u_7
T : Type u_8
M : Type u_9
M₁ : Type u_10
M₂ : Type u_11
M₃ : Type u_12
N₁ : Type u_13
N₂ : Type u_14
N₃ : Type u_15
ι : Type u_16
inst✝¹ : AddCommGroup M
inst✝ : AddCommGroup M₂
f g : M →+ M₂
h : f.toIntLinearMap = g.toIntLinearMap
⊢ f = g
tactic: intro f g h
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
k : Type u_5
S : Type u_6
S₃ : Type u_7
T : Type u_8
M : Type u_9
M₁ : Type u_10
M₂ : Type u_11
M₃ : Type u_12
N₁ : Type u_13
N₂ : Type u_14
N₃ : Type u_15
ι : Type u_16
inst✝¹ : AddCommGroup M
inst✝ : AddCommGroup M₂
f g : M →+ M₂
h : f.toIntLinearMap = g.toIntLinearMap
⊢ f = g
state_after: case h
R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
k : Type u_5
S : Type u_6
S₃ : Type u_7
T : Type u_8
M : Type u_9
M₁ : Type u_10
M₂ : Type u_11
M₃ : Type u_12
N₁ : Type u_13
N₂ : Type u_14
N₃ : Type u_15
ι : Type u_16
inst✝¹ : AddCommGroup M
inst✝ : AddCommGroup M₂
f g : M →+ M₂
h : f.toIntLinearMap = g.toIntLinearMap
x : M
⊢ f x = g x
tactic: ext x
state_before: case h
R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
k : Type u_5
S : Type u_6
S₃ : Type u_7
T : Type u_8
M : Type u_9
M₁ : Type u_10
M₂ : Type u_11
M₃ : Type u_12
N₁ : Type u_13
N₂ : Type u_14
N₃ : Type u_15
ι : Type u_16
inst✝¹ : AddCommGroup M
inst✝ : AddCommGroup M₂
f g : M →+ M₂
h : f.toIntLinearMap = g.toIntLinearMap
x : M
⊢ f x = g x
state_after: no goals
tactic: exact LinearMap.congr_fun h x
Theorem: MvPolynomial.bind₂_monomial_one
File: Mathlib/Algebra/MvPolynomial/Monad.lean

Proof steps:
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
T : Type u_5
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
f : R →+* MvPolynomial σ S
d : σ →₀ ℕ
⊢ (bind₂ f) ((monomial d) 1) = (monomial d) 1
state_after: no goals
tactic: rw [bind₂_monomial, f.map_one, one_mul]
Theorem: Module.End.IsSemisimple.minpoly_squarefree
File: Mathlib/LinearAlgebra/Semisimple.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
K : Type u_3
inst✝² : Field K
inst✝¹ : Module K M
f g : End K M
inst✝ : FiniteDimensional K M
hf : f.IsSemisimple
⊢ IsRadical (minpoly K f)
state_after: R : Type u_1
M : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
K : Type u_3
inst✝² : Field K
inst✝¹ : Module K M
f g : End K M
inst✝ : FiniteDimensional K M
hf : f.IsSemisimple
⊢ (annihilator K[X] (AEval' f)).IsRadical
tactic: rw [isRadical_iff_span_singleton, span_minpoly_eq_annihilator]
state_before: R : Type u_1
M : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
K : Type u_3
inst✝² : Field K
inst✝¹ : Module K M
f g : End K M
inst✝ : FiniteDimensional K M
hf : f.IsSemisimple
⊢ (annihilator K[X] (AEval' f)).IsRadical
state_after: no goals
tactic: exact hf.annihilator_isRadical
Theorem: Complex.arg_mul_coe_angle
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

Proof steps:
state_before: a x✝ z x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
⊢ ↑(x * y).arg = ↑x.arg + ↑y.arg
state_after: case h.e'_2.h.e'_1.h.e'_1
a x✝ z x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
⊢ x * y = ↑(abs x * abs y) * (↑(↑x.arg + ↑y.arg).cos + ↑(↑x.arg + ↑y.arg).sin * I)
tactic: convert arg_mul_cos_add_sin_mul_I_coe_angle (mul_pos (abs.pos hx) (abs.pos hy))
      (arg x + arg y : Real.Angle) using
    3
state_before: case h.e'_2.h.e'_1.h.e'_1
a x✝ z x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
⊢ x * y = ↑(abs x * abs y) * (↑(↑x.arg + ↑y.arg).cos + ↑(↑x.arg + ↑y.arg).sin * I)
state_after: case h.e'_2.h.e'_1.h.e'_1
a x✝ z x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
⊢ x * y = ↑(abs x) * ↑(abs y) * (cexp (↑x.arg * I) * cexp (↑y.arg * I))
tactic: simp_rw [← Real.Angle.coe_add, Real.Angle.sin_coe, Real.Angle.cos_coe, ofReal_cos, ofReal_sin,
    cos_add_sin_I, ofReal_add, add_mul, exp_add, ofReal_mul]
state_before: case h.e'_2.h.e'_1.h.e'_1
a x✝ z x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
⊢ x * y = ↑(abs x) * ↑(abs y) * (cexp (↑x.arg * I) * cexp (↑y.arg * I))
state_after: no goals
tactic: rw [mul_assoc, mul_comm (exp _), ← mul_assoc (abs y : ℂ), abs_mul_exp_arg_mul_I, mul_comm y, ←
    mul_assoc, abs_mul_exp_arg_mul_I]
Theorem: dvd_mul_sub_mul_mul_gcd_of_dvd
File: Mathlib/Algebra/Ring/Divisibility/Lemmas.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
p a b c d x y : R
inst✝¹ : IsDomain R
inst✝ : GCDMonoid R
h1 : p ∣ a * x + b * y
h2 : p ∣ c * x + d * y
⊢ p ∣ (a * d - b * c) * gcd x y
state_after: R : Type u_1
inst✝² : CommRing R
p a b c d x y : R
inst✝¹ : IsDomain R
inst✝ : GCDMonoid R
h1 : p ∣ a * x + b * y
h2 : p ∣ c * x + d * y
⊢ p ∣ gcd ((a * d - b * c) * x) ((a * d - b * c) * y)
tactic: rw [← (gcd_mul_left' (a*d - b*c) x y).dvd_iff_dvd_right]
state_before: R : Type u_1
inst✝² : CommRing R
p a b c d x y : R
inst✝¹ : IsDomain R
inst✝ : GCDMonoid R
h1 : p ∣ a * x + b * y
h2 : p ∣ c * x + d * y
⊢ p ∣ gcd ((a * d - b * c) * x) ((a * d - b * c) * y)
state_after: no goals
tactic: exact (dvd_gcd_iff _ _ _).2 ⟨dvd_mul_sub_mul_mul_left_of_dvd h1 h2,
    dvd_mul_sub_mul_mul_right_of_dvd h1 h2⟩
Theorem: closedBall_rpow_sub_one_eq_empty_aux
File: Mathlib/Analysis/SpecialFunctions/JapaneseBracket.lean

Proof steps:
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
r t : ℝ
hr : 0 < r
ht : 1 < t
⊢ Metric.closedBall 0 (t ^ (-r⁻¹) - 1) = ∅
state_after: E : Type u_1
inst✝ : NormedAddCommGroup E
r t : ℝ
hr : 0 < r
ht : 1 < t
⊢ t ^ (-r⁻¹) < 1
tactic: rw [Metric.closedBall_eq_empty, sub_neg]
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
r t : ℝ
hr : 0 < r
ht : 1 < t
⊢ t ^ (-r⁻¹) < 1
state_after: no goals
tactic: exact Real.rpow_lt_one_of_one_lt_of_neg ht (by simp only [hr, Right.neg_neg_iff, inv_pos])
Theorem: MeasureTheory.Measure.setIntegral_toReal_rnDeriv
File: Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
hμν : μ ≪ ν
s : Set α
⊢ ∫ (x : α) in s, (μ.rnDeriv ν x).toReal ∂ν = (μ s).toReal
state_after: no goals
tactic: rw [setIntegral_toReal_rnDeriv_eq_withDensity s, Measure.withDensity_rnDeriv_eq _ _ hμν]
Theorem: LieIdeal.derivedSeries_map_eq
File: Mathlib/Algebra/Lie/Solvable.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
k : ℕ
h : Function.Surjective ⇑f
⊢ map f (derivedSeries R L' k) = derivedSeries R L k
state_after: case zero
R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
h : Function.Surjective ⇑f
⊢ map f (derivedSeries R L' 0) = derivedSeries R L 0

case succ
R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
h : Function.Surjective ⇑f
k : ℕ
ih : map f (derivedSeries R L' k) = derivedSeries R L k
⊢ map f (derivedSeries R L' (k + 1)) = derivedSeries R L (k + 1)
tactic: induction' k with k ih
Theorem: Rat.toNNRat_mul
File: Mathlib/Data/NNRat/Defs.lean

Proof steps:
state_before: p q : ℚ
hp : 0 ≤ p
⊢ (p * q).toNNRat = p.toNNRat * q.toNNRat
state_after: case inl
p q : ℚ
hp : 0 ≤ p
hq : 0 ≤ q
⊢ (p * q).toNNRat = p.toNNRat * q.toNNRat

case inr
p q : ℚ
hp : 0 ≤ p
hq : q ≤ 0
⊢ (p * q).toNNRat = p.toNNRat * q.toNNRat
tactic: rcases le_total 0 q with hq | hq
Theorem: CategoryTheory.NatIso.isIso_of_isIso_app
File: Mathlib/CategoryTheory/NatIso.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
F G : C ⥤ D
X Y : C
α : F ⟶ G
inst✝ : ∀ (X : C), IsIso (α.app X)
⊢ ∀ {X Y : C} (f : X ⟶ Y), F.map f ≫ ((fun X => asIso (α.app X)) Y).hom = ((fun X => asIso (α.app X)) X).hom ≫ G.map f
state_after: no goals
tactic: aesop
Theorem: midpoint_comm
File: Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : Ring R
inst✝⁶ : Invertible 2
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x✝ y✝ z x y : P
⊢ midpoint R x y = midpoint R y x
state_after: no goals
tactic: rw [midpoint, ← lineMap_apply_one_sub, one_sub_invOf_two, midpoint]
Theorem: div_ball_one
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

Proof steps:
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ s / ball 1 δ = thickening δ s
state_after: no goals
tactic: simp [div_eq_mul_inv, mul_ball_one]
Theorem: Subgroup.normalCore_le
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
s : Set G
H : Subgroup G
a : G
h : a ∈ H.normalCore
⊢ a ∈ H
state_after: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
s : Set G
H : Subgroup G
a : G
h : a ∈ H.normalCore
⊢ 1 * a * 1⁻¹ ∈ H
tactic: rw [← mul_one a, ← inv_one, ← one_mul a]
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
s : Set G
H : Subgroup G
a : G
h : a ∈ H.normalCore
⊢ 1 * a * 1⁻¹ ∈ H
state_after: no goals
tactic: exact h 1
Theorem: Matrix.neg_vecMul_neg
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalNonAssocRing α
inst✝ : Fintype m
v : m → α
A : Matrix m n α
⊢ -v ᵥ* -A = v ᵥ* A
state_after: no goals
tactic: rw [vecMul_neg, neg_vecMul, neg_neg]
Theorem: Finset.sum_smul_sum_eq_sum_perm
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Semiring α
inst✝¹ : AddCommMonoid β
inst✝ : Module α β
s : Finset ι
σ : Perm ι
hσ : σ.IsCycleOn ↑s
f : ι → α
g : ι → β
⊢ (∑ i ∈ s, f i) • ∑ i ∈ s, g i = ∑ k ∈ range s.card, ∑ i ∈ s, f i • g ((σ ^ k) i)
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Semiring α
inst✝¹ : AddCommMonoid β
inst✝ : Module α β
s : Finset ι
σ : Perm ι
hσ : σ.IsCycleOn ↑s
f : ι → α
g : ι → β
⊢ ∑ x ∈ s ×ˢ s, f x.1 • g x.2 = ∑ k ∈ range s.card, ∑ i ∈ s, f i • g ((σ ^ k) i)
tactic: rw [sum_smul_sum, ← sum_product']
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Semiring α
inst✝¹ : AddCommMonoid β
inst✝ : Module α β
s : Finset ι
σ : Perm ι
hσ : σ.IsCycleOn ↑s
f : ι → α
g : ι → β
⊢ ∑ x ∈ s ×ˢ s, f x.1 • g x.2 = ∑ k ∈ range s.card, ∑ i ∈ s, f i • g ((σ ^ k) i)
state_after: no goals
tactic: simp_rw [product_self_eq_disjiUnion_perm hσ, sum_disjiUnion, sum_map, Embedding.coeFn_mk]