ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: thickenedIndicator_le_one
File: Mathlib/Topology/MetricSpace/ThickenedIndicator.lean

Proof steps:
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
δ_pos : 0 < δ
E : Set α
x : α
⊢ (thickenedIndicator δ_pos E) x ≤ 1
state_after: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
δ_pos : 0 < δ
E : Set α
x : α
⊢ (ENNReal.toNNReal ∘ thickenedIndicatorAux δ E) x ≤ 1
tactic: rw [thickenedIndicator.coeFn_eq_comp]
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
δ_pos : 0 < δ
E : Set α
x : α
⊢ (ENNReal.toNNReal ∘ thickenedIndicatorAux δ E) x ≤ 1
state_after: no goals
tactic: simpa using (toNNReal_le_toNNReal thickenedIndicatorAux_lt_top.ne one_ne_top).mpr
    (thickenedIndicatorAux_le_one δ E x)
Theorem: constant_of_derivWithin_zero
File: Mathlib/Analysis/Calculus/MeanValue.lean

Proof steps:
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → E
a b : ℝ
hdiff : DifferentiableOn ℝ f (Icc a b)
hderiv : ∀ x ∈ Ico a b, derivWithin f (Icc a b) x = 0
⊢ ∀ x ∈ Icc a b, f x = f a
state_after: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → E
a b : ℝ
hdiff : DifferentiableOn ℝ f (Icc a b)
hderiv : ∀ x ∈ Ico a b, derivWithin f (Icc a b) x = 0
H : ∀ x ∈ Ico a b, ‖derivWithin f (Icc a b) x‖ ≤ 0
⊢ ∀ x ∈ Icc a b, f x = f a
tactic: have H : ∀ x ∈ Ico a b, ‖derivWithin f (Icc a b) x‖ ≤ 0 := by
    simpa only [norm_le_zero_iff] using fun x hx => hderiv x hx
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → E
a b : ℝ
hdiff : DifferentiableOn ℝ f (Icc a b)
hderiv : ∀ x ∈ Ico a b, derivWithin f (Icc a b) x = 0
H : ∀ x ∈ Ico a b, ‖derivWithin f (Icc a b) x‖ ≤ 0
⊢ ∀ x ∈ Icc a b, f x = f a
state_after: no goals
tactic: simpa only [zero_mul, norm_le_zero_iff, sub_eq_zero] using fun x hx =>
    norm_image_sub_le_of_norm_deriv_le_segment hdiff H x hx
Theorem: CategoryTheory.Abelian.pseudoEqual_refl
File: Mathlib/CategoryTheory/Abelian/Pseudoelements.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
P : C
f : Over P
⊢ 𝟙 f.left ≫ f.hom = 𝟙 f.left ≫ f.hom
state_after: no goals
tactic: simp
Theorem: continuousMap_mem_polynomialFunctions_closure
File: Mathlib/Topology/ContinuousFunction/Weierstrass.lean

