ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CoalgebraCat.MonoidalCategoryAux.comul_tensorObj
File: Mathlib/Algebra/Category/CoalgebraCat/ComonEquivalence.lean

Proof steps:
state_before: R : Type u
inst✝¹² : CommRing R
M N P Q : Type u
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : AddCommGroup Q
inst✝⁷ : Module R M
inst✝⁶ : Module R N
inst✝⁵ : Module R P
inst✝⁴ : Module R Q
inst✝³ : Coalgebra R M
inst✝² : Coalgebra R N
inst✝¹ : Coalgebra R P
inst✝ : Coalgebra R Q
⊢ Coalgebra.comul = Coalgebra.comul
state_after: R : Type u
inst✝¹² : CommRing R
M N P Q : Type u
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : AddCommGroup Q
inst✝⁷ : Module R M
inst✝⁶ : Module R N
inst✝⁵ : Module R P
inst✝⁴ : Module R Q
inst✝³ : Coalgebra R M
inst✝² : Coalgebra R N
inst✝¹ : Coalgebra R P
inst✝ : Coalgebra R Q
⊢ ((comonEquivalence R).symm.inverse.obj (of R M) ⊗ (comonEquivalence R).symm.inverse.obj (of R N)).comul =
    Coalgebra.comul
tactic: rw [ofComonObjCoalgebraStruct_comul]
state_before: R : Type u
inst✝¹² : CommRing R
M N P Q : Type u
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : AddCommGroup Q
inst✝⁷ : Module R M
inst✝⁶ : Module R N
inst✝⁵ : Module R P
inst✝⁴ : Module R Q
inst✝³ : Coalgebra R M
inst✝² : Coalgebra R N
inst✝¹ : Coalgebra R P
inst✝ : Coalgebra R Q
⊢ ((comonEquivalence R).symm.inverse.obj (of R M) ⊗ (comonEquivalence R).symm.inverse.obj (of R N)).comul =
    Coalgebra.comul
state_after: R : Type u
inst✝¹² : CommRing R
M N P Q : Type u
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : AddCommGroup Q
inst✝⁷ : Module R M
inst✝⁶ : Module R N
inst✝⁵ : Module R P
inst✝⁴ : Module R Q
inst✝³ : Coalgebra R M
inst✝² : Coalgebra R N
inst✝¹ : Coalgebra R P
inst✝ : Coalgebra R Q
⊢ (tensor_μ (ModuleCat R)ᵒᵖ (Opposite.op (ModuleCat.mk M), Opposite.op (ModuleCat.mk N))
          (Opposite.op (ModuleCat.mk M), Opposite.op (ModuleCat.mk N))).unop ∘ₗ
      map Coalgebra.comul Coalgebra.comul =
    ↑(tensorTensorTensorComm R M M N N) ∘ₗ map Coalgebra.comul Coalgebra.comul
tactic: dsimp [- Mon_.monMonoidalStruct_tensorObj_X, instMonoidalCategoryStruct_tensorHom,
    ModuleCat.comp_def, ModuleCat.ofHom, ModuleCat.of]
state_before: R : Type u
inst✝¹² : CommRing R
M N P Q : Type u
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : AddCommGroup Q
inst✝⁷ : Module R M
inst✝⁶ : Module R N
inst✝⁵ : Module R P
inst✝⁴ : Module R Q
inst✝³ : Coalgebra R M
inst✝² : Coalgebra R N
inst✝¹ : Coalgebra R P
inst✝ : Coalgebra R Q
⊢ (tensor_μ (ModuleCat R)ᵒᵖ (Opposite.op (ModuleCat.mk M), Opposite.op (ModuleCat.mk N))
          (Opposite.op (ModuleCat.mk M), Opposite.op (ModuleCat.mk N))).unop ∘ₗ
      map Coalgebra.comul Coalgebra.comul =
    ↑(tensorTensorTensorComm R M M N N) ∘ₗ map Coalgebra.comul Coalgebra.comul
