ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Algebra.Generators.ofComp_val
File: Mathlib/RingTheory/Generators.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝²⁹ : CommRing R
inst✝²⁸ : CommRing S
inst✝²⁷ : Algebra R S
P✝ : Generators R S
R' : Type ?u.417180
S' : Type ?u.417183
inst✝²⁶ : CommRing R'
inst✝²⁵ : CommRing S'
inst✝²⁴ : Algebra R' S'
P' : Generators R' S'
inst✝²³ : Algebra R R'
inst✝²² : Algebra S S'
inst✝²¹ : Algebra R S'
inst✝²⁰ : IsScalarTower R R' S'
inst✝¹⁹ : IsScalarTower R S S'
R'' : Type ?u.419614
S'' : Type ?u.419617
inst✝¹⁸ : CommRing R''
inst✝¹⁷ : CommRing S''
inst✝¹⁶ : Algebra R'' S''
P'' : Generators R'' S''
inst✝¹⁵ : Algebra R R''
inst✝¹⁴ : Algebra S S''
inst✝¹³ : Algebra R S''
inst✝¹² : IsScalarTower R R'' S''
inst✝¹¹ : IsScalarTower R S S''
inst✝¹⁰ : Algebra R' R''
inst✝⁹ : Algebra S' S''
inst✝⁸ : Algebra R' S''
inst✝⁷ : IsScalarTower R' R'' S''
inst✝⁶ : IsScalarTower R' S' S''
inst✝⁵ : IsScalarTower R R' R''
inst✝⁴ : IsScalarTower S S' S''
T : Type ?u.425474
inst✝³ : CommRing T
inst✝² : Algebra R T
inst✝¹ : Algebra S T
inst✝ : IsScalarTower R S T
Q : Generators S T
P : Generators R S
i : (Q.comp P).vars
⊢ (aeval Q.val) ((fun i => Sum.elim X (⇑C ∘ P.val) i) i) = (algebraMap T T) ((Q.comp P).val i)
state_after: no goals
tactic: cases i <;> simp
Theorem: Multiset.disjoint_map_map
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
f : α → γ
g : β → γ
s : Multiset α
t : Multiset β
⊢ (map f s).Disjoint (map g t) ↔ ∀ a ∈ s, ∀ b ∈ t, f a ≠ g b
state_after: no goals
tactic: simp [Disjoint, @eq_comm _ (f _) (g _)]
Theorem: Complex.sinh_mul_I
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℂ
⊢ sinh (x * I) = sin x * I
state_after: no goals
tactic: rw [← mul_right_inj' (two_ne_zero' ℂ), two_sinh, ← mul_assoc, two_sin, mul_assoc, I_mul_I,
    mul_neg_one, neg_sub, neg_mul_eq_neg_mul]
Theorem: Multiset.coeEquiv_apply_coe
File: Mathlib/Data/Multiset/Fintype.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
x : m.ToType
⊢ m.coeEmbedding x ∈ m.toEnumFinset
state_after: α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
x : m.ToType
⊢ (m.coeEmbedding x).2 < count (m.coeEmbedding x).1 m
tactic: rw [Multiset.mem_toEnumFinset]
state_before: α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
x : m.ToType
⊢ (m.coeEmbedding x).2 < count (m.coeEmbedding x).1 m
state_after: no goals
tactic: exact x.2.2
state_before: α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
x : { x // x ∈ m.toEnumFinset }
⊢ (↑x).2 < count (↑x).1 m
state_after: α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
x : { x // x ∈ m.toEnumFinset }
⊢ ↑x ∈ m.toEnumFinset
tactic: rw [← Multiset.mem_toEnumFinset]
state_before: α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
x : { x // x ∈ m.toEnumFinset }
⊢ ↑x ∈ m.toEnumFinset
state_after: no goals
tactic: exact x.2
state_before: α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
⊢ Function.LeftInverse (fun x => ⟨(↑x).1, ⟨(↑x).2, ⋯⟩⟩) fun x => ⟨m.coeEmbedding x, ⋯⟩
state_after: case mk.mk
α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
x : α
i : ℕ
h : i < count x m
⊢ (fun x => ⟨(↑x).1, ⟨(↑x).2, ⋯⟩⟩) ((fun x => ⟨m.coeEmbedding x, ⋯⟩) ⟨x, ⟨i, h⟩⟩) = ⟨x, ⟨i, h⟩⟩
tactic: rintro ⟨x, i, h⟩
state_before: case mk.mk
α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
x : α
i : ℕ
h : i < count x m
⊢ (fun x => ⟨(↑x).1, ⟨(↑x).2, ⋯⟩⟩) ((fun x => ⟨m.coeEmbedding x, ⋯⟩) ⟨x, ⟨i, h⟩⟩) = ⟨x, ⟨i, h⟩⟩
state_after: no goals
tactic: rfl
state_before: α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
⊢ Function.RightInverse (fun x => ⟨(↑x).1, ⟨(↑x).2, ⋯⟩⟩) fun x => ⟨m.coeEmbedding x, ⋯⟩
state_after: case mk.mk
α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
x : α
i : ℕ
h : (x, i) ∈ m.toEnumFinset
⊢ (fun x => ⟨m.coeEmbedding x, ⋯⟩) ((fun x => ⟨(↑x).1, ⟨(↑x).2, ⋯⟩⟩) ⟨(x, i), h⟩) = ⟨(x, i), h⟩
tactic: rintro ⟨⟨x, i⟩, h⟩
state_before: case mk.mk
α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
x : α
i : ℕ
h : (x, i) ∈ m.toEnumFinset
⊢ (fun x => ⟨m.coeEmbedding x, ⋯⟩) ((fun x => ⟨(↑x).1, ⟨(↑x).2, ⋯⟩⟩) ⟨(x, i), h⟩) = ⟨(x, i), h⟩
state_after: no goals
tactic: rfl
Theorem: Ideal.prime_span_singleton_iff
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDedekindDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
a : A
⊢ Prime (span {a}) ↔ Prime a
state_after: case inl
R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDedekindDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
⊢ Prime (span {0}) ↔ Prime 0

case inr
R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDedekindDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
a : A
ha : a ≠ 0
⊢ Prime (span {a}) ↔ Prime a
tactic: rcases eq_or_ne a 0 with rfl | ha
Theorem: Matrix.nonsing_inv_apply
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

Proof steps:
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
h : IsUnit A.det
⊢ A⁻¹ = ↑h.unit⁻¹ • A.adjugate
state_after: no goals
tactic: rw [inv_def, ← Ring.inverse_unit h.unit, IsUnit.unit_spec]
Theorem: Matrix.StdBasisMatrix.apply_of_ne
File: Mathlib/Data/Matrix/Basis.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
R : Type u_4
α : Type u_5
inst✝³ : DecidableEq l
inst✝² : DecidableEq m
inst✝¹ : DecidableEq n
inst✝ : Semiring α
i : m
j : n
c : α
i' : m
j' : n
h : ¬(i = i' ∧ j = j')
⊢ stdBasisMatrix i j c i' j' = 0
state_after: l : Type u_1
m : Type u_2
n : Type u_3
R : Type u_4
α : Type u_5
inst✝³ : DecidableEq l
inst✝² : DecidableEq m
inst✝¹ : DecidableEq n
inst✝ : Semiring α
i : m
j : n
c : α
i' : m
j' : n
h : ¬(i = i' ∧ j = j')
⊢ i = i' → j = j' → c = 0
tactic: simp only [stdBasisMatrix, and_imp, ite_eq_right_iff]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
R : Type u_4
α : Type u_5
inst✝³ : DecidableEq l
inst✝² : DecidableEq m
inst✝¹ : DecidableEq n
inst✝ : Semiring α
i : m
j : n
c : α
i' : m
j' : n
h : ¬(i = i' ∧ j = j')
⊢ i = i' → j = j' → c = 0
state_after: no goals
tactic: tauto
Theorem: Matrix.PosDef.transpose
File: Mathlib/LinearAlgebra/Matrix/PosDef.lean

Proof steps:
state_before: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁶ : Fintype m
inst✝⁵ : Fintype n
inst✝⁴ : CommRing R
inst✝³ : PartialOrder R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : RCLike 𝕜
M : Matrix n n R
hM : M.PosDef
⊢ Mᵀ.PosDef
state_after: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁶ : Fintype m
inst✝⁵ : Fintype n
inst✝⁴ : CommRing R
inst✝³ : PartialOrder R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : RCLike 𝕜
M : Matrix n n R
hM : M.PosDef
x : n → R
hx : x ≠ 0
⊢ 0 < star x ⬝ᵥ Mᵀ *ᵥ x
tactic: refine ⟨IsHermitian.transpose hM.1, fun x hx => ?_⟩
state_before: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁶ : Fintype m
inst✝⁵ : Fintype n
inst✝⁴ : CommRing R
inst✝³ : PartialOrder R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : RCLike 𝕜
M : Matrix n n R
hM : M.PosDef
x : n → R
hx : x ≠ 0
⊢ 0 < star x ⬝ᵥ Mᵀ *ᵥ x
state_after: case h.e'_4
m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁶ : Fintype m
inst✝⁵ : Fintype n
inst✝⁴ : CommRing R
inst✝³ : PartialOrder R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : RCLike 𝕜
M : Matrix n n R
hM : M.PosDef
x : n → R
hx : x ≠ 0
⊢ star x ⬝ᵥ Mᵀ *ᵥ x = star (star x) ⬝ᵥ M *ᵥ star x
tactic: convert hM.2 (star x) (star_ne_zero.2 hx) using 1
state_before: case h.e'_4
m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁶ : Fintype m
inst✝⁵ : Fintype n
inst✝⁴ : CommRing R
inst✝³ : PartialOrder R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : RCLike 𝕜
M : Matrix n n R
hM : M.PosDef
x : n → R
hx : x ≠ 0
⊢ star x ⬝ᵥ Mᵀ *ᵥ x = star (star x) ⬝ᵥ M *ᵥ star x
state_after: no goals
tactic: rw [mulVec_transpose, Matrix.dotProduct_mulVec, star_star, dotProduct_comm]
Theorem: Num.zero_add
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
n : Num
⊢ 0 + n = n
state_after: no goals
tactic: cases n <;> rfl
Theorem: CategoryTheory.Functor.isIso_ranAdjunction_unit_app_iff
File: Mathlib/CategoryTheory/Functor/KanExtension/Adjunction.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_6, u_1} C
inst✝² : Category.{u_4, u_2} D
L : C ⥤ D
H : Type u_3
inst✝¹ : Category.{u_5, u_3} H
inst✝ : ∀ (F : C ⥤ H), L.HasRightKanExtension F
G : D ⥤ H
⊢ whiskerLeft L ((L.ranAdjunction H).unit.app G) ≫ L.ranCounit.app (L ⋙ G) = 𝟙 (L ⋙ G)
state_after: no goals
tactic: simp
Theorem: CategoryTheory.PreservesImage.iso_hom
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Images.lean

Proof steps:
state_before: A : Type u₁
B : Type u₂
inst✝⁷ : Category.{v₁, u₁} A
inst✝⁶ : Category.{v₂, u₂} B
inst✝⁵ : HasEqualizers A
inst✝⁴ : HasImages A
inst✝³ : StrongEpiCategory B
inst✝² : HasImages B
L : A ⥤ B
inst✝¹ : {X Y Z : A} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PreservesLimit (cospan f g) L
inst✝ : {X Y Z : A} → (f : X ⟶ Y) → (g : X ⟶ Z) → PreservesColimit (span f g) L
X Y : A
f : X ⟶ Y
⊢ L.map (factorThruImage f) ≫ L.map (image.ι f) = L.map f
state_after: no goals
tactic: rw [← L.map_comp, Limits.image.fac]
Theorem: Finset.fold_op_distrib
File: Mathlib/Data/Finset/Fold.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
op : β → β → β
hc : Std.Commutative op
ha : Std.Associative op
f✝ : α → β
b : β
s : Finset α
a : α
f g : α → β
b₁ b₂ : β
⊢ fold op (op b₁ b₂) (fun x => op (f x) (g x)) s = op (fold op b₁ f s) (fold op b₂ g s)
state_after: no goals
tactic: simp only [fold, fold_distrib]
Theorem: BddAbove.range_comp
File: Mathlib/Order/Bounds/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ✝ : Type w
ι : Sort x
γ : Type u_1
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β
g : β → γ
hf : BddAbove (range f)
hg : Monotone g
⊢ BddAbove (range fun x => g (f x))
state_after: α : Type u
β : Type v
γ✝ : Type w
ι : Sort x
γ : Type u_1
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β
g : β → γ
hf : BddAbove (range f)
hg : Monotone g
⊢ BddAbove (range (g ∘ f))
tactic: change BddAbove (range (g ∘ f))
state_before: α : Type u
β : Type v
γ✝ : Type w
ι : Sort x
γ : Type u_1
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β
g : β → γ
hf : BddAbove (range f)
hg : Monotone g
⊢ BddAbove (range (g ∘ f))
state_after: no goals
tactic: simpa only [Set.range_comp] using hg.map_bddAbove hf
Theorem: StrictConvexSpace.of_norm_add
File: Mathlib/Analysis/Convex/StrictConvexSpace.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
h : ∀ (x y : E), ‖x‖ = 1 → ‖y‖ = 1 → ‖x + y‖ = 2 → SameRay ℝ x y
⊢ StrictConvexSpace ℝ E
state_after: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
h : ∀ (x y : E), ‖x‖ = 1 → ‖y‖ = 1 → ‖x + y‖ = 2 → SameRay ℝ x y
x : E
hx : x ∈ sphere 0 1
y : E
hy : y ∈ sphere 0 1
h₂ : ‖x + y‖ = 2
⊢ x = y
tactic: refine StrictConvexSpace.of_pairwise_sphere_norm_ne_two fun x hx y hy => mt fun h₂ => ?_
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
h : ∀ (x y : E), ‖x‖ = 1 → ‖y‖ = 1 → ‖x + y‖ = 2 → SameRay ℝ x y
x : E
hx : x ∈ sphere 0 1
y : E
hy : y ∈ sphere 0 1
h₂ : ‖x + y‖ = 2
⊢ x = y
state_after: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
h : ∀ (x y : E), ‖x‖ = 1 → ‖y‖ = 1 → ‖x + y‖ = 2 → SameRay ℝ x y
x : E
hx : ‖x‖ = 1
y : E
hy : ‖y‖ = 1
h₂ : ‖x + y‖ = 2
⊢ x = y
tactic: rw [mem_sphere_zero_iff_norm] at hx hy
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
h : ∀ (x y : E), ‖x‖ = 1 → ‖y‖ = 1 → ‖x + y‖ = 2 → SameRay ℝ x y
x : E
hx : ‖x‖ = 1
y : E
hy : ‖y‖ = 1
h₂ : ‖x + y‖ = 2
⊢ x = y
state_after: no goals
tactic: exact (sameRay_iff_of_norm_eq (hx.trans hy.symm)).1 (h x y hx hy h₂)
Theorem: _private.Mathlib.Topology.MetricSpace.GromovHausdorffRealized.0.GromovHausdorff.dist_mem_candidates
File: Mathlib/Topology/MetricSpace/GromovHausdorffRealized.lean

Proof steps:
state_before: X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f : GromovHausdorff.ProdSpaceFun X Y
x y z t : X ⊕ Y
⊢ (fun p => dist p.1 p.2) ∈ candidates X Y
state_after: X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f : GromovHausdorff.ProdSpaceFun X Y
x y z t : X ⊕ Y
⊢ (∀ (x y : X), dist (inl x) (inl y) = dist x y) ∧ ∀ (x y : Y), dist (inr x) (inr y) = dist x y
tactic: simp_rw [candidates, Set.mem_setOf_eq, dist_comm, dist_triangle, dist_self, maxVar_bound,
    forall_const, and_true]
state_before: X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f : GromovHausdorff.ProdSpaceFun X Y
x y z t : X ⊕ Y
⊢ (∀ (x y : X), dist (inl x) (inl y) = dist x y) ∧ ∀ (x y : Y), dist (inr x) (inr y) = dist x y
state_after: no goals
tactic: exact ⟨fun x y => rfl, fun x y => rfl⟩
Theorem: IsPGroup.sylow_mem_fixedPoints_iff
File: Mathlib/GroupTheory/Sylow.lean

Proof steps:
state_before: p : ℕ
G : Type u_1
inst✝ : Group G
P : Subgroup G
hP : IsPGroup p ↥P
Q : Sylow p G
⊢ Q ∈ fixedPoints (↥P) (Sylow p G) ↔ P ≤ ↑Q
state_after: no goals
tactic: rw [P.sylow_mem_fixedPoints_iff, ← inf_eq_left, hP.inf_normalizer_sylow, inf_eq_left]
Theorem: PowerSeries.le_order
File: Mathlib/RingTheory/PowerSeries/Order.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
φ✝ φ : R⟦X⟧
n : PartENat
h : ∀ (i : ℕ), ↑i < n → (coeff R i) φ = 0
⊢ n ≤ φ.order
state_after: case a
R : Type u_1
inst✝ : Semiring R
φ✝ φ : R⟦X⟧
h : ∀ (i : ℕ), ↑i < ⊤ → (coeff R i) φ = 0
⊢ ⊤ ≤ φ.order

case a
R : Type u_1
inst✝ : Semiring R
φ✝ φ : R⟦X⟧
n✝ : ℕ
h : ∀ (i : ℕ), ↑i < ↑n✝ → (coeff R i) φ = 0
⊢ ↑n✝ ≤ φ.order
tactic: induction n using PartENat.casesOn
Theorem: MulAut.conjNormal_symm_apply
File: Mathlib/GroupTheory/GroupAction/ConjAct.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
G : Type u_3
G₀ : Type u_4
R : Type u_5
K : Type u_6
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
g : G
h : ↥H
⊢ ↑((MulEquiv.symm (MulAut.conjNormal g)) h) = g⁻¹ * ↑h * g
state_after: α : Type u_1
M : Type u_2
G : Type u_3
G₀ : Type u_4
R : Type u_5
K : Type u_6
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
g : G
h : ↥H
⊢ ofConjAct (toConjAct.toMonoidHom g)⁻¹ * ↑h * (toConjAct.toMonoidHom g)⁻¹⁻¹ = g⁻¹ * ↑h * g
tactic: change _ * _⁻¹⁻¹ = _
state_before: α : Type u_1
M : Type u_2
G : Type u_3
G₀ : Type u_4
R : Type u_5
K : Type u_6
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
g : G
h : ↥H
⊢ ofConjAct (toConjAct.toMonoidHom g)⁻¹ * ↑h * (toConjAct.toMonoidHom g)⁻¹⁻¹ = g⁻¹ * ↑h * g
state_after: α : Type u_1
M : Type u_2
G : Type u_3
G₀ : Type u_4
R : Type u_5
K : Type u_6
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
g : G
h : ↥H
⊢ ofConjAct (toConjAct.toMonoidHom g)⁻¹ * ↑h * toConjAct.toMonoidHom g = g⁻¹ * ↑h * g
tactic: rw [inv_inv]
state_before: α : Type u_1
M : Type u_2
G : Type u_3
G₀ : Type u_4
R : Type u_5
K : Type u_6
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
g : G
h : ↥H
⊢ ofConjAct (toConjAct.toMonoidHom g)⁻¹ * ↑h * toConjAct.toMonoidHom g = g⁻¹ * ↑h * g
state_after: no goals
tactic: rfl
Theorem: NormedAddCommGroup.summable_imp_tendsto_of_complete
File: Mathlib/Analysis/Normed/Group/Completeness.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : CompleteSpace E
u : ℕ → E
hu : Summable fun x => ‖u x‖
⊢ ∃ a, Tendsto (fun n => ∑ i ∈ range n, u i) atTop (𝓝 a)
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : CompleteSpace E
u : ℕ → E
hu : Summable fun x => ‖u x‖
⊢ Summable fun n => dist (∑ i ∈ range n, u i) (∑ i ∈ range n.succ, u i)
tactic: refine cauchySeq_tendsto_of_complete <| cauchySeq_of_summable_dist ?_
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : CompleteSpace E
u : ℕ → E
hu : Summable fun x => ‖u x‖
⊢ Summable fun n => dist (∑ i ∈ range n, u i) (∑ i ∈ range n.succ, u i)
state_after: no goals
tactic: simp [dist_eq_norm, sum_range_succ, hu]
Theorem: IsLocalization.submonoid_map_le_is_unit
File: Mathlib/RingTheory/Localization/InvSubmonoid.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommRing P
inst✝ : IsLocalization M S
⊢ Submonoid.map (algebraMap R S) M ≤ IsUnit.submonoid S
state_after: case intro.intro
R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommRing P
inst✝ : IsLocalization M S
a : R
ha : a ∈ ↑M
⊢ (algebraMap R S) a ∈ IsUnit.submonoid S
tactic: rintro _ ⟨a, ha, rfl⟩
state_before: case intro.intro
R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommRing P
inst✝ : IsLocalization M S
a : R
ha : a ∈ ↑M
⊢ (algebraMap R S) a ∈ IsUnit.submonoid S
state_after: no goals
tactic: exact IsLocalization.map_units S ⟨_, ha⟩
Theorem: CategoryTheory.Limits.Cotrident.ofπ_pt
File: Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean

Proof steps:
state_before: J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
f✝ : J → (X ⟶ Y)
inst✝ : Nonempty J
P : C
π : Y ⟶ P
w : ∀ (j₁ j₂ : J), f✝ j₁ ≫ π = f✝ j₂ ≫ π
i j : WalkingParallelFamily J
f : i ⟶ j
⊢ (parallelFamily f✝).map f ≫ (fun X_1 => WalkingParallelFamily.casesOn X_1 (f✝ (Classical.arbitrary J) ≫ π) π) j =
    (fun X_1 => WalkingParallelFamily.casesOn X_1 (f✝ (Classical.arbitrary J) ≫ π) π) i ≫
      ((Functor.const (WalkingParallelFamily J)).obj P).map f
state_after: J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
f✝ : J → (X ⟶ Y)
inst✝ : Nonempty J
P : C
π : Y ⟶ P
w : ∀ (j₁ j₂ : J), f✝ j₁ ≫ π = f✝ j₂ ≫ π
i j : WalkingParallelFamily J
f : i ⟶ j
⊢ (parallelFamily f✝).map f ≫ WalkingParallelFamily.rec (f✝ (Classical.arbitrary J) ≫ π) π j =
    WalkingParallelFamily.rec (f✝ (Classical.arbitrary J) ≫ π) π i ≫ 𝟙 P
tactic: dsimp
state_before: J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
f✝ : J → (X ⟶ Y)
inst✝ : Nonempty J
P : C
π : Y ⟶ P
w : ∀ (j₁ j₂ : J), f✝ j₁ ≫ π = f✝ j₂ ≫ π
i j : WalkingParallelFamily J
f : i ⟶ j
⊢ (parallelFamily f✝).map f ≫ WalkingParallelFamily.rec (f✝ (Classical.arbitrary J) ≫ π) π j =
    WalkingParallelFamily.rec (f✝ (Classical.arbitrary J) ≫ π) π i ≫ 𝟙 P
state_after: case id
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
inst✝ : Nonempty J
P : C
π : Y ⟶ P
w : ∀ (j₁ j₂ : J), f j₁ ≫ π = f j₂ ≫ π
i : WalkingParallelFamily J
⊢ (parallelFamily f).map (Hom.id i) ≫ WalkingParallelFamily.rec (f (Classical.arbitrary J) ≫ π) π i =
    WalkingParallelFamily.rec (f (Classical.arbitrary J) ≫ π) π i ≫ 𝟙 P

case line
J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
inst✝ : Nonempty J
P : C
π : Y ⟶ P
w : ∀ (j₁ j₂ : J), f j₁ ≫ π = f j₂ ≫ π
k : J
⊢ (parallelFamily f).map (line k) ≫ WalkingParallelFamily.rec (f (Classical.arbitrary J) ≫ π) π one =
    WalkingParallelFamily.rec (f (Classical.arbitrary J) ≫ π) π zero ≫ 𝟙 P
tactic: cases' f with _ k
Theorem: CategoryTheory.Presheaf.isLocallySurjective_iff_imagePresheaf_sheafify_eq_top'
File: Mathlib/CategoryTheory/Sites/LocallySurjective.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝¹ : Category.{v', u'} A
inst✝ : ConcreteCategory A
F G : Cᵒᵖ ⥤ Type w
f : F ⟶ G
⊢ IsLocallySurjective J f ↔ Subpresheaf.sheafify J (imagePresheaf f) = ⊤
state_after: no goals
tactic: apply isLocallySurjective_iff_imagePresheaf_sheafify_eq_top
Theorem: _private.Mathlib.Data.Num.Lemmas.0.ZNum.mul_comm
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
⊢ ∀ (a b : ZNum), a * b = b * a
state_after: no goals
tactic: transfer
Theorem: Function.Antiperiodic.even_zsmul_periodic
File: Mathlib/Algebra/Periodic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddGroup α
inst✝ : InvolutiveNeg β
h : Antiperiodic f c
n : ℤ
⊢ Periodic f ((2 * n) • c)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddGroup α
inst✝ : InvolutiveNeg β
h : Antiperiodic f c
n : ℤ
⊢ Periodic f (n • 2 • c)
tactic: rw [mul_comm, mul_zsmul, two_zsmul, ← two_nsmul]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddGroup α
inst✝ : InvolutiveNeg β
h : Antiperiodic f c
n : ℤ
⊢ Periodic f (n • 2 • c)
state_after: no goals
tactic: exact h.periodic.zsmul n
Theorem: Ideal.span_pair_comm
File: Mathlib/RingTheory/Ideal/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b x y : α
⊢ span {x, y} = span {y, x}
state_after: no goals
tactic: simp only [span_insert, sup_comm]
Theorem: circleIntegral.integral_sub
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

Proof steps:
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f g : ℂ → E
c : ℂ
R : ℝ
hf : CircleIntegrable f c R
hg : CircleIntegrable g c R
⊢ (∮ (z : ℂ) in C(c, R), f z - g z) = (∮ (z : ℂ) in C(c, R), f z) - ∮ (z : ℂ) in C(c, R), g z
state_after: no goals
tactic: simp only [circleIntegral, smul_sub, intervalIntegral.integral_sub hf.out hg.out]
Theorem: Equiv.piCongr'_symm_apply_symm_apply
File: Mathlib/Logic/Equiv/Basic.lean

Proof steps:
state_before: α : Sort u_1
β : Sort u_2
W : α → Sort w
Z : β → Sort z
h₁ : α ≃ β
h₂ : (b : β) → W (h₁.symm b) ≃ Z b
f : (b : β) → Z b
b : β
⊢ (h₁.piCongr' h₂).symm f (h₁.symm b) = (h₂ b).symm (f b)
state_after: no goals
tactic: simp [piCongr', piCongr_apply_apply]
Theorem: Nat.div_lt_div_of_lt_of_dvd
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a✝ b✝ c d✝ m n k : ℕ
p q : ℕ → Prop
a b d : ℕ
hdb : d ∣ b
h : a < b
⊢ a / d < b / d
state_after: a✝ b✝ c d✝ m n k : ℕ
p q : ℕ → Prop
a b d : ℕ
hdb : d ∣ b
h : a < b
⊢ d * (a / d) < b
tactic: rw [Nat.lt_div_iff_mul_lt hdb]
state_before: a✝ b✝ c d✝ m n k : ℕ
p q : ℕ → Prop
a b d : ℕ
hdb : d ∣ b
h : a < b
⊢ d * (a / d) < b
state_after: no goals
tactic: exact lt_of_le_of_lt (mul_div_le a d) h