ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ContextFreeGrammar.reverse_mem_language_of_mem_reverse_language
File: Mathlib/Computability/ContextFreeGrammar.lean

Proof steps:
state_before: T : Type uT
g : ContextFreeGrammar T
w : List T
hgw : w ∈ g.reverse.language
⊢ w.reverse ∈ g.language
state_after: case a
T : Type uT
g : ContextFreeGrammar T
w : List T
hgw : w ∈ g.reverse.language
⊢ w.reverse ∈ g.language ↔ g.Derives [Symbol.nonterminal g.initial] (List.map Symbol.terminal w).reverse
tactic: convert g.reverse_derives hgw
state_before: case a
T : Type uT
g : ContextFreeGrammar T
w : List T
hgw : w ∈ g.reverse.language
⊢ w.reverse ∈ g.language ↔ g.Derives [Symbol.nonterminal g.initial] (List.map Symbol.terminal w).reverse
state_after: no goals
tactic: simp [List.map_reverse]
Theorem: CategoryTheory.Limits.PullbackCone.op_inr
File: Mathlib/CategoryTheory/Limits/Opposites.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
c : PullbackCone f g
⊢ c.op.inr = c.snd.op
state_after: no goals
tactic: aesop_cat
Theorem: spectrum.algebraMap_eq_of_mem
File: Mathlib/Analysis/Normed/Algebra/Spectrum.lean

Proof steps:
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝¹ : NormedRing A
inst✝ : NormedAlgebra ℂ A
hA : ∀ {a : A}, IsUnit a ↔ a ≠ 0
a : A
z : ℂ
h : z ∈ σ a
⊢ (algebraMap ℂ A) z = a
state_after: no goals
tactic: rwa [mem_iff, hA, Classical.not_not, sub_eq_zero] at h
Theorem: LieIdeal.map_comap_eq
File: Mathlib/Algebra/Lie/Submodule.lean

Proof steps:
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
h : f.IsIdealMorphism
⊢ map f (comap f J) = f.idealRange ⊓ J
state_after: case a
R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
h : f.IsIdealMorphism
⊢ map f (comap f J) ≤ f.idealRange ⊓ J

case a
R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
h : f.IsIdealMorphism
⊢ f.idealRange ⊓ J ≤ map f (comap f J)
tactic: apply le_antisymm
Theorem: Nat.testBit_two_pow_self
File: Mathlib/Data/Nat/Bitwise.lean

Proof steps:
state_before: n : ℕ
⊢ (2 ^ n).testBit n = true
state_after: n : ℕ
⊢ (1 &&& 1 != 0) = true
tactic: rw [testBit, shiftRight_eq_div_pow, Nat.div_self (Nat.pow_pos Nat.zero_lt_two)]
state_before: n : ℕ
⊢ (1 &&& 1 != 0) = true
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Limits.Cocone.fromStructuredArrow_map_hom
File: Mathlib/CategoryTheory/Limits/ConeCategory.lean

Proof steps:
state_before: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
X✝ Y✝ : StructuredArrow F (const J)
f : X✝ ⟶ Y✝
j : J
⊢ ((fun c => { pt := c.right, ι := c.hom }) X✝).ι.app j ≫ f.right =
    ((fun c => { pt := c.right, ι := c.hom }) Y✝).ι.app j
state_after: case h.e'_3.h.h.e'_7.h
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
X✝ Y✝ : StructuredArrow F (const J)
f : X✝ ⟶ Y✝
j : J
e_1✝ :
  (F.obj j ⟶ ((fun c => { pt := c.right, ι := c.hom }) Y✝).pt) =
    (((fromPUnit F).obj X✝.left).obj j ⟶ ((const J).obj Y✝.right).obj j)
e_5✝ : F = (fromPUnit F).obj X✝.left
⊢ ((fun c => { pt := c.right, ι := c.hom }) Y✝).ι = (fromPUnit F).map f.left ≫ Y✝.hom
tactic: convert (congr_fun (congr_arg NatTrans.app f.w) j).symm
state_before: case h.e'_3.h.h.e'_7.h
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
X✝ Y✝ : StructuredArrow F (const J)
f : X✝ ⟶ Y✝
j : J
e_1✝ :
  (F.obj j ⟶ ((fun c => { pt := c.right, ι := c.hom }) Y✝).pt) =
    (((fromPUnit F).obj X✝.left).obj j ⟶ ((const J).obj Y✝.right).obj j)