state_after: no goals
tactic: simp only [BraidedCategory.unop_tensor_μ, tensor_μ_eq_tensorTensorTensorComm]
Theorem: BooleanRing.inf_assoc
File: Mathlib/Algebra/Ring/BooleanRing.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : BooleanRing α
inst✝¹ : BooleanRing β
inst✝ : BooleanRing γ
a b c : α
⊢ a * b * c = a * (b * c)
state_after: no goals
tactic: ring
Theorem: Ideal.map_eq_top_or_isMaximal_of_surjective
File: Mathlib/RingTheory/Ideal/Maps.lean

Proof steps:
state_before: R : Type u
S : Type v
F : Type u_1
inst✝³ : Ring R
inst✝² : Ring S
inst✝¹ : FunLike F R S
inst✝ : RingHomClass F R S
f : F
I✝ : Ideal R
hf : Function.Surjective ⇑f
I : Ideal R
H : I.IsMaximal
⊢ map f I = ⊤ ∨ (map f I).IsMaximal
state_after: R : Type u
S : Type v
F : Type u_1
inst✝³ : Ring R
inst✝² : Ring S
inst✝¹ : FunLike F R S
inst✝ : RingHomClass F R S
f : F
I✝ : Ideal R
hf : Function.Surjective ⇑f
I : Ideal R
H : I.IsMaximal
ne_top : ¬map f I = ⊤
J : Ideal S
hJ : map f I < J
⊢ J = ⊤
tactic: refine or_iff_not_imp_left.2 fun ne_top => ⟨⟨fun h => ne_top h, fun J hJ => ?_⟩⟩
Theorem: IsSMulRegular.pow_iff
File: Mathlib/Algebra/Regular/SMul.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
M : Type u_3
a b : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
n : ℕ
n0 : 0 < n
⊢ IsSMulRegular M (a ^ n) ↔ IsSMulRegular M a
state_after: R : Type u_1
S : Type u_2
M : Type u_3
a b : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
n : ℕ
n0 : 0 < n
⊢ IsSMulRegular M (a ^ n) → IsSMulRegular M a
tactic: refine ⟨?_, pow n⟩
state_before: R : Type u_1
S : Type u_2
M : Type u_3
a b : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
n : ℕ
n0 : 0 < n
⊢ IsSMulRegular M (a ^ n) → IsSMulRegular M a
state_after: R : Type u_1
S : Type u_2
M : Type u_3
a b : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
n : ℕ
n0 : 0 < n
⊢ IsSMulRegular M (a ^ n.pred • a) → IsSMulRegular M a
tactic: rw [← Nat.succ_pred_eq_of_pos n0, pow_succ, ← smul_eq_mul]
state_before: R : Type u_1
S : Type u_2
M : Type u_3
a b : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
n : ℕ
n0 : 0 < n
⊢ IsSMulRegular M (a ^ n.pred • a) → IsSMulRegular M a
state_after: no goals
tactic: exact of_smul _
Theorem: Option.map_bind'
File: Mathlib/Data/Option/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
p : α → Prop
f✝ : (a : α) → p a → β
x✝ : Option α
f : β → γ
x : Option α
g : α → Option β
⊢ Option.map f (x.bind g) = x.bind fun a => Option.map f (g a)
state_after: no goals
tactic: cases x <;> simp
Theorem: NumberField.InfinitePlace.isUnramified_smul_iff
File: Mathlib/NumberTheory/NumberField/Embeddings.lean

Proof steps:
state_before: k : Type u_1
inst✝⁷ : Field k
K : Type u_2
inst✝⁶ : Field K
F : Type u_3
inst✝⁵ : Field F
inst✝⁴ : NumberField K
inst✝³ : Algebra k K
inst✝² : Algebra k F
inst✝¹ : Algebra K F
inst✝ : IsScalarTower k K F
σ : K ≃ₐ[k] K
w : InfinitePlace K
⊢ IsUnramified k (σ • w) ↔ IsUnramified k w
state_after: no goals
tactic: rw [isUnramified_iff, isUnramified_iff, isReal_smul_iff, comap_smul,
    ← AlgEquiv.toAlgHom_toRingHom, AlgHom.comp_algebraMap]
Theorem: Profinite.NobelingProof.eval_eq_πJ
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

Proof steps:
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
l : Products I
hl : Products.isGood (π C fun x => x ∈ s) l
⊢ Products.eval C l = (πJ C s) (Products.eval (π C fun x => x ∈ s) l)
state_after: case h
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
l : Products I
hl : Products.isGood (π C fun x => x ∈ s) l
f : ↑C
⊢ (Products.eval C l) f = ((πJ C s) (Products.eval (π C fun x => x ∈ s) l)) f
tactic: ext f
Theorem: isBoundedUnder_le_finset_sup
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝¹ : LinearOrder β
inst✝ : OrderBot β
f : Filter α
F : ι → α → β
s : Finset ι
h : ∀ i ∈ s, IsBoundedUnder (fun x x_1 => x ≤ x_1) f (F i)
⊢ IsBoundedUnder (fun x x_1 => x ≤ x_1) f fun a => s.sup fun i => F i a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝¹ : LinearOrder β
inst✝ : OrderBot β
f : Filter α
F : ι → α → β
s : Finset ι
m : ι → β
hm : ∀ i ∈ s, ∀ᶠ (x : β) in Filter.map (F i) f, (fun x x_1 => x ≤ x_1) x (m i)
⊢ IsBoundedUnder (fun x x_1 => x ≤ x_1) f fun a => s.sup fun i => F i a
tactic: choose! m hm using h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝¹ : LinearOrder β
inst✝ : OrderBot β
f : Filter α
F : ι → α → β
s : Finset ι
m : ι → β
hm : ∀ i ∈ s, ∀ᶠ (x : β) in Filter.map (F i) f, (fun x x_1 => x ≤ x_1) x (m i)
⊢ IsBoundedUnder (fun x x_1 => x ≤ x_1) f fun a => s.sup fun i => F i a
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝¹ : LinearOrder β
inst✝ : OrderBot β
f : Filter α
F : ι → α → β
s : Finset ι
m : ι → β
hm : ∀ i ∈ s, ∀ᶠ (x : β) in Filter.map (F i) f, (fun x x_1 => x ≤ x_1) x (m i)
⊢ ∀ᶠ (x : β) in Filter.map (fun a => s.sup fun i => F i a) f, (fun x x_1 => x ≤ x_1) x (s.sup m)
tactic: use sup s m
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝¹ : LinearOrder β
inst✝ : OrderBot β
f : Filter α
F : ι → α → β
s : Finset ι
m : ι → β
hm : ∀ i ∈ s, ∀ᶠ (x : β) in Filter.map (F i) f, (fun x x_1 => x ≤ x_1) x (m i)
⊢ ∀ᶠ (x : β) in Filter.map (fun a => s.sup fun i => F i a) f, (fun x x_1 => x ≤ x_1) x (s.sup m)
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝¹ : LinearOrder β
inst✝ : OrderBot β
f : Filter α
F : ι → α → β
s : Finset ι
m : ι → β
hm : ∀ i ∈ s, ∀ᶠ (a : α) in f, F i a ≤ m i
⊢ ∀ᶠ (a : α) in f, (s.sup fun i => F i a) ≤ s.sup m
tactic: simp only [eventually_map] at hm ⊢
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝¹ : LinearOrder β
inst✝ : OrderBot β
f : Filter α
F : ι → α → β
s : Finset ι
m : ι → β
hm : ∀ i ∈ s, ∀ᶠ (a : α) in f, F i a ≤ m i
⊢ ∀ᶠ (a : α) in f, (s.sup fun i => F i a) ≤ s.sup m
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝¹ : LinearOrder β
inst✝ : OrderBot β
f : Filter α
F : ι → α → β
s : Finset ι
m : ι → β
hm : ∀ᶠ (x : α) in f, ∀ i ∈ s, F i x ≤ m i
⊢ ∀ᶠ (a : α) in f, (s.sup fun i => F i a) ≤ s.sup m
tactic: rw [← eventually_all_finset s] at hm
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝¹ : LinearOrder β
inst✝ : OrderBot β
f : Filter α
F : ι → α → β
s : Finset ι
m : ι → β
hm : ∀ᶠ (x : α) in f, ∀ i ∈ s, F i x ≤ m i
⊢ ∀ᶠ (a : α) in f, (s.sup fun i => F i a) ≤ s.sup m
state_after: no goals
tactic: exact hm.mono fun _ h ↦ sup_mono_fun h
Theorem: Basis.orientation_adjustToOrientation
File: Mathlib/LinearAlgebra/Orientation.lean

Proof steps:
state_before: R : Type u_1
inst✝⁵ : LinearOrderedCommRing R
M : Type u_2
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
ι : Type u_3
inst✝² : Fintype ι
inst✝¹ : DecidableEq ι
inst✝ : Nonempty ι
e : Basis ι R M
x : Orientation R M ι
⊢ (e.adjustToOrientation x).orientation = x
state_after: R : Type u_1
inst✝⁵ : LinearOrderedCommRing R
M : Type u_2
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
ι : Type u_3
inst✝² : Fintype ι
inst✝¹ : DecidableEq ι
inst✝ : Nonempty ι
e : Basis ι R M
x : Orientation R M ι
⊢ (if e.orientation = x then e else e.unitsSMul (Function.update 1 (Classical.arbitrary ι) (-1))).orientation = x
tactic: rw [adjustToOrientation]
state_before: R : Type u_1
inst✝⁵ : LinearOrderedCommRing R
M : Type u_2
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
ι : Type u_3
inst✝² : Fintype ι
inst✝¹ : DecidableEq ι
inst✝ : Nonempty ι
e : Basis ι R M
x : Orientation R M ι
⊢ (if e.orientation = x then e else e.unitsSMul (Function.update 1 (Classical.arbitrary ι) (-1))).orientation = x
state_after: case pos
R : Type u_1
inst✝⁵ : LinearOrderedCommRing R
M : Type u_2
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
ι : Type u_3
inst✝² : Fintype ι
inst✝¹ : DecidableEq ι
inst✝ : Nonempty ι
e : Basis ι R M
x : Orientation R M ι
h : e.orientation = x
⊢ e.orientation = x

case neg
R : Type u_1
inst✝⁵ : LinearOrderedCommRing R
M : Type u_2
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
ι : Type u_3
inst✝² : Fintype ι
inst✝¹ : DecidableEq ι
inst✝ : Nonempty ι
e : Basis ι R M
x : Orientation R M ι
h : ¬e.orientation = x
⊢ (e.unitsSMul (Function.update 1 (Classical.arbitrary ι) (-1))).orientation = x
tactic: split_ifs with h
Theorem: AlgebraicGeometry.Spec.map_inj
File: Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean

Proof steps:
state_before: R S : CommRingCat
φ ψ : R ⟶ S
f : Spec S ⟶ Spec R
⊢ map φ = map ψ ↔ φ = ψ
state_after: R S : CommRingCat
φ ψ : R ⟶ S
f : Spec S ⟶ Spec R
⊢ Scheme.Spec.map φ.op = Scheme.Spec.map ψ.op ↔ map φ = map ψ
tactic: rw [iff_comm, ← Quiver.Hom.op_inj.eq_iff, ← Scheme.Spec.map_injective.eq_iff]
state_before: R S : CommRingCat
φ ψ : R ⟶ S
f : Spec S ⟶ Spec R
⊢ Scheme.Spec.map φ.op = Scheme.Spec.map ψ.op ↔ map φ = map ψ
state_after: no goals
tactic: rfl
Theorem: nhdsWithin_Iio_eq_bot_iff
File: Mathlib/Topology/Order/LeftRightNhds.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
⊢ 𝓝[<] a = ⊥ ↔ IsBot a ∨ ∃ b, b ⋖ a
state_after: case h.e'_2.h.e'_2.h.e'_2.h.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
e_1✝ : α = αᵒᵈ
x✝ : α
⊢ x✝ ⋖ a ↔ toDual a ⋖ x✝
tactic: convert (config := {preTransparency := .default})
      nhdsWithin_Ioi_eq_bot_iff (a := OrderDual.toDual a) using 4
state_before: case h.e'_2.h.e'_2.h.e'_2.h.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
e_1✝ : α = αᵒᵈ
x✝ : α
⊢ x✝ ⋖ a ↔ toDual a ⋖ x✝
state_after: no goals
tactic: exact ofDual_covBy_ofDual_iff
Theorem: PMF.support_seq
File: Mathlib/Probability/ProbabilityMassFunction/Constructions.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
q : PMF (α → β)
p : PMF α
b✝ b : β
⊢ b ∈ (q.seq p).support ↔ b ∈ ⋃ f ∈ q.support, f '' p.support
state_after: no goals
tactic: simp [-mem_support_iff, seq, @eq_comm β b]
Theorem: LieDerivation.IsKilling.exists_eq_ad
File: Mathlib/Algebra/Lie/Derivation/Killing.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
inst✝⁴ : Field R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : Module.Finite R L
inst✝ : LieAlgebra.IsKilling R L
D : LieDerivation R L L
⊢ ∃ x, (ad R L) x = D
state_after: R : Type u_1
L : Type u_2
inst✝⁴ : Field R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : Module.Finite R L
inst✝ : LieAlgebra.IsKilling R L
D : LieDerivation R L L
⊢ D ∈ (ad R L).range
tactic: change D ∈ 𝕀
state_before: R : Type u_1
L : Type u_2
inst✝⁴ : Field R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : Module.Finite R L
inst✝ : LieAlgebra.IsKilling R L
D : LieDerivation R L L
⊢ D ∈ (ad R L).range
state_after: R : Type u_1
L : Type u_2
inst✝⁴ : Field R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : Module.Finite R L
inst✝ : LieAlgebra.IsKilling R L
D : LieDerivation R L L
⊢ D ∈ ⊤
tactic: rw [range_ad_eq_top R L]
state_before: R : Type u_1
L : Type u_2
inst✝⁴ : Field R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : Module.Finite R L
inst✝ : LieAlgebra.IsKilling R L
D : LieDerivation R L L
⊢ D ∈ ⊤
state_after: no goals
tactic: exact Submodule.mem_top
Theorem: ZetaAsymptotics.term_tsum_of_lt
File: Mathlib/NumberTheory/Harmonic/ZetaAsymp.lean

Proof steps:
state_before: s : ℝ
hs : 1 < s
⊢ term_tsum s = 1 / (s - 1) - 1 / s * ∑' (n : ℕ), 1 / (↑n + 1) ^ s
state_after: case ha
s : ℝ
hs : 1 < s
⊢ HasSum (fun b => term (b + 1) s) (1 / (s - 1) - 1 / s * ∑' (n : ℕ), 1 / (↑n + 1) ^ s)
tactic: apply HasSum.tsum_eq
state_before: case ha
s : ℝ
hs : 1 < s
⊢ HasSum (fun b => term (b + 1) s) (1 / (s - 1) - 1 / s * ∑' (n : ℕ), 1 / (↑n + 1) ^ s)
state_after: case ha
s : ℝ
hs : 1 < s
⊢ Tendsto (fun n => ∑ i ∈ Finset.range n, term (i + 1) s) atTop (𝓝 (1 / (s - 1) - 1 / s * ∑' (n : ℕ), 1 / (↑n + 1) ^ s))
tactic: rw [hasSum_iff_tendsto_nat_of_nonneg (fun n ↦ term_nonneg (n + 1) s)]
state_before: case ha
s : ℝ
hs : 1 < s
⊢ Tendsto (fun n => ∑ i ∈ Finset.range n, term (i + 1) s) atTop (𝓝 (1 / (s - 1) - 1 / s * ∑' (n : ℕ), 1 / (↑n + 1) ^ s))
state_after: case ha
s : ℝ
hs : 1 < s
⊢ Tendsto (fun N => term_sum s N) atTop (𝓝 (1 / (s - 1) - 1 / s * ∑' (n : ℕ), 1 / (↑n + 1) ^ s))
tactic: change Tendsto (fun N ↦ term_sum s N) atTop _
state_before: case ha
s : ℝ
hs : 1 < s
⊢ Tendsto (fun N => term_sum s N) atTop (𝓝 (1 / (s - 1) - 1 / s * ∑' (n : ℕ), 1 / (↑n + 1) ^ s))
state_after: case ha
s : ℝ
hs : 1 < s
⊢ Tendsto
    (fun N =>
      1 / (s - 1) * (1 - 1 / (↑N + 1) ^ (s - 1)) - 1 / s * (∑ n ∈ Finset.range N, 1 / (↑n + 1) ^ s - ↑N / (↑N + 1) ^ s))
    atTop (𝓝 (1 / (s - 1) - 1 / s * ∑' (n : ℕ), 1 / (↑n + 1) ^ s))
tactic: simp_rw [term_sum_of_lt _ hs]
state_before: case ha
s : ℝ
hs : 1 < s
⊢ Tendsto
    (fun N =>
      1 / (s - 1) * (1 - 1 / (↑N + 1) ^ (s - 1)) - 1 / s * (∑ n ∈ Finset.range N, 1 / (↑n + 1) ^ s - ↑N / (↑N + 1) ^ s))
    atTop (𝓝 (1 / (s - 1) - 1 / s * ∑' (n : ℕ), 1 / (↑n + 1) ^ s))
state_after: case ha.hf
s : ℝ
hs : 1 < s
⊢ Tendsto (fun x => 1 / (s - 1) * (1 - 1 / (↑x + 1) ^ (s - 1))) atTop (𝓝 (1 / (s - 1)))

case ha.hg
s : ℝ
hs : 1 < s
⊢ Tendsto (fun x => 1 / s * (∑ n ∈ Finset.range x, 1 / (↑n + 1) ^ s - ↑x / (↑x + 1) ^ s)) atTop
    (𝓝 (1 / s * ∑' (n : ℕ), 1 / (↑n + 1) ^ s))
tactic: apply Tendsto.sub
Theorem: MvPolynomial.bind₂_monomial
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 : σ →₀ ℕ
r : R
⊢ (bind₂ f) ((monomial d) r) = f r * (monomial d) 1
state_after: no goals
tactic: simp only [monomial_eq, RingHom.map_mul, bind₂_C_right, Finsupp.prod, map_prod,
    map_pow, bind₂_X_right, C_1, one_mul]
Theorem: Finset.sup'_map
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
s✝ : Finset β
H : s✝.Nonempty
f✝ : β → α
s : Finset γ
f : γ ↪ β
g : β → α
hs : (map f s).Nonempty
⊢ (map f s).sup' hs g = s.sup' ⋯ (g ∘ ⇑f)
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
s✝ : Finset β
H : s✝.Nonempty
f✝ : β → α
s : Finset γ
f : γ ↪ β
g : β → α
hs : (map f s).Nonempty
⊢ s.sup ((WithBot.some ∘ g) ∘ ⇑f) = s.sup (WithBot.some ∘ g ∘ ⇑f)
tactic: rw [← WithBot.coe_eq_coe, coe_sup', sup_map, coe_sup']
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
s✝ : Finset β
H : s✝.Nonempty
f✝ : β → α
s : Finset γ
f : γ ↪ β
g : β → α
hs : (map f s).Nonempty
⊢ s.sup ((WithBot.some ∘ g) ∘ ⇑f) = s.sup (WithBot.some ∘ g ∘ ⇑f)
state_after: no goals
tactic: rfl
Theorem: IsCompact.bddBelow
File: Mathlib/Topology/Algebra/Order/Compact.lean

Proof steps:
state_before: α✝ : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁵ : LinearOrder α
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : ClosedIicTopology α
inst✝ : Nonempty α
s : Set α
hs : IsCompact s
⊢ BddBelow s
state_after: case inl
α✝ : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁵ : LinearOrder α
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : ClosedIicTopology α
inst✝ : Nonempty α
hs : IsCompact ∅
⊢ BddBelow ∅

case inr
α✝ : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁵ : LinearOrder α
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : ClosedIicTopology α
inst✝ : Nonempty α
s : Set α
hs : IsCompact s
hne : s.Nonempty
⊢ BddBelow s
tactic: rcases s.eq_empty_or_nonempty with rfl | hne
Theorem: List.toFinset_inter
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
l✝ l'✝ : List α
a : α
l l' : List α
⊢ (l ∩ l').toFinset = l.toFinset ∩ l'.toFinset
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
l✝ l'✝ : List α
a : α
l l' : List α
a✝ : α
⊢ a✝ ∈ (l ∩ l').toFinset ↔ a✝ ∈ l.toFinset ∩ l'.toFinset
tactic: ext
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
l✝ l'✝ : List α
a : α
l l' : List α
a✝ : α
⊢ a✝ ∈ (l ∩ l').toFinset ↔ a✝ ∈ l.toFinset ∩ l'.toFinset
state_after: no goals
tactic: simp
Theorem: spectrum.hasDerivAt_resolvent
File: Mathlib/Analysis/Normed/Algebra/Spectrum.lean

Proof steps:
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedRing A
inst✝¹ : NormedAlgebra 𝕜 A
inst✝ : CompleteSpace A
a : A
k : 𝕜
hk : k ∈ ρ a
⊢ HasDerivAt (resolvent a) (-resolvent a k ^ 2) k
state_after: 𝕜 : Type u_1
A : Type u_2
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedRing A
inst✝¹ : NormedAlgebra 𝕜 A
inst✝ : CompleteSpace A
a : A
k : 𝕜
hk : k ∈ ρ a
H₁ :
  HasFDerivAt Ring.inverse (-((ContinuousLinearMap.mulLeftRight 𝕜 A) ↑(IsUnit.unit hk)⁻¹) ↑(IsUnit.unit hk)⁻¹)
    (↑ₐ k - a)
⊢ HasDerivAt (resolvent a) (-resolvent a k ^ 2) k
tactic: have H₁ : HasFDerivAt Ring.inverse _ (↑ₐ k - a) := hasFDerivAt_ring_inverse (𝕜 := 𝕜) hk.unit
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedRing A
inst✝¹ : NormedAlgebra 𝕜 A
inst✝ : CompleteSpace A
a : A
k : 𝕜
hk : k ∈ ρ a
H₁ :
  HasFDerivAt Ring.inverse (-((ContinuousLinearMap.mulLeftRight 𝕜 A) ↑(IsUnit.unit hk)⁻¹) ↑(IsUnit.unit hk)⁻¹)
    (↑ₐ k - a)
⊢ HasDerivAt (resolvent a) (-resolvent a k ^ 2) k
state_after: 𝕜 : Type u_1
A : Type u_2
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedRing A
inst✝¹ : NormedAlgebra 𝕜 A
inst✝ : CompleteSpace A
a : A
k : 𝕜
hk : k ∈ ρ a
H₁ :
  HasFDerivAt Ring.inverse (-((ContinuousLinearMap.mulLeftRight 𝕜 A) ↑(IsUnit.unit hk)⁻¹) ↑(IsUnit.unit hk)⁻¹)
    (↑ₐ k - a)
H₂ : HasDerivAt (fun k => ↑ₐ k - a) 1 k
⊢ HasDerivAt (resolvent a) (-resolvent a k ^ 2) k
tactic: have H₂ : HasDerivAt (fun k => ↑ₐ k - a) 1 k := by
    simpa using (Algebra.linearMap 𝕜 A).hasDerivAt.sub_const a
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedRing A
inst✝¹ : NormedAlgebra 𝕜 A
inst✝ : CompleteSpace A
a : A
k : 𝕜
hk : k ∈ ρ a
H₁ :
  HasFDerivAt Ring.inverse (-((ContinuousLinearMap.mulLeftRight 𝕜 A) ↑(IsUnit.unit hk)⁻¹) ↑(IsUnit.unit hk)⁻¹)
    (↑ₐ k - a)
H₂ : HasDerivAt (fun k => ↑ₐ k - a) 1 k
⊢ HasDerivAt (resolvent a) (-resolvent a k ^ 2) k
state_after: no goals
tactic: simpa [resolvent, sq, hk.unit_spec, ← Ring.inverse_unit hk.unit] using H₁.comp_hasDerivAt k H₂
Theorem: intervalIntegral.integral_hasStrictDerivAt_left
File: Mathlib/MeasureTheory/Integral/FundThmCalculus.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f : ℝ → E
c ca cb : E
l l' la la' lb lb' : Filter ℝ
lt : Filter ι
a b z : ℝ
u v ua ub va vb : ι → ℝ
inst✝¹ : FTCFilter a la la'
inst✝ : FTCFilter b lb lb'
hf : IntervalIntegrable f volume a b
hmeas : StronglyMeasurableAtFilter f (𝓝 a) volume
ha : ContinuousAt f a
⊢ HasStrictDerivAt (fun u => ∫ (x : ℝ) in u..b, f x) (-f a) a
state_after: no goals
tactic: simpa only [← integral_symm] using (integral_hasStrictDerivAt_right hf.symm hmeas ha).neg
Theorem: CategoryTheory.Projective.projective_iff_preservesEpimorphisms_preadditiveCoyoneda_obj'
File: Mathlib/CategoryTheory/Preadditive/Yoneda/Projective.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
P : C
⊢ Projective P ↔ (preadditiveCoyoneda.obj (op P)).PreservesEpimorphisms
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
P : C
⊢ (coyoneda.obj (op P)).PreservesEpimorphisms ↔ (preadditiveCoyoneda.obj (op P)).PreservesEpimorphisms
tactic: rw [projective_iff_preservesEpimorphisms_coyoneda_obj]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
P : C
⊢ (coyoneda.obj (op P)).PreservesEpimorphisms ↔ (preadditiveCoyoneda.obj (op P)).PreservesEpimorphisms
state_after: case refine_1
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
P : C
h : (preadditiveCoyoneda.obj (op P) ⋙ forget AddCommGrp).PreservesEpimorphisms
⊢ (preadditiveCoyoneda.obj (op P)).PreservesEpimorphisms

case refine_2
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
P : C
⊢ (preadditiveCoyoneda.obj (op P)).PreservesEpimorphisms → (coyoneda.obj (op P)).PreservesEpimorphisms
tactic: refine ⟨fun h : (preadditiveCoyoneda.obj (op P) ⋙
      forget AddCommGrp).PreservesEpimorphisms => ?_, ?_⟩