Proof steps:
state_before: a b : ℝ
f : C(↑(Set.Icc a b), ℝ)
⊢ f ∈ (polynomialFunctions (Set.Icc a b)).topologicalClosure
state_after: a b : ℝ
f : C(↑(Set.Icc a b), ℝ)
⊢ f ∈ ⊤
tactic: rw [polynomialFunctions_closure_eq_top _ _]
state_before: a b : ℝ
f : C(↑(Set.Icc a b), ℝ)
⊢ f ∈ ⊤
state_after: no goals
tactic: simp
Theorem: PMF.mem_support_bind_iff
File: Mathlib/Probability/ProbabilityMassFunction/Monad.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
f : α → PMF β
g : β → PMF γ
b : β
⊢ b ∈ (p.bind f).support ↔ ∃ a ∈ p.support, b ∈ (f a).support
state_after: no goals
tactic: simp only [support_bind, Set.mem_iUnion, Set.mem_setOf_eq, exists_prop]
Theorem: Polynomial.expand_eval
File: Mathlib/Algebra/Polynomial/Expand.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q p : ℕ
P : R[X]
r : R
⊢ eval r ((expand R p) P) = eval (r ^ p) P
state_after: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q p : ℕ
P : R[X]
r : R
f g : R[X]
hf : eval r ((expand R p) f) = eval (r ^ p) f
hg : eval r ((expand R p) g) = eval (r ^ p) g
⊢ eval r ((expand R p) (f + g)) = eval (r ^ p) (f + g)
tactic: refine Polynomial.induction_on P (fun a => by simp) (fun f g hf hg => ?_) fun n a _ => by simp
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q p : ℕ
P : R[X]
r : R
f g : R[X]
hf : eval r ((expand R p) f) = eval (r ^ p) f
hg : eval r ((expand R p) g) = eval (r ^ p) g
⊢ eval r ((expand R p) (f + g)) = eval (r ^ p) (f + g)
state_after: no goals
tactic: rw [map_add, eval_add, eval_add, hf, hg]
Theorem: freeGroupEquivCoprodI_apply
File: Mathlib/GroupTheory/CoprodI.lean

Proof steps:
state_before: ι✝ : Type u_1
M : ι✝ → Type u_2
inst✝¹ : (i : ι✝) → Monoid (M i)
N : Type u_3
inst✝ : Monoid N
ι : Type u_1
⊢ FreeGroup ι ≃* CoprodI fun x => FreeGroup Unit
state_after: case refine_1
ι✝ : Type u_1
M : ι✝ → Type u_2
inst✝¹ : (i : ι✝) → Monoid (M i)
N : Type u_3
inst✝ : Monoid N
ι : Type u_1
⊢ FreeGroup ι →* CoprodI fun x => FreeGroup Unit

case refine_2
ι✝ : Type u_1
M : ι✝ → Type u_2
inst✝¹ : (i : ι✝) → Monoid (M i)
N : Type u_3
inst✝ : Monoid N
ι : Type u_1
⊢ (CoprodI fun x => FreeGroup Unit) →* FreeGroup ι

case refine_3
ι✝ : Type u_1
M : ι✝ → Type u_2
inst✝¹ : (i : ι✝) → Monoid (M i)
N : Type u_3
inst✝ : Monoid N
ι : Type u_1
⊢ ?refine_2.comp ?refine_1 = MonoidHom.id (FreeGroup ι)

case refine_4
ι✝ : Type u_1
M : ι✝ → Type u_2
inst✝¹ : (i : ι✝) → Monoid (M i)
N : Type u_3
inst✝ : Monoid N
ι : Type u_1
⊢ ?refine_1.comp ?refine_2 = MonoidHom.id (CoprodI fun x => FreeGroup Unit)
tactic: refine MonoidHom.toMulEquiv ?_ ?_ ?_ ?_
Theorem: measurable_const_vadd_iff
File: Mathlib/MeasureTheory/Group/Arithmetic.lean

Proof steps:
state_before: α✝ : Type u_1
M : Type u_2
β : Type u_3
α : Type u_4
inst✝⁹ : MeasurableSpace M
inst✝⁸ : MeasurableSpace β
inst✝⁷ : Monoid M
inst✝⁶ : MulAction M β
inst✝⁵ : MeasurableSMul M β
inst✝⁴ : MeasurableSpace α
f : α → β
μ : Measure α
G : Type u_5
inst✝³ : Group G
inst✝² : MeasurableSpace G
inst✝¹ : MulAction G β
inst✝ : MeasurableSMul G β
c : G
h : Measurable fun x => c • f x
⊢ Measurable f
state_after: no goals
tactic: simpa only [inv_smul_smul] using h.const_smul' c⁻¹
Theorem: Ideal.mul_sup_eq_of_coprime_left
File: Mathlib/RingTheory/Ideal/Operations.lean

Proof steps:
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
h : I ⊔ J = ⊤
⊢ I * K ⊔ J = K ⊔ J
state_after: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
h : J ⊔ I = ⊤
⊢ I * K ⊔ J = K ⊔ J
tactic: rw [sup_comm] at h
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
h : J ⊔ I = ⊤
⊢ I * K ⊔ J = K ⊔ J
state_after: no goals
tactic: rw [sup_comm, sup_mul_eq_of_coprime_left h, sup_comm]
Theorem: Fin.prod_cons
File: Mathlib/Algebra/BigOperators/Fin.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
n : ℕ
x : β
f : Fin n → β
⊢ ∏ i : Fin n.succ, cons x f i = x * ∏ i : Fin n, f i
state_after: no goals
tactic: simp_rw [prod_univ_succ, cons_zero, cons_succ]
Theorem: Function.Periodic.div
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✝¹ : Add α
inst✝ : Div β
hf : Periodic f c
hg : Periodic g c
⊢ Periodic (f / g) c
state_after: no goals
tactic: simp_all
Theorem: OpenEmbedding.tendsto_nhds_iff'
File: Mathlib/Topology/Maps/Basic.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hf : OpenEmbedding f
l : Filter Z
x : X
⊢ Tendsto (g ∘ f) (𝓝 x) l ↔ Tendsto g (𝓝 (f x)) l
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hf : OpenEmbedding f
l : Filter Z
x : X
⊢ map g (𝓝 (f x)) ≤ l ↔ Tendsto g (𝓝 (f x)) l
tactic: rw [Tendsto, ← map_map, hf.map_nhds_eq]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hf : OpenEmbedding f
l : Filter Z
x : X
⊢ map g (𝓝 (f x)) ≤ l ↔ Tendsto g (𝓝 (f x)) l
state_after: no goals
tactic: rfl
Theorem: Finset.coe_sup'
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.sup' H f) = s.sup (WithBot.some ∘ f)
state_after: no goals
tactic: rw [sup', WithBot.coe_unbot]
Theorem: HurwitzKernelBounds.f_int_negSucc
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/Bounds.lean

Proof steps:
state_before: k : ℕ
a : ℝ
ha : a ≤ 1
t : ℝ
n : ℕ
⊢ f_int k a t (Int.negSucc n) = f_nat k (1 - a) t n
state_after: k : ℕ
a : ℝ
ha : a ≤ 1
t : ℝ
n : ℕ
this : ↑(Int.negSucc n) + a = -(↑n + (1 - a))
⊢ f_int k a t (Int.negSucc n) = f_nat k (1 - a) t n
tactic: have : (Int.negSucc n) + a = -(n + (1 - a)) := by { push_cast; ring }
state_before: k : ℕ
a : ℝ
ha : a ≤ 1
t : ℝ
n : ℕ
this : ↑(Int.negSucc n) + a = -(↑n + (1 - a))
⊢ f_int k a t (Int.negSucc n) = f_nat k (1 - a) t n
state_after: no goals
tactic: rw [f_int, f_nat, this, abs_neg, neg_sq, abs_of_nonneg (by linarith)]
Theorem: TypeVec.splitFun_inj
File: Mathlib/Data/TypeVec.lean

Proof steps:
state_before: n : ℕ
α : TypeVec.{u_1} (n + 1)
α' : TypeVec.{u_2} (n + 1)
f f' : α.drop ⟹ α'.drop
g g' : α.last → α'.last
H : splitFun f g = splitFun f' g'
⊢ f = f' ∧ g = g'
state_after: n : ℕ
α : TypeVec.{u_1} (n + 1)
α' : TypeVec.{u_2} (n + 1)
f f' : α.drop ⟹ α'.drop
g g' : α.last → α'.last
H : splitFun f g = splitFun f' g'
⊢ dropFun (splitFun f' g') = f' ∧ lastFun (splitFun f' g') = g'
tactic: rw [← dropFun_splitFun f g, H, ← lastFun_splitFun f g, H]
state_before: n : ℕ
α : TypeVec.{u_1} (n + 1)
α' : TypeVec.{u_2} (n + 1)
f f' : α.drop ⟹ α'.drop
g g' : α.last → α'.last
H : splitFun f g = splitFun f' g'
⊢ dropFun (splitFun f' g') = f' ∧ lastFun (splitFun f' g') = g'
state_after: no goals
tactic: simp
Theorem: setIntegral_withDensity_eq_setIntegral_smul
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝⁷ : MeasurableSpace X
μ : Measure X
𝕜 : Type u_5
inst✝⁶ : RCLike 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
p : ℝ≥0∞
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℝ F
f : X → ℝ≥0
f_meas : Measurable f
g : X → E
s : Set X
hs : MeasurableSet s
⊢ (∫ (x : X) in s, g x ∂μ.withDensity fun x => ↑(f x)) = ∫ (x : X) in s, f x • g x ∂μ
state_after: no goals
tactic: rw [restrict_withDensity hs, integral_withDensity_eq_integral_smul f_meas]
Theorem: EReal.range_coe_eq_Ioo
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: ⊢ range Real.toEReal = Ioo ⊥ ⊤
state_after: case h
x : EReal
⊢ x ∈ range Real.toEReal ↔ x ∈ Ioo ⊥ ⊤
tactic: ext x
state_before: case h
x : EReal
⊢ x ∈ range Real.toEReal ↔ x ∈ Ioo ⊥ ⊤
state_after: no goals
tactic: induction x <;> simp
Theorem: isAddUnit_iff_eq_zero
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝¹ : Monoid M
a b : M
inst✝ : Unique Mˣ
x : M
x✝ : IsUnit x
u : Mˣ
hu : ↑u = x
⊢ x = 1
state_after: no goals
tactic: rw [← hu, Subsingleton.elim u 1, Units.val_one]
Theorem: mul_inv_le_one_of_le
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h : a ≤ b
hb : 0 ≤ b
⊢ a * b⁻¹ ≤ 1
state_after: no goals
tactic: simpa only [← div_eq_mul_inv] using div_le_one_of_le h hb
Theorem: CategoryTheory.Functor.FullyFaithful.isoEquiv_symm_apply
File: Mathlib/CategoryTheory/Functor/FullyFaithful.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u_1
inst✝ : Category.{?u.11481, u_1} E
X✝¹ Y✝¹ : C
F : C ⥤ D
X✝ Y✝ Z : C
hF : F.FullyFaithful
X Y : C
⊢ Function.LeftInverse hF.preimageIso F.mapIso
state_after: no goals
tactic: aesop_cat
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u_1
inst✝ : Category.{?u.11481, u_1} E
X✝¹ Y✝¹ : C
F : C ⥤ D
X✝ Y✝ Z : C
hF : F.FullyFaithful
X Y : C
⊢ Function.RightInverse hF.preimageIso F.mapIso
state_after: no goals
tactic: aesop_cat
Theorem: Isometry.right_inv
File: Mathlib/Topology/MetricSpace/Isometry.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
f✝ : α → β
x✝ y✝ z : α
s : Set α
f : α → β
g : β → α
h : Isometry f
hg : Function.RightInverse g f
x y : β
⊢ edist (g x) (g y) = edist x y
state_after: no goals
tactic: rw [← h, hg _, hg _]
Theorem: GradedAlgebra.proj_recompose
File: Mathlib/RingTheory/GradedAlgebra/Basic.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
A : Type u_3
σ : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : AddMonoid ι
inst✝³ : CommSemiring R
inst✝² : Semiring A
inst✝¹ : Algebra R A
𝒜 : ι → Submodule R A
inst✝ : GradedAlgebra 𝒜
a : ⨁ (i : ι), ↥(𝒜 i)
i : ι
⊢ (proj 𝒜 i) ((decompose 𝒜).symm a) = (decompose 𝒜).symm ((of (fun i => ↥(𝒜 i)) i) (a i))
state_after: no goals
tactic: rw [GradedAlgebra.proj_apply, decompose_symm_of, Equiv.apply_symm_apply]
Theorem: Sum.LiftRel.mono
File: .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean

Proof steps:
state_before: α✝¹ : Type u_1
α✝ : Type u_2
r₁ r₂ : α✝¹ → α✝ → Prop
β✝¹ : Type u_3
β✝ : Type u_4
s₁ s₂ : β✝¹ → β✝ → Prop
x : α✝¹ ⊕ β✝¹
y : α✝ ⊕ β✝
hr : ∀ (a : α✝¹) (b : α✝), r₁ a b → r₂ a b
hs : ∀ (a : β✝¹) (b : β✝), s₁ a b → s₂ a b
h : LiftRel r₁ s₁ x y
⊢ LiftRel r₂ s₂ x y
state_after: case inl
α✝¹ : Type u_1
α✝ : Type u_2
r₁ r₂ : α✝¹ → α✝ → Prop
β✝¹ : Type u_3
β✝ : Type u_4
s₁ s₂ : β✝¹ → β✝ → Prop
hr : ∀ (a : α✝¹) (b : α✝), r₁ a b → r₂ a b
hs : ∀ (a : β✝¹) (b : β✝), s₁ a b → s₂ a b
a✝¹ : α✝¹
c✝ : α✝
a✝ : r₁ a✝¹ c✝
⊢ LiftRel r₂ s₂ (inl a✝¹) (inl c✝)

case inr
α✝¹ : Type u_1
α✝ : Type u_2
r₁ r₂ : α✝¹ → α✝ → Prop
β✝¹ : Type u_3
β✝ : Type u_4
s₁ s₂ : β✝¹ → β✝ → Prop
hr : ∀ (a : α✝¹) (b : α✝), r₁ a b → r₂ a b
hs : ∀ (a : β✝¹) (b : β✝), s₁ a b → s₂ a b
b✝ : β✝¹
d✝ : β✝
a✝ : s₁ b✝ d✝
⊢ LiftRel r₂ s₂ (inr b✝) (inr d✝)
tactic: cases h
Theorem: CategoryTheory.Subobject.pullback_id
File: Mathlib/CategoryTheory/Subobject/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
x : Subobject X
⊢ (pullback (𝟙 X)).obj x = x
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
f : MonoOver X
⊢ (pullback (𝟙 X)).obj (Quotient.mk'' f) = Quotient.mk'' f
tactic: induction' x using Quotient.inductionOn' with f
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
f : MonoOver X
⊢ (pullback (𝟙 X)).obj (Quotient.mk'' f) = Quotient.mk'' f
state_after: no goals
tactic: exact Quotient.sound ⟨MonoOver.pullbackId.app f⟩
Theorem: HasDerivWithinAt.div
File: Mathlib/Analysis/Calculus/Deriv/Inv.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
𝕜' : Type u_1
inst✝¹ : NontriviallyNormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
c d : 𝕜 → 𝕜'
c' d' : 𝕜'
hc : HasDerivWithinAt c c' s x
hd : HasDerivWithinAt d d' s x
hx : d x ≠ 0
⊢ HasDerivWithinAt (fun y => c y / d y) ((c' * d x - c x * d') / d x ^ 2) s x
state_after: case h.e'_6
𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
𝕜' : Type u_1
inst✝¹ : NontriviallyNormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
c d : 𝕜 → 𝕜'
c' d' : 𝕜'
hc : HasDerivWithinAt c c' s x
hd : HasDerivWithinAt d d' s x
hx : d x ≠ 0
⊢ (fun y => c y / d y) = fun y => c y * ((fun y => y⁻¹) ∘ d) y

case h.e'_7
𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
𝕜' : Type u_1
inst✝¹ : NontriviallyNormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
c d : 𝕜 → 𝕜'
c' d' : 𝕜'
hc : HasDerivWithinAt c c' s x
hd : HasDerivWithinAt d d' s x
hx : d x ≠ 0
⊢ (c' * d x - c x * d') / d x ^ 2 = c' * ((fun y => y⁻¹) ∘ d) x + c x * (-(d x ^ 2)⁻¹ * d')
tactic: convert hc.mul ((hasDerivAt_inv hx).comp_hasDerivWithinAt x hd) using 1
Theorem: Real.expNear_sub
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: n : ℕ
x r₁ r₂ : ℝ
⊢ expNear n x r₁ - expNear n x r₂ = x ^ n / ↑n.factorial * (r₁ - r₂)
state_after: no goals
tactic: simp [expNear, mul_sub]
Theorem: MeasureTheory.limsup_ae_eq_of_forall_ae_eq
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
s : ℕ → Set α
t : Set α
h : ∀ (n : ℕ), s n =ᶠ[ae μ] t
⊢ limsup s atTop =ᶠ[ae μ] t
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
s : ℕ → Set α
t : Set α
h : ∀ (n : ℕ), μ (s n \ t) = 0 ∧ μ (t \ s n) = 0
⊢ μ (limsup s atTop \ t) = 0 ∧ μ (t \ limsup s atTop) = 0
tactic: simp_rw [ae_eq_set] at h ⊢
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
s : ℕ → Set α
t : Set α
h : ∀ (n : ℕ), μ (s n \ t) = 0 ∧ μ (t \ s n) = 0
⊢ μ (limsup s atTop \ t) = 0 ∧ μ (t \ limsup s atTop) = 0
state_after: case left
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
s : ℕ → Set α
t : Set α
h : ∀ (n : ℕ), μ (s n \ t) = 0 ∧ μ (t \ s n) = 0
⊢ μ (limsup s atTop \ t) = 0

case right
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
s : ℕ → Set α
t : Set α
h : ∀ (n : ℕ), μ (s n \ t) = 0 ∧ μ (t \ s n) = 0
⊢ μ (t \ limsup s atTop) = 0
tactic: constructor
Theorem: Polynomial.cyclotomic_eq_minpoly
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Roots.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
n✝ n : ℕ
K : Type u_2
inst✝¹ : Field K
μ : K
h : IsPrimitiveRoot μ n
hpos : 0 < n
inst✝ : CharZero K
⊢ cyclotomic n ℤ = minpoly ℤ μ
state_after: R : Type u_1
inst✝² : CommRing R
n✝ n : ℕ
K : Type u_2
inst✝¹ : Field K
μ : K
h : IsPrimitiveRoot μ n
hpos : 0 < n
inst✝ : CharZero K
⊢ (cyclotomic n ℤ).natDegree ≤ (minpoly ℤ μ).natDegree
tactic: refine eq_of_monic_of_dvd_of_natDegree_le (minpoly.monic (IsPrimitiveRoot.isIntegral h hpos))
    (cyclotomic.monic n ℤ) (h.minpoly_dvd_cyclotomic hpos) ?_
state_before: R : Type u_1
inst✝² : CommRing R
n✝ n : ℕ
K : Type u_2
inst✝¹ : Field K
μ : K
h : IsPrimitiveRoot μ n
hpos : 0 < n
inst✝ : CharZero K
⊢ (cyclotomic n ℤ).natDegree ≤ (minpoly ℤ μ).natDegree
state_after: no goals
tactic: simpa [natDegree_cyclotomic n ℤ] using totient_le_degree_minpoly h
Theorem: CategoryTheory.shiftFunctor_of_induced
File: Mathlib/CategoryTheory/Shift/Induced.lean

Proof steps:
state_before: C : Type u_4
D : Type u_1
inst✝⁵ : Category.{u_5, u_4} C
inst✝⁴ : Category.{u_2, u_1} D
F : C ⥤ D
A : Type u_3
inst✝³ : AddMonoid A
inst✝² : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
inst✝¹ : ((whiskeringLeft C D D).obj F).Full
inst✝ : ((whiskeringLeft C D D).obj F).Faithful
a : A
⊢ shiftFunctor D a = s a
state_after: no goals
tactic: rfl
Theorem: tsub_le_tsub_iff_right
File: Mathlib/Algebra/Order/Sub/Canonical.lean

Proof steps:
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
h : c ≤ b
⊢ a - c ≤ b - c ↔ a ≤ b
state_after: no goals
tactic: rw [tsub_le_iff_right, tsub_add_cancel_of_le h]
Theorem: Batteries.AssocList.toList_modify
File: .lake/packages/batteries/Batteries/Data/AssocList.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f : α → β → β
inst✝ : BEq α
a : α
l : AssocList α β
⊢ (modify a f l).toList =
    List.replaceF
      (fun x =>
        match x with
        | (k, v) => bif k == a then some (a, f k v) else none)
      l.toList
state_after: α : Type u_1
β : Type u_2
f : α → β → β
inst✝ : BEq α
a : α
l : AssocList α β
⊢ (modify a f l).toList =
    List.replaceF
      (fun x =>
        match x.fst == a with
        | true => some (a, f x.fst x.snd)
        | false => none)
      l.toList
tactic: simp [cond]
state_before: α : Type u_1
β : Type u_2
f : α → β → β
inst✝ : BEq α
a : α
l : AssocList α β
⊢ (modify a f l).toList =
    List.replaceF
      (fun x =>
        match x.fst == a with
        | true => some (a, f x.fst x.snd)
        | false => none)
      l.toList
state_after: no goals
tactic: induction l with simp [List.replaceF]
  | cons k v es ih => cases k == a <;> simp [ih]
Theorem: AlgebraicTopology.DoldKan.Γ₀.Obj.Termwise.mapMono_id
File: Mathlib/AlgebraicTopology/DoldKan/FunctorGamma.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
⊢ mapMono K (𝟙 Δ) = 𝟙 (K.X Δ.len)
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
⊢ (if h : Δ = Δ then eqToHom ⋯ else if h : Isδ₀ (𝟙 Δ) then K.d Δ.len Δ.len else 0) = 𝟙 (K.X Δ.len)
tactic: unfold mapMono
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
⊢ (if h : Δ = Δ then eqToHom ⋯ else if h : Isδ₀ (𝟙 Δ) then K.d Δ.len Δ.len else 0) = 𝟙 (K.X Δ.len)
state_after: no goals
tactic: simp only [eq_self_iff_true, eqToHom_refl, dite_eq_ite, if_true]
Theorem: ArithmeticFunction.moebius_apply_one
File: Mathlib/NumberTheory/ArithmeticFunction.lean

Proof steps:
state_before: R : Type u_1
⊢ μ 1 = 1
state_after: no goals
tactic: simp
Theorem: GenContFract.of_h_eq_intFractPair_seq1_fst_b
File: Mathlib/Algebra/ContinuedFractions/Computation/Translations.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
⊢ (of v).h = ↑(IntFractPair.seq1 v).1.b
state_after: case mk
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
fst✝ : IntFractPair K
snd✝ : Stream'.Seq (IntFractPair K)
aux_seq_eq : IntFractPair.seq1 v = (fst✝, snd✝)
⊢ (of v).h = ↑(fst✝, snd✝).1.b
tactic: cases aux_seq_eq : IntFractPair.seq1 v
state_before: case mk
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
fst✝ : IntFractPair K
snd✝ : Stream'.Seq (IntFractPair K)
aux_seq_eq : IntFractPair.seq1 v = (fst✝, snd✝)
⊢ (of v).h = ↑(fst✝, snd✝).1.b
state_after: no goals
tactic: simp [of, aux_seq_eq]