e_5✝ : F = (fromPUnit F).obj X✝.left
⊢ ((fun c => { pt := c.right, ι := c.hom }) Y✝).ι = (fromPUnit F).map f.left ≫ Y✝.hom
state_after: case h.e'_3.h.h.e'_7.h
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
X✝ Y✝ : StructuredArrow F (const J)
f : X✝ ⟶ Y✝
j : J
e_1✝ :
  (F.obj j ⟶ ((fun c => { pt := c.right, ι := c.hom }) Y✝).pt) =
    (((fromPUnit F).obj X✝.left).obj j ⟶ ((const J).obj Y✝.right).obj j)
e_5✝ : F = (fromPUnit F).obj X✝.left
⊢ Y✝.hom = 𝟙 F ≫ Y✝.hom
tactic: dsimp
state_before: case h.e'_3.h.h.e'_7.h
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
X✝ Y✝ : StructuredArrow F (const J)
f : X✝ ⟶ Y✝
j : J
e_1✝ :
  (F.obj j ⟶ ((fun c => { pt := c.right, ι := c.hom }) Y✝).pt) =
    (((fromPUnit F).obj X✝.left).obj j ⟶ ((const J).obj Y✝.right).obj j)
e_5✝ : F = (fromPUnit F).obj X✝.left
⊢ Y✝.hom = 𝟙 F ≫ Y✝.hom
state_after: no goals
tactic: simp
Theorem: HomologicalComplex.opcyclesToCycles_homologyπ
File: Mathlib/Algebra/Homology/HomologySequence.lean

Proof steps:
state_before: C : Type u_1
ι : Type u_2
inst✝⁵ : Category.{u_3, u_1} C
inst✝⁴ : HasZeroMorphisms C
c : ComplexShape ι
K L : HomologicalComplex C c
φ : K ⟶ L
i j : ι
inst✝³ : K.HasHomology i
inst✝² : K.HasHomology j
inst✝¹ : L.HasHomology i
inst✝ : L.HasHomology j
⊢ K.opcyclesToCycles i j ≫ K.homologyπ j = 0
state_after: no goals
tactic: simp only [← cancel_epi (K.pOpcycles i),
    pOpcycles_opcyclesToCycles_assoc, toCycles_comp_homologyπ, comp_zero]
Theorem: PartialHomeomorph.ofSet_univ_eq_refl
File: Mathlib/Topology/PartialHomeomorph.lean

Proof steps:
state_before: X : Type u_1
X' : Type u_2
Y : Type u_3
Y' : Type u_4
Z : Type u_5
Z' : Type u_6
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace X'
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Y'
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
e : PartialHomeomorph X Y
s : Set X
hs : IsOpen s
⊢ ofSet univ ⋯ = PartialHomeomorph.refl X
state_after: no goals
tactic: ext <;> simp
Theorem: Fin.dist_insertNth_insertNth
File: Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
inst✝³ : PseudoMetricSpace α✝
π : β → Type u_3
inst✝² : Fintype β
inst✝¹ : (b : β) → PseudoMetricSpace (π b)
n : ℕ
α : Fin (n + 1) → Type u_4
inst✝ : (i : Fin (n + 1)) → PseudoMetricSpace (α i)
i : Fin (n + 1)
x y : α i
f g : (j : Fin n) → α (i.succAbove j)
⊢ dist (i.insertNth x f) (i.insertNth y g) = max (dist x y) (dist f g)
state_after: no goals
tactic: simp only [dist_nndist, Fin.nndist_insertNth_insertNth, NNReal.coe_max]
Theorem: sub_add_eq_sub_sub
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionCommMonoid α
a b c d : α
⊢ a / (b * c) = a / b / c
state_after: no goals
tactic: simp
Theorem: commutatorElement_inv
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
⊢ ⁅g₁, g₂⁆⁻¹ = ⁅g₂, g₁⁆
state_after: no goals
tactic: simp_rw [commutatorElement_def, mul_inv_rev, inv_inv, mul_assoc]
Theorem: zsmul_eq_zero_iff_modEq
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Group G
inst✝ : Finite G
x y : G
n : ℤ
⊢ x ^ n = 1 ↔ n ≡ 0 [ZMOD ↑(orderOf x)]
state_after: no goals
tactic: rw [Int.modEq_zero_iff_dvd, orderOf_dvd_iff_zpow_eq_one]
Theorem: AddSubmonoid.LocalizationMap.map_map
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝⁵ : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝⁴ : CommMonoid N
P : Type u_3
inst✝³ : CommMonoid P
f : S.LocalizationMap N
g : M →* P
hg : ∀ (y : ↥S), IsUnit (g ↑y)
T : Submonoid P
hy : ∀ (y : ↥S), g ↑y ∈ T
Q : Type u_4
inst✝² : CommMonoid Q
k : T.LocalizationMap Q
A : Type u_5
inst✝¹ : CommMonoid A
U : Submonoid A
R : Type u_6
inst✝ : CommMonoid R
j : U.LocalizationMap R
l : P →* A
hl : ∀ (w : ↥T), l ↑w ∈ U
x : N
⊢ (k.map hl j) ((f.map hy k) x) = (f.map ⋯ j) x
state_after: M : Type u_1
inst✝⁵ : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝⁴ : CommMonoid N
P : Type u_3
inst✝³ : CommMonoid P
f : S.LocalizationMap N
g : M →* P
hg : ∀ (y : ↥S), IsUnit (g ↑y)
T : Submonoid P
hy : ∀ (y : ↥S), g ↑y ∈ T
Q : Type u_4
inst✝² : CommMonoid Q
k : T.LocalizationMap Q
A : Type u_5
inst✝¹ : CommMonoid A
U : Submonoid A
R : Type u_6
inst✝ : CommMonoid R
j : U.LocalizationMap R
l : P →* A
hl : ∀ (w : ↥T), l ↑w ∈ U
x : N
⊢ (k.map hl j) ((f.map hy k) x) = ((k.map hl j).comp (f.map hy k)) x
tactic: rw [← @map_comp_map M _ S N _ P _ f g T hy Q _ k A _ U R _ j l hl]
state_before: M : Type u_1
inst✝⁵ : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝⁴ : CommMonoid N
P : Type u_3
inst✝³ : CommMonoid P
f : S.LocalizationMap N
g : M →* P
hg : ∀ (y : ↥S), IsUnit (g ↑y)
T : Submonoid P
hy : ∀ (y : ↥S), g ↑y ∈ T
Q : Type u_4
inst✝² : CommMonoid Q
k : T.LocalizationMap Q
A : Type u_5
inst✝¹ : CommMonoid A
U : Submonoid A
R : Type u_6
inst✝ : CommMonoid R
j : U.LocalizationMap R
l : P →* A
hl : ∀ (w : ↥T), l ↑w ∈ U
x : N
⊢ (k.map hl j) ((f.map hy k) x) = ((k.map hl j).comp (f.map hy k)) x
state_after: no goals
tactic: simp only [MonoidHom.coe_comp, comp_apply]
Theorem: PiLp.nnnorm_equiv_symm_const
File: Mathlib/Analysis/Normed/Lp/PiLp.lean

Proof steps:
state_before: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝⁷ : Fact (1 ≤ p)
inst✝⁶ : Fintype ι
inst✝⁵ : Semiring 𝕜
inst✝⁴ : (i : ι) → SeminormedAddCommGroup (α i)
inst✝³ : (i : ι) → SeminormedAddCommGroup (β✝ i)
inst✝² : (i : ι) → Module 𝕜 (α i)
inst✝¹ : (i : ι) → Module 𝕜 (β✝ i)
c : 𝕜
β : Type u_5
inst✝ : SeminormedAddCommGroup β
hp : p ≠ ⊤
b : β
⊢ ‖(WithLp.equiv p (ι → β)).symm (Function.const ι b)‖₊ = ↑(Fintype.card ι) ^ (1 / p).toReal * ‖b‖₊
state_after: case inl
p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝⁷ : Fact (1 ≤ p)
inst✝⁶ : Fintype ι
inst✝⁵ : Semiring 𝕜
inst✝⁴ : (i : ι) → SeminormedAddCommGroup (α i)
inst✝³ : (i : ι) → SeminormedAddCommGroup (β✝ i)
inst✝² : (i : ι) → Module 𝕜 (α i)
inst✝¹ : (i : ι) → Module 𝕜 (β✝ i)
c : 𝕜
β : Type u_5
inst✝ : SeminormedAddCommGroup β
hp : p ≠ ⊤
b : β
h : p = ⊤
⊢ ‖(WithLp.equiv p (ι → β)).symm (Function.const ι b)‖₊ = ↑(Fintype.card ι) ^ (1 / p).toReal * ‖b‖₊

case inr
p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝⁷ : Fact (1 ≤ p)
inst✝⁶ : Fintype ι
inst✝⁵ : Semiring 𝕜
inst✝⁴ : (i : ι) → SeminormedAddCommGroup (α i)
inst✝³ : (i : ι) → SeminormedAddCommGroup (β✝ i)
inst✝² : (i : ι) → Module 𝕜 (α i)
inst✝¹ : (i : ι) → Module 𝕜 (β✝ i)
c : 𝕜
β : Type u_5
inst✝ : SeminormedAddCommGroup β
hp : p ≠ ⊤
b : β
h : 1 ≤ p.toReal
⊢ ‖(WithLp.equiv p (ι → β)).symm (Function.const ι b)‖₊ = ↑(Fintype.card ι) ^ (1 / p).toReal * ‖b‖₊
tactic: rcases p.dichotomy with (h | h)
Theorem: Multiset.toList_eq_singleton_iff
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
a : α
m : Multiset α
⊢ m.toList = [a] ↔ m = {a}
state_after: no goals
tactic: rw [← perm_singleton, ← coe_eq_coe, coe_toList, coe_singleton]
Theorem: AddSubgroup.quotientiInfEmbedding_apply
File: Mathlib/GroupTheory/Coset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Group α
s t : Subgroup α
ι : Type u_2
f : ι → Subgroup α
⊢ ∀ (a₁ a₂ : α),
    (fun q i => quotientMapOfLE ⋯ q) (Quotient.mk'' a₁) = (fun q i => quotientMapOfLE ⋯ q) (Quotient.mk'' a₂) →
      Quotient.mk'' a₁ = Quotient.mk'' a₂
state_after: no goals
tactic: simp_rw [funext_iff, quotientMapOfLE_apply_mk, eq', mem_iInf, imp_self, forall_const]
Theorem: Int.card_fintype_Ioo
File: Mathlib/Data/Int/Interval.lean

Proof steps:
state_before: a b : ℤ
⊢ Fintype.card ↑(Set.Ioo a b) = (b - a - 1).toNat
state_after: no goals
tactic: rw [← card_Ioo, Fintype.card_ofFinset]
Theorem: Complex.ball_one_subset_slitPlane
File: Mathlib/Analysis/Complex/Basic.lean

Proof steps:
state_before: z : ℂ
hz : z ∈ Metric.ball 1 1
this : -1 < z.re - 1
⊢ 0 < z.re
state_after: no goals
tactic: linarith
Theorem: npow_mul_comm
File: Mathlib/Algebra/Group/NatPowAssoc.lean

Proof steps:
state_before: M : Type u_1
inst✝² : MulOneClass M
inst✝¹ : Pow M ℕ
inst✝ : NatPowAssoc M
m n : ℕ
x : M
⊢ x ^ m * x ^ n = x ^ n * x ^ m
state_after: no goals
tactic: simp only [← npow_add, add_comm]
Theorem: NNReal.tendsto_cofinite_zero_of_summable
File: Mathlib/Topology/Instances/NNReal.lean

Proof steps:
state_before: α : Type u_1
f : α → ℝ≥0
hf : Summable f
⊢ Tendsto f cofinite (𝓝 0)
state_after: α : Type u_1
f : α → ℝ≥0
hf : Summable fun a => ↑(f a)
⊢ Tendsto (fun a => ↑(f a)) cofinite (𝓝 ↑0)
tactic: simp only [← summable_coe, ← tendsto_coe] at hf ⊢
state_before: α : Type u_1
f : α → ℝ≥0
hf : Summable fun a => ↑(f a)
⊢ Tendsto (fun a => ↑(f a)) cofinite (𝓝 ↑0)
state_after: no goals
tactic: exact hf.tendsto_cofinite_zero
Theorem: RatFunc.denom_add_dvd
File: Mathlib/FieldTheory/RatFunc/Basic.lean

Proof steps:
state_before: K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ (x + y).denom ∣ x.denom * y.denom
state_after: K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ ∃ p, x + y = (algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) (x.denom * y.denom)
tactic: rw [denom_dvd (mul_ne_zero (denom_ne_zero x) (denom_ne_zero y))]
state_before: K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ ∃ p, x + y = (algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) (x.denom * y.denom)
state_after: K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ x + y =
    (algebraMap K[X] (RatFunc K)) (x.num * y.denom + x.denom * y.num) /
      (algebraMap K[X] (RatFunc K)) (x.denom * y.denom)
tactic: refine ⟨x.num * y.denom + x.denom * y.num, ?_⟩
state_before: K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ x + y =
    (algebraMap K[X] (RatFunc K)) (x.num * y.denom + x.denom * y.num) /
      (algebraMap K[X] (RatFunc K)) (x.denom * y.denom)
state_after: case hb
K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ (algebraMap K[X] (RatFunc K)) x.denom ≠ 0

case hd
K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ (algebraMap K[X] (RatFunc K)) y.denom ≠ 0
tactic: rw [RingHom.map_mul, RingHom.map_add, RingHom.map_mul, RingHom.map_mul, ← div_add_div,
    num_div_denom, num_div_denom]
Theorem: StieltjesFunction.measure_univ
File: Mathlib/MeasureTheory/Measure/Stieltjes.lean

Proof steps:
state_before: f : StieltjesFunction
l u : ℝ
hfl : Tendsto (↑f) atBot (𝓝 l)
hfu : Tendsto (↑f) atTop (𝓝 u)
⊢ f.measure univ = ofReal (u - l)
state_after: f : StieltjesFunction
l u : ℝ
hfl : Tendsto (↑f) atBot (𝓝 l)
hfu : Tendsto (↑f) atTop (𝓝 u)
⊢ Tendsto (fun x => f.measure (Iic x)) atTop (𝓝 (ofReal (u - l)))
tactic: refine tendsto_nhds_unique (tendsto_measure_Iic_atTop _) ?_
state_before: f : StieltjesFunction
l u : ℝ
hfl : Tendsto (↑f) atBot (𝓝 l)
hfu : Tendsto (↑f) atTop (𝓝 u)
⊢ Tendsto (fun x => f.measure (Iic x)) atTop (𝓝 (ofReal (u - l)))
state_after: f : StieltjesFunction
l u : ℝ
hfl : Tendsto (↑f) atBot (𝓝 l)
hfu : Tendsto (↑f) atTop (𝓝 u)
⊢ Tendsto (fun x => ofReal (↑f x - l)) atTop (𝓝 (ofReal (u - l)))
tactic: simp_rw [measure_Iic f hfl]
state_before: f : StieltjesFunction
l u : ℝ
hfl : Tendsto (↑f) atBot (𝓝 l)
hfu : Tendsto (↑f) atTop (𝓝 u)
⊢ Tendsto (fun x => ofReal (↑f x - l)) atTop (𝓝 (ofReal (u - l)))
state_after: no goals
tactic: exact ENNReal.tendsto_ofReal (Tendsto.sub_const hfu _)
Theorem: groupCohomology.isOneCoboundary_of_oneCoboundaries
File: Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean

Proof steps:
state_before: k✝ G✝ : Type u
inst✝⁷ : CommRing k✝
inst✝⁶ : Group G✝
A✝ : Rep k✝ G✝
k G A : Type u
inst✝⁵ : CommRing k
inst✝⁴ : Group G
inst✝³ : AddCommGroup A
inst✝² : Module k A
inst✝¹ : DistribMulAction G A
inst✝ : SMulCommClass G k A
f : ↥(oneCoboundaries (Rep.ofDistribMulAction k G A))
⊢ IsOneCoboundary ↑↑f
state_after: case intro
k✝ G✝ : Type u
inst✝⁷ : CommRing k✝
inst✝⁶ : Group G✝
A✝ : Rep k✝ G✝
k G A : Type u
inst✝⁵ : CommRing k
inst✝⁴ : Group G
inst✝³ : AddCommGroup A
inst✝² : Module k A
inst✝¹ : DistribMulAction G A
inst✝ : SMulCommClass G k A
f : ↥(oneCoboundaries (Rep.ofDistribMulAction k G A))
x : CoeSort.coe (Rep.ofDistribMulAction k G A)
hx : (dZero (Rep.ofDistribMulAction k G A)) x = ↑↑f
⊢ IsOneCoboundary ↑↑f
tactic: rcases mem_range_of_mem_oneCoboundaries f.2 with ⟨x, hx⟩
state_before: case intro
k✝ G✝ : Type u
inst✝⁷ : CommRing k✝
inst✝⁶ : Group G✝
A✝ : Rep k✝ G✝
k G A : Type u
inst✝⁵ : CommRing k
inst✝⁴ : Group G
inst✝³ : AddCommGroup A
inst✝² : Module k A
inst✝¹ : DistribMulAction G A
inst✝ : SMulCommClass G k A
f : ↥(oneCoboundaries (Rep.ofDistribMulAction k G A))
x : CoeSort.coe (Rep.ofDistribMulAction k G A)
hx : (dZero (Rep.ofDistribMulAction k G A)) x = ↑↑f
⊢ IsOneCoboundary ↑↑f
state_after: no goals
tactic: exact ⟨x, by rw [← hx]; intro g; rfl⟩
Theorem: Equiv.injective_pointReflection_left_of_injective_bit0
File: Mathlib/Algebra/AddTorsor.lean

Proof steps:
state_before: G✝ : Type u_1
P✝ : Type u_2
inst✝³ : AddGroup G✝
inst✝² : AddTorsor G✝ P✝
G : Type u_3
P : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : AddTorsor G P
h : Injective fun x => 2 • x
y x₁ x₂ : P
hy : (pointReflection x₁) y = (pointReflection x₂) y
⊢ x₁ = x₂
state_after: no goals
tactic: rwa [pointReflection_apply, pointReflection_apply, vadd_eq_vadd_iff_sub_eq_vsub,
    vsub_sub_vsub_cancel_right, ← neg_vsub_eq_vsub_rev, neg_eq_iff_add_eq_zero,
    ← two_nsmul, ← nsmul_zero 2, h.eq_iff, vsub_eq_zero_iff_eq] at hy
Theorem: Function.Periodic.sub_nsmul_eq
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 α
h : Periodic f c
n : ℕ
⊢ f (x - n • c) = f x
state_after: no goals
tactic: simpa only [sub_eq_add_neg] using h.neg_nsmul n x
Theorem: Polynomial.nthRootsFinset_zero
File: Mathlib/Algebra/Polynomial/Roots.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
⊢ nthRootsFinset 0 R = ∅
state_after: no goals
tactic: classical simp [nthRootsFinset_def]
Theorem: List.finRange_eq_nil
File: Mathlib/Data/List/Range.lean

Proof steps:
state_before: α : Type u
n : ℕ
⊢ finRange n = [] ↔ n = 0
state_after: no goals
tactic: rw [← length_eq_zero, length_finRange]
Theorem: String.data_takeWhile
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: p : Char → Bool
s : String
⊢ (s.takeWhile p).data = List.takeWhile p s.data
state_after: no goals
tactic: rw [takeWhile_eq]
Theorem: Ordinal.toPGame_rightMoves
File: Mathlib/SetTheory/Game/Ordinal.lean

Proof steps:
state_before: o : Ordinal.{u_1}
⊢ o.toPGame.RightMoves = PEmpty.{u_1 + 1}
state_after: no goals
tactic: rw [toPGame, RightMoves]
Theorem: tendsto_ite
File: Mathlib/Topology/IndicatorConstPointwise.lean

Proof steps:
state_before: α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
⊢ Tendsto (fun i => if p i then a else b) L (if q then F else G) ↔ ∀ᶠ (i : ι) in L, p i ↔ q
state_after: case mp
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : Tendsto (fun i => if p i then a else b) L (if q then F else G)
⊢ ∀ᶠ (i : ι) in L, p i ↔ q

case mpr
α : Type u_1
A : Set α
β✝ : Type u_2
inst✝³ : Zero β✝
inst✝² : TopologicalSpace β✝
ι : Type u_3
L : Filter ι
As : ι → Set α
β : Type u_4
p : ι → Prop
inst✝¹ : DecidablePred p
q : Prop
inst✝ : Decidable q
a b : β
F G : Filter β
haG : {a}ᶜ ∈ G
hbF : {b}ᶜ ∈ F
haF : 𝓟 {a} ≤ F
hbG : 𝓟 {b} ≤ G
h : ∀ᶠ (i : ι) in L, p i ↔ q
⊢ Tendsto (fun i => if p i then a else b) L (if q then F else G)
tactic: constructor <;> intro h
Theorem: max_sub_sub_right
File: Mathlib/Algebra/Order/Group/MinMax.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroup α
a✝ b✝ c✝ a b c : α
⊢ max (a / c) (b / c) = max a b / c
state_after: no goals
tactic: simpa only [div_eq_mul_inv] using max_mul_mul_right a b c⁻¹
Theorem: Associates.factors_mul
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a b : Associates α
⊢ (a * b).factors = a.factors + b.factors
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a b : Associates α
a✝ : Nontrivial α
⊢ (a * b).factors = a.factors + b.factors
tactic: nontriviality α
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a b : Associates α
a✝ : Nontrivial α
⊢ (a * b).factors = a.factors + b.factors
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a b : Associates α
a✝ : Nontrivial α
⊢ (a * b).factors.prod.factors = (a.factors + b.factors).prod.factors
tactic: refine eq_of_prod_eq_prod <| eq_of_factors_eq_factors ?_
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a b : Associates α
a✝ : Nontrivial α
⊢ (a * b).factors.prod.factors = (a.factors + b.factors).prod.factors
state_after: no goals
tactic: rw [prod_add, factors_prod, factors_prod, factors_prod]
Theorem: IsNowhereDense.closure
File: Mathlib/Topology/GDelta.lean

Proof steps:
state_before: X✝ : Type u_1
Y : Type u_2
ι : Type u_3
ι' : Sort u_4
X : Type u_5
inst✝ : TopologicalSpace X
s : Set X
hs : IsNowhereDense s
⊢ IsNowhereDense (closure s)
state_after: no goals
tactic: rwa [IsNowhereDense, closure_closure]
Theorem: Mon_.mul_one_hom
File: Mathlib/CategoryTheory/Monoidal/Mon_.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Mon_ C
Z : C
f : Z ⟶ M.X
⊢ (f ⊗ M.one) ≫ M.mul = (ρ_ Z).hom ≫ f
state_after: no goals
tactic: rw [tensorHom_def_assoc, M.mul_one, rightUnitor_naturality]
Theorem: Polynomial.newtonMap_apply_of_isUnit
File: Mathlib/Dynamics/Newton.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
P : R[X]
x : S
h : IsUnit ((aeval x) (derivative P))
⊢ P.newtonMap x = x - ↑h.unit⁻¹ * (aeval x) P
state_after: no goals
tactic: simp [newtonMap_apply, Ring.inverse, h]
Theorem: IntermediateField.adjoin.powerBasis_dim
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
α : E
K : Type u
inst✝³ : Field K
inst✝² : Algebra F K
L : Type u_3
inst✝¹ : Field L
inst✝ : Algebra K L
x : L
hx : IsIntegral K x
i : Fin (minpoly K x).natDegree
⊢ (powerBasisAux hx) i = AdjoinSimple.gen K x ^ ↑i
state_after: no goals
tactic: erw [powerBasisAux, Basis.map_apply, PowerBasis.basis_eq_pow, AlgEquiv.toLinearEquiv_apply,
      map_pow, AdjoinRoot.powerBasis_gen, adjoinRootEquivAdjoin_apply_root]