ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Subgroup.commutator_prod_prod
File: Mathlib/GroupTheory/Commutator.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
F : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : FunLike F G G'
inst✝ : MonoidHomClass F G G'
f : F
g₁ g₂ g₃ g : G
H₁ H₂ H₃ K₁✝ K₂✝ : Subgroup G
K₁ K₂ : Subgroup G'
⊢ ⁅H₁.prod K₁, H₂.prod K₂⁆ = ⁅H₁, H₂⁆.prod ⁅K₁, K₂⁆
state_after: case a
G : Type u_1
G' : Type u_2
F : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : FunLike F G G'
inst✝ : MonoidHomClass F G G'
f : F
g₁ g₂ g₃ g : G
H₁ H₂ H₃ K₁✝ K₂✝ : Subgroup G
K₁ K₂ : Subgroup G'
⊢ ⁅H₁.prod K₁, H₂.prod K₂⁆ ≤ ⁅H₁, H₂⁆.prod ⁅K₁, K₂⁆

case a
G : Type u_1
G' : Type u_2
F : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : FunLike F G G'
inst✝ : MonoidHomClass F G G'
f : F
g₁ g₂ g₃ g : G
H₁ H₂ H₃ K₁✝ K₂✝ : Subgroup G
K₁ K₂ : Subgroup G'
⊢ ⁅H₁, H₂⁆.prod ⁅K₁, K₂⁆ ≤ ⁅H₁.prod K₁, H₂.prod K₂⁆
tactic: apply le_antisymm
Theorem: Nat.Ico_succ_right
File: Mathlib/Order/Interval/Finset/Nat.lean

Proof steps:
state_before: a b c : ℕ
⊢ Ico a b.succ = Icc a b
state_after: case a
a b c x : ℕ
⊢ x ∈ Ico a b.succ ↔ x ∈ Icc a b
tactic: ext x
state_before: case a
a b c x : ℕ
⊢ x ∈ Ico a b.succ ↔ x ∈ Icc a b
state_after: no goals
tactic: rw [mem_Ico, mem_Icc, Nat.lt_succ_iff]
Theorem: Polynomial.Monic.eq_X_pow_iff_natDegree_le_natTrailingDegree
File: Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
h₁ : p.Monic
⊢ p = X ^ p.natDegree ↔ p.natDegree ≤ p.natTrailingDegree
state_after: case refine_1
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
h₁ : p.Monic
h : p = X ^ p.natDegree
⊢ p.natDegree ≤ p.natTrailingDegree

case refine_2
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
h₁ : p.Monic
h : p.natDegree ≤ p.natTrailingDegree
⊢ p = X ^ p.natDegree
tactic: refine ⟨fun h => ?_, fun h => ?_⟩
Theorem: AlgHom.restrictNormal_comp
File: Mathlib/FieldTheory/Normal.lean

Proof steps:
state_before: F : Type u_1
K : Type u_2
inst✝¹⁸ : Field F
inst✝¹⁷ : Field K
inst✝¹⁶ : Algebra F K
K₁ : Type u_3
K₂ : Type u_4
K₃ : Type u_5
inst✝¹⁵ : Field F
inst✝¹⁴ : Field K₁
inst✝¹³ : Field K₂
inst✝¹² : Field K₃
inst✝¹¹ : Algebra F K₁
inst✝¹⁰ : Algebra F K₂
inst✝⁹ : Algebra F K₃
ϕ : K₁ →ₐ[F] K₂
χ : K₁ ≃ₐ[F] K₂
ψ : K₂ →ₐ[F] K₃
ω : K₂ ≃ₐ[F] K₃
E : Type u_6
inst✝⁸ : Field E
inst✝⁷ : Algebra F E
inst✝⁶ : Algebra E K₁
inst✝⁵ : Algebra E K₂
inst✝⁴ : Algebra E K₃
inst✝³ : IsScalarTower F E K₁
inst✝² : IsScalarTower F E K₂
inst✝¹ : IsScalarTower F E K₃
inst✝ : Normal F E
x✝ : E
⊢ (algebraMap E K₃) (((ψ.restrictNormal E).comp (ϕ.restrictNormal E)) x✝) =
    (algebraMap E K₃) (((ψ.comp ϕ).restrictNormal E) x✝)
state_after: no goals
tactic: simp only [AlgHom.comp_apply, AlgHom.restrictNormal_commutes]
Theorem: CategoryTheory.Limits.colimitIsoColimitCurryCompColim_ι_ι_inv
File: Mathlib/CategoryTheory/Limits/Fubini.lean

Proof steps:
state_before: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ K ⥤ C
G : J × K ⥤ C
inst✝² : HasColimitsOfShape K C
inst✝¹ : HasColimit G
inst✝ : HasColimit (curry.obj G ⋙ colim)
j : J
k : K
⊢ colimit.ι ((curry.obj G).obj j) k ≫ colimit.ι (curry.obj G ⋙ colim) j ≫ (colimitIsoColimitCurryCompColim G).inv =
    colimit.ι G (j, k)
state_after: no goals
tactic: set_option tactic.skipAssignedInstances false in
  simp [colimitIsoColimitCurryCompColim, Trans.simple, HasColimit.isoOfNatIso,
    colimitUncurryIsoColimitCompColim]
Theorem: IntermediateField.eq_adjoin_of_eq_algebra_adjoin
File: Mathlib/FieldTheory/Adjoin.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
K : IntermediateField F E
h : K.toSubalgebra = Algebra.adjoin F S
⊢ K = adjoin F S
state_after: case a
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
K : IntermediateField F E
h : K.toSubalgebra = Algebra.adjoin F S
⊢ K.toSubalgebra = (adjoin F S).toSubalgebra
tactic: apply toSubalgebra_injective
state_before: case a
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
K : IntermediateField F E
h : K.toSubalgebra = Algebra.adjoin F S
⊢ K.toSubalgebra = (adjoin F S).toSubalgebra
state_after: case a
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
K : IntermediateField F E
h : K.toSubalgebra = Algebra.adjoin F S
⊢ Algebra.adjoin F S = (adjoin F S).toSubalgebra
tactic: rw [h]
state_before: case a
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
K : IntermediateField F E
h : K.toSubalgebra = Algebra.adjoin F S
⊢ Algebra.adjoin F S = (adjoin F S).toSubalgebra
state_after: case a
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
K : IntermediateField F E
h : K.toSubalgebra = Algebra.adjoin F S
⊢ ∀ x ∈ Algebra.adjoin F S, x⁻¹ ∈ Algebra.adjoin F S
tactic: refine (adjoin_eq_algebra_adjoin F _ ?_).symm
state_before: case a
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
K : IntermediateField F E
h : K.toSubalgebra = Algebra.adjoin F S
⊢ ∀ x ∈ Algebra.adjoin F S, x⁻¹ ∈ Algebra.adjoin F S
state_after: case a
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
K : IntermediateField F E
h : K.toSubalgebra = Algebra.adjoin F S
x : E
⊢ x ∈ Algebra.adjoin F S → x⁻¹ ∈ Algebra.adjoin F S
tactic: intro x
state_before: case a
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
K : IntermediateField F E
h : K.toSubalgebra = Algebra.adjoin F S
x : E
⊢ x ∈ Algebra.adjoin F S → x⁻¹ ∈ Algebra.adjoin F S
state_after: no goals
tactic: convert K.inv_mem (x := x) <;> rw [← h] <;> rfl
Theorem: Set.preimage_const_mul_Iic_of_neg
File: Mathlib/Data/Set/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a c : α
h : c < 0
⊢ (fun x => c * x) ⁻¹' Iic a = Ici (a / c)
state_after: no goals
tactic: simpa only [mul_comm] using preimage_mul_const_Iic_of_neg a h
Theorem: List.Ico.succ_top
File: Mathlib/Data/List/Intervals.lean

Proof steps:
state_before: n m : ℕ
h : n ≤ m
⊢ Ico n (m + 1) = Ico n m ++ [m]
state_after: case hml
n m : ℕ
h : n ≤ m
⊢ m ≤ m + 1
tactic: rwa [← succ_singleton, append_consecutive]
state_before: case hml
n m : ℕ
h : n ≤ m
⊢ m ≤ m + 1
state_after: no goals
tactic: exact Nat.le_succ _
Theorem: HasFTaylorSeriesUpToOn.add
File: Mathlib/Analysis/Calculus/ContDiff/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g✝ : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
q : E → FormalMultilinearSeries 𝕜 E F
g : E → F
hf : HasFTaylorSeriesUpToOn n f p s
hg : HasFTaylorSeriesUpToOn n g q s
⊢ HasFTaylorSeriesUpToOn n (f + g) (p + q) s
state_after: no goals
tactic: convert HasFTaylorSeriesUpToOn.continuousLinearMap_comp
    (ContinuousLinearMap.fst 𝕜 F F + .snd 𝕜 F F) (hf.prod hg)
Theorem: Function.Injective.list_map
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → β
h : Injective f
x : α
xs : List α
y : α
ys : List α
hxy : map f (x :: xs) = map f (y :: ys)
⊢ x :: xs = y :: ys
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → β
h : Injective f
x : α
xs : List α
y : α
ys : List α
hxy : f x = f y
hxys : map f xs = map f ys
⊢ x :: xs = y :: ys
tactic: injection hxy with hxy hxys
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → β
h : Injective f
x : α
xs : List α
y : α
ys : List α
hxy : f x = f y
hxys : map f xs = map f ys
⊢ x :: xs = y :: ys
state_after: no goals
tactic: rw [h hxy, h.list_map hxys]
Theorem: CategoryTheory.ShortComplex.LeftHomologyData.ofIsLimitKernelFork_K
File: Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.25254, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.LeftHomologyData
A : C
hf : S.f = 0
c : KernelFork S.g
hc : IsLimit c
⊢ ((hc.ofIsoLimit (Fork.ext (Iso.refl c.pt) ⋯)).lift (KernelFork.ofι S.f ⋯) ≫ 𝟙 c.pt) ≫ Fork.ι c = 0 ≫ Fork.ι c
state_after: C : Type u_1
inst✝¹ : Category.{?u.25254, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.LeftHomologyData
A : C
hf : S.f = 0
c : KernelFork S.g
hc : IsLimit c
⊢ ((hc.lift (KernelFork.ofι S.f ⋯) ≫ 𝟙 c.pt) ≫ 𝟙 c.pt) ≫ Fork.ι c = 0 ≫ Fork.ι c
tactic: dsimp
state_before: C : Type u_1
inst✝¹ : Category.{?u.25254, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.LeftHomologyData
A : C
hf : S.f = 0
c : KernelFork S.g
hc : IsLimit c
⊢ ((hc.lift (KernelFork.ofι S.f ⋯) ≫ 𝟙 c.pt) ≫ 𝟙 c.pt) ≫ Fork.ι c = 0 ≫ Fork.ι c
state_after: no goals
tactic: simp only [comp_id, zero_comp, Fork.IsLimit.lift_ι, Fork.ι_ofι, hf]
state_before: C : Type u_1
inst✝¹ : Category.{?u.25254, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.LeftHomologyData
A : C
hf : S.f = 0
c : KernelFork S.g
hc : IsLimit c
⊢ (hc.ofIsoLimit (Fork.ext (Iso.refl c.pt) ⋯)).lift (KernelFork.ofι S.f ⋯) ≫ Fork.ι c = 0 ≫ Fork.ι c
state_after: C : Type u_1
inst✝¹ : Category.{?u.25254, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.LeftHomologyData
A : C
hf : S.f = 0
c : KernelFork S.g
hc : IsLimit c
⊢ (hc.lift (KernelFork.ofι S.f ⋯) ≫ 𝟙 c.pt) ≫ Fork.ι c = 0 ≫ Fork.ι c
tactic: dsimp
state_before: C : Type u_1
inst✝¹ : Category.{?u.25254, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.LeftHomologyData
A : C
hf : S.f = 0
c : KernelFork S.g
hc : IsLimit c
⊢ (hc.lift (KernelFork.ofι S.f ⋯) ≫ 𝟙 c.pt) ≫ Fork.ι c = 0 ≫ Fork.ι c
state_after: no goals
tactic: simp only [comp_id, zero_comp, Fork.IsLimit.lift_ι, Fork.ι_ofι, hf]
Theorem: BoxIntegral.BoxAdditiveMap.map_apply
File: Mathlib/Analysis/BoxIntegral/Partition/Additive.lean

Proof steps:
state_before: ι : Type u_1
M : Type u_2
n : ℕ
N : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : AddCommMonoid N
I₀ : WithTop (Box ι)
I✝ J : Box ι
i : ι
f : ι →ᵇᵃ[I₀] M
g : M →+ N
I : Box ι
hI : ↑I ≤ I₀
π : Prepartition I
hπ : π.IsPartition
⊢ ∑ Ji ∈ π.boxes, (⇑g ∘ ⇑f) Ji = (⇑g ∘ ⇑f) I
state_after: no goals
tactic: simp_rw [comp, ← map_sum, f.sum_partition_boxes hI hπ]
Theorem: riemannZeta_eulerProduct
File: Mathlib/NumberTheory/EulerProduct/DirichletLSeries.lean

Proof steps:
state_before: s : ℂ
hs : 1 < s.re
⊢ Tendsto (fun n => ∏ p ∈ n.primesBelow, (1 - ↑p ^ (-s))⁻¹) atTop (𝓝 (riemannZeta s))
state_after: s : ℂ
hs : 1 < s.re
⊢ Tendsto (fun n => ∏ p ∈ n.primesBelow, (1 - ↑p ^ (-s))⁻¹) atTop (𝓝 (∑' (n : ℕ), (riemannZetaSummandHom ⋯) n))
tactic: rw [← tsum_riemannZetaSummand hs]
state_before: s : ℂ
hs : 1 < s.re
⊢ Tendsto (fun n => ∏ p ∈ n.primesBelow, (1 - ↑p ^ (-s))⁻¹) atTop (𝓝 (∑' (n : ℕ), (riemannZetaSummandHom ⋯) n))
state_after: no goals
tactic: apply eulerProduct_completely_multiplicative <| summable_riemannZetaSummand hs
Theorem: CategoryTheory.Pretriangulated.Triangle.isIso_of_isIsos
File: Mathlib/CategoryTheory/Triangulated/Basic.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasShift C ℤ
T₁ T₂ T₃ A B : Triangle C
f : A ⟶ B
h₁ : IsIso f.hom₁
h₂ : IsIso f.hom₂
h₃ : IsIso f.hom₃
⊢ IsIso f
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasShift C ℤ
T₁ T₂ T₃ A B : Triangle C
f : A ⟶ B
h₁ : IsIso f.hom₁
h₂ : IsIso f.hom₂
h₃ : IsIso f.hom₃
e : A ≅ B := A.isoMk B (asIso f.hom₁) (asIso f.hom₂) (asIso f.hom₃) ⋯ ⋯ ⋯
⊢ IsIso f
tactic: let e := Triangle.isoMk A B (asIso f.hom₁) (asIso f.hom₂) (asIso f.hom₃)
    (by simp) (by simp) (by simp)
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasShift C ℤ
T₁ T₂ T₃ A B : Triangle C
f : A ⟶ B
h₁ : IsIso f.hom₁
h₂ : IsIso f.hom₂
h₃ : IsIso f.hom₃
e : A ≅ B := A.isoMk B (asIso f.hom₁) (asIso f.hom₂) (asIso f.hom₃) ⋯ ⋯ ⋯
⊢ IsIso f
state_after: no goals
tactic: exact (inferInstance : IsIso e.hom)
Theorem: Finset.sum_pos
File: Mathlib/Algebra/Order/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝ : OrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
h : ∀ i ∈ s, 1 < f i
hs : s.Nonempty
⊢ 1 ≤ ∏ i ∈ s, 1
state_after: no goals
tactic: rw [prod_const_one]
Theorem: DFinsupp.neLocus_sub_left
File: Mathlib/Data/DFinsupp/NeLocus.lean

Proof steps:
state_before: α : Type u_1
N : α → Type u_2
inst✝² : DecidableEq α
inst✝¹ : (a : α) → DecidableEq (N a)
inst✝ : (a : α) → AddGroup (N a)
f f₁ f₂ g g₁ g₂ : Π₀ (a : α), N a
⊢ (f - g₁).neLocus (f - g₂) = g₁.neLocus g₂
state_after: no goals
tactic: simp only [sub_eq_add_neg, @neLocus_add_left α N _ _ _, neLocus_neg_neg]
Theorem: MeasureTheory.eventually_add_right_iff
File: Mathlib/MeasureTheory/Group/Measure.lean

Proof steps:
state_before: 𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : μ.IsMulRightInvariant
t : G
p : G → Prop
⊢ (∀ᵐ (x : G) ∂μ, p (x * t)) ↔ ∀ᵐ (x : G) ∂μ, p x
state_after: 𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : μ.IsMulRightInvariant
t : G
p : G → Prop
⊢ (∀ᵐ (x : G) ∂μ, p (x * t)) ↔ {x | p x} ∈ Filter.map (fun h => h * t) (ae μ)
tactic: conv_rhs => rw [Filter.Eventually, ← map_mul_right_ae μ t]
state_before: 𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : μ.IsMulRightInvariant
t : G
p : G → Prop
⊢ (∀ᵐ (x : G) ∂μ, p (x * t)) ↔ {x | p x} ∈ Filter.map (fun h => h * t) (ae μ)
state_after: no goals
tactic: rfl
Theorem: List.traverse_eq_map_id
File: Mathlib/Control/Traversable/Instances.lean

Proof steps:
state_before: F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β : Type u_1
f : α → β
x : List α
⊢ List.traverse (pure ∘ f) x = pure (f <$> x)
state_after: case cons
F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β : Type u_1
f : α → β
head✝ : α
tail✝ : List α
tail_ih✝ : List.traverse (pure ∘ f) tail✝ = pure (f <$> tail✝)
⊢ (Seq.seq (cons (f head✝)) fun x => map f tail✝) = f head✝ :: map f tail✝
tactic: induction x <;> simp! [*, functor_norm]
state_before: case cons
F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β : Type u_1
f : α → β
head✝ : α
tail✝ : List α
tail_ih✝ : List.traverse (pure ∘ f) tail✝ = pure (f <$> tail✝)
⊢ (Seq.seq (cons (f head✝)) fun x => map f tail✝) = f head✝ :: map f tail✝
state_after: no goals
tactic: rfl
Theorem: Submodule.prod_comap_inl
File: Mathlib/LinearAlgebra/Prod.lean

Proof steps:
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ comap (inl R M M₂) (p.prod q) = p
state_after: case h
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
x✝ : M
⊢ x✝ ∈ comap (inl R M M₂) (p.prod q) ↔ x✝ ∈ p
tactic: ext
state_before: case h
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
x✝ : M
⊢ x✝ ∈ comap (inl R M M₂) (p.prod q) ↔ x✝ ∈ p
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Limits.kernelIsoOfEq_trans
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

Proof steps:
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝³ : HasKernel f✝
f g h : X ⟶ Y
inst✝² : HasKernel f
inst✝¹ : HasKernel g
inst✝ : HasKernel h
w₁ : f = g
w₂ : g = h
⊢ kernelIsoOfEq w₁ ≪≫ kernelIsoOfEq w₂ = kernelIsoOfEq ⋯
state_after: case refl
C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝³ : HasKernel f✝
f h : X ⟶ Y
inst✝² : HasKernel f
inst✝¹ : HasKernel h
inst✝ : HasKernel f
w₂ : f = h
⊢ kernelIsoOfEq ⋯ ≪≫ kernelIsoOfEq w₂ = kernelIsoOfEq ⋯
tactic: cases w₁
state_before: case refl
C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝³ : HasKernel f✝
f h : X ⟶ Y
inst✝² : HasKernel f
inst✝¹ : HasKernel h
inst✝ : HasKernel f
w₂ : f = h
⊢ kernelIsoOfEq ⋯ ≪≫ kernelIsoOfEq w₂ = kernelIsoOfEq ⋯
state_after: case refl.refl
C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝³ : HasKernel f✝
f : X ⟶ Y
inst✝² inst✝¹ inst✝ : HasKernel f
⊢ kernelIsoOfEq ⋯ ≪≫ kernelIsoOfEq ⋯ = kernelIsoOfEq ⋯
tactic: cases w₂
state_before: case refl.refl
C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝³ : HasKernel f✝
f : X ⟶ Y
inst✝² inst✝¹ inst✝ : HasKernel f
⊢ kernelIsoOfEq ⋯ ≪≫ kernelIsoOfEq ⋯ = kernelIsoOfEq ⋯
state_after: case refl.refl.w.h
C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝³ : HasKernel f✝
f : X ⟶ Y
inst✝² inst✝¹ inst✝ : HasKernel f
⊢ (kernelIsoOfEq ⋯ ≪≫ kernelIsoOfEq ⋯).hom ≫ equalizer.ι f 0 = (kernelIsoOfEq ⋯).hom ≫ equalizer.ι f 0
tactic: ext
state_before: case refl.refl.w.h
C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝³ : HasKernel f✝
f : X ⟶ Y
inst✝² inst✝¹ inst✝ : HasKernel f
⊢ (kernelIsoOfEq ⋯ ≪≫ kernelIsoOfEq ⋯).hom ≫ equalizer.ι f 0 = (kernelIsoOfEq ⋯).hom ≫ equalizer.ι f 0
state_after: no goals
tactic: simp [kernelIsoOfEq]
Theorem: PerfectPairing.toDualRight_symm_toDualLeft
File: Mathlib/LinearAlgebra/PerfectPairing.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
p : PerfectPairing R M N
x : M
⊢ p.toDualRight.symm.dualMap (p.toDualLeft x) = (Dual.eval R M) x
state_after: case h
R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
p : PerfectPairing R M N
x : M
f : Dual R M
⊢ (p.toDualRight.symm.dualMap (p.toDualLeft x)) f = ((Dual.eval R M) x) f
tactic: ext f
state_before: case h
R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
p : PerfectPairing R M N
x : M
f : Dual R M
⊢ (p.toDualRight.symm.dualMap (p.toDualLeft x)) f = ((Dual.eval R M) x) f
state_after: case h
R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
p : PerfectPairing R M N
x : M
f : Dual R M
⊢ (p.toDualLeft x) (p.toDualRight.symm f) = f x
tactic: simp only [LinearEquiv.dualMap_apply, Dual.eval_apply]
state_before: case h
R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
p : PerfectPairing R M N
x : M
f : Dual R M
⊢ (p.toDualLeft x) (p.toDualRight.symm f) = f x
state_after: no goals
tactic: exact toDualLeft_of_toDualRight_symm p x f
Theorem: Set.neg_insert
File: Mathlib/Data/Set/Pointwise/Basic.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : InvolutiveInv α
s✝ t : Set α
a✝ a : α
s : Set α
⊢ (insert a s)⁻¹ = insert a⁻¹ s⁻¹
state_after: no goals
tactic: rw [insert_eq, union_inv, inv_singleton, insert_eq]
Theorem: Finset.sum_add_eq_sum_add_of_exists
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 β
s : Finset α
f : α → β
b₁ b₂ : β
a : α
ha : a ∈ s
h : f a * b₁ = f a * b₂
⊢ (∏ a ∈ s, f a) * b₁ = (∏ a ∈ s, f a) * b₂
state_after: no goals
tactic: classical
  rw [← insert_erase ha]
  simp only [mem_erase, ne_eq, not_true_eq_false, false_and, not_false_eq_true, prod_insert]
  rw [mul_assoc, mul_comm, mul_assoc, mul_comm b₁, h, ← mul_assoc, mul_comm _ (f a)]
Theorem: TopologicalSpace.separableSpace_iff_countable
File: Mathlib/Topology/Bases.lean

Proof steps:
state_before: α : Type u
β : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s : Set α
inst✝ : DiscreteTopology α
⊢ SeparableSpace α ↔ Countable α
state_after: no goals
tactic: simp [separableSpace_iff, countable_univ_iff]
Theorem: Topology.IsScott.isClosed_iff_isLowerSet_and_dirSupClosed
File: Mathlib/Topology/Order/ScottTopology.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : IsScott α
s : Set α
a : α
⊢ IsClosed s ↔ IsLowerSet s ∧ DirSupClosed s
state_after: no goals
tactic: rw [← isOpen_compl_iff, isOpen_iff_isUpperSet_and_dirSupInacc, isUpperSet_compl,
    dirSupInacc_compl]
Theorem: CauchySeq.subseq_subseq_mem
File: Mathlib/Topology/UniformSpace/Cauchy.lean

Proof steps:
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
V : ℕ → Set (α × α)
hV : ∀ (n : ℕ), V n ∈ 𝓤 α
u : ℕ → α
hu : CauchySeq u
f g : ℕ → ℕ
hf : Tendsto f atTop atTop
hg : Tendsto g atTop atTop
⊢ ∃ φ, StrictMono φ ∧ ∀ (n : ℕ), ((u ∘ f ∘ φ) n, (u ∘ g ∘ φ) n) ∈ V n
state_after: α : Type u
β : Type v
uniformSpace : UniformSpace α
V : ℕ → Set (α × α)
hV : ∀ (n : ℕ), V n ∈ 𝓤 α
u : ℕ → α
hu : Tendsto (Prod.map u u) atTop (𝓤 α)
f g : ℕ → ℕ
hf : Tendsto f atTop atTop
hg : Tendsto g atTop atTop
⊢ ∃ φ, StrictMono φ ∧ ∀ (n : ℕ), ((u ∘ f ∘ φ) n, (u ∘ g ∘ φ) n) ∈ V n
tactic: rw [cauchySeq_iff_tendsto] at hu
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
V : ℕ → Set (α × α)
hV : ∀ (n : ℕ), V n ∈ 𝓤 α
u : ℕ → α
hu : Tendsto (Prod.map u u) atTop (𝓤 α)
f g : ℕ → ℕ
hf : Tendsto f atTop atTop
hg : Tendsto g atTop atTop
⊢ ∃ φ, StrictMono φ ∧ ∀ (n : ℕ), ((u ∘ f ∘ φ) n, (u ∘ g ∘ φ) n) ∈ V n
state_after: no goals
tactic: exact ((hu.comp <| hf.prod_atTop hg).comp tendsto_atTop_diagonal).subseq_mem hV
Theorem: linearIndependent_fin_succ'
File: Mathlib/LinearAlgebra/LinearIndependent.lean

Proof steps:
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v✝ : ι → V
s t : Set V
x y z : V
n : ℕ
v : Fin (n + 1) → V
⊢ LinearIndependent K v ↔ LinearIndependent K (Fin.init v) ∧ v (Fin.last n) ∉ span K (range (Fin.init v))
state_after: no goals
tactic: rw [← linearIndependent_fin_snoc, Fin.snoc_init_self]
Theorem: HasStrictDerivAt.clog_real
File: Mathlib/Analysis/SpecialFunctions/Complex/LogDeriv.lean

Proof steps:
state_before: α : Type u_1
inst✝² : TopologicalSpace α
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℝ → ℂ
x : ℝ
f' : ℂ
h₁ : HasStrictDerivAt f f' x
h₂ : f x ∈ slitPlane
⊢ HasStrictDerivAt (fun t => log (f t)) (f' / f x) x
state_after: no goals
tactic: simpa only [div_eq_inv_mul] using (hasStrictFDerivAt_log_real h₂).comp_hasStrictDerivAt x h₁