1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Finsupp.mem_span_image_iff_total
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: rw [span_image_eq_map_total]
state_before: α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
s : Set α
x : M
⊢ x ∈ span R (v '' s) ↔ ∃ l ∈ supported R R s, (Finsupp.total α M R v) l = x
state_after: α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
s : Set α
x : M
⊢ x ∈ map (Finsupp.total α M R v) (supported R R s) ↔ ∃ l ∈ supported R R s, (Finsupp.total α M R v) l = x

tactic: simp
state_before: α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
s : Set α
x : M
⊢ x ∈ map (Finsupp.total α M R v) (supported R R s) ↔ ∃ l ∈ supported R R s, (Finsupp.total α M R v) l = x
state_after: no goals
Theorem: Real.rpow_neg
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: simp only [rpow_def_of_nonneg hx]
state_before: x✝¹ y✝¹ z✝ w x✝ y✝ z x : ℝ
hx : 0 ≤ x
y : ℝ
⊢ x ^ (-y) = (x ^ y)⁻¹
state_after: x✝¹ y✝¹ z✝ w x✝ y✝ z x : ℝ
hx : 0 ≤ x
y : ℝ
⊢ (if x = 0 then if -y = 0 then 1 else 0 else rexp (log x * -y)) =
    (if x = 0 then if y = 0 then 1 else 0 else rexp (log x * y))⁻¹

tactic: split_ifs <;> simp_all [exp_neg]
state_before: x✝¹ y✝¹ z✝ w x✝ y✝ z x : ℝ
hx : 0 ≤ x
y : ℝ
⊢ (if x = 0 then if -y = 0 then 1 else 0 else rexp (log x * -y)) =
    (if x = 0 then if y = 0 then 1 else 0 else rexp (log x * y))⁻¹
state_after: no goals
Theorem: QuotientGroup.mk_out'_eq_mul
File: Mathlib/GroupTheory/Coset.lean

tactic: rw [mul_inv_cancel_left]
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
g : α
⊢ Quotient.out' ↑g = g * ↑⟨g⁻¹ * Quotient.out' ↑g, ⋯⟩
state_after: no goals
Theorem: natCast_ceil_eq_intCast_ceil
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← Int.ofNat_ceil_eq_ceil ha, Int.cast_natCast]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
a : α
ha : 0 ≤ a
⊢ ↑⌈a⌉₊ = ↑⌈a⌉
state_after: no goals
Theorem: Order.le_le_succ_iff
File: Mathlib/Order/SuccPred/Basic.lean

tactic: refine
  ⟨fun h =>
    or_iff_not_imp_left.2 fun hba : b ≠ a =>
      h.2.antisymm (succ_le_of_lt <| h.1.lt_of_ne <| hba.symm),
    ?_⟩
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
⊢ a ≤ b ∧ b ≤ succ a ↔ b = a ∨ b = succ a
state_after: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
⊢ b = a ∨ b = succ a → a ≤ b ∧ b ≤ succ a

tactic: rintro (rfl | rfl)
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
⊢ b = a ∨ b = succ a → a ≤ b ∧ b ≤ succ a
state_after: case inl
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
b : α
⊢ b ≤ b ∧ b ≤ succ b

case inr
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a : α
⊢ a ≤ succ a ∧ succ a ≤ succ a

tactic: exact ⟨le_rfl, le_succ b⟩
state_before: case inl
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
b : α
⊢ b ≤ b ∧ b ≤ succ b
state_after: no goals

tactic: exact ⟨le_succ a, le_rfl⟩
state_before: case inr
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a : α
⊢ a ≤ succ a ∧ succ a ≤ succ a
state_after: no goals
Theorem: Multiset.filter_add_filter
File: Mathlib/Data/Multiset/Basic.lean

tactic: by_cases p a <;> by_cases q a <;> simp [*]
state_before: α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝¹ : DecidablePred p
q : α → Prop
inst✝ : DecidablePred q
s✝ : Multiset α
a : α
s : Multiset α
IH : filter p s + filter q s = filter (fun a => p a ∨ q a) s + filter (fun a => p a ∧ q a) s
⊢ filter p (a ::ₘ s) + filter q (a ::ₘ s) =
    filter (fun a => p a ∨ q a) (a ::ₘ s) + filter (fun a => p a ∧ q a) (a ::ₘ s)
state_after: no goals
Theorem: DiscreteValuationRing.associated_of_irreducible
File: Mathlib/RingTheory/DiscreteValuationRing/Basic.lean

tactic: rw [irreducible_iff_uniformizer] at ha hb
state_before: R : Type u
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
a b : R
ha : Irreducible a
hb : Irreducible b
⊢ Associated a b
state_after: R : Type u
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
a b : R
ha : maximalIdeal R = span {a}
hb : maximalIdeal R = span {b}
⊢ Associated a b

tactic: rw [← span_singleton_eq_span_singleton, ← ha, hb]
state_before: R : Type u
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
a b : R
ha : maximalIdeal R = span {a}
hb : maximalIdeal R = span {b}
⊢ Associated a b
state_after: no goals
Theorem: inv_div'
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionCommMonoid α
a b c d : α
⊢ (a / b)⁻¹ = a⁻¹ / b⁻¹
state_after: no goals
Theorem: Asymptotics.isLittleO_map
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [IsLittleO_def, isBigOWith_map]
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹³ : Norm E
inst✝¹² : Norm F
inst✝¹¹ : Norm G
inst✝¹⁰ : SeminormedAddCommGroup E'
inst✝⁹ : SeminormedAddCommGroup F'
inst✝⁸ : SeminormedAddCommGroup G'
inst✝⁷ : NormedAddCommGroup E''
inst✝⁶ : NormedAddCommGroup F''
inst✝⁵ : NormedAddCommGroup G''
inst✝⁴ : SeminormedRing R
inst✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k✝ : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l✝ l' : Filter α
k : β → α
l : Filter β
⊢ f =o[map k l] g ↔ (f ∘ k) =o[l] (g ∘ k)
state_after: no goals
Theorem: MeasureTheory.mul_meas_ge_le_pow_snorm'
File: Mathlib/MeasureTheory/Function/LpSeminorm/ChebyshevMarkov.lean

tactic: convert mul_meas_ge_le_pow_snorm μ hp_ne_zero hp_ne_top hf (ε ^ p.toReal) using 4
state_before: α : Type u_1
E : Type u_2
m0 : MeasurableSpace α
inst✝ : NormedAddCommGroup E
p : ℝ≥0∞
μ : Measure α
f : α → E
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
hf : AEStronglyMeasurable f μ
ε : ℝ≥0∞
⊢ ε ^ p.toReal * μ {x | ε ≤ ↑‖f x‖₊} ≤ snorm f p μ ^ p.toReal
state_after: case h.e'_3.h.e'_6.h.e'_6.h.e'_2
α : Type u_1
E : Type u_2
m0 : MeasurableSpace α
inst✝ : NormedAddCommGroup E
p : ℝ≥0∞
μ : Measure α
f : α → E
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
hf : AEStronglyMeasurable f μ
ε : ℝ≥0∞
⊢ (fun x => ε ≤ ↑‖f x‖₊) = fun x => ε ^ p.toReal ≤ ↑‖f x‖₊ ^ p.toReal

tactic: ext x
state_before: case h.e'_3.h.e'_6.h.e'_6.h.e'_2
α : Type u_1
E : Type u_2
m0 : MeasurableSpace α
inst✝ : NormedAddCommGroup E
p : ℝ≥0∞
μ : Measure α
f : α → E
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
hf : AEStronglyMeasurable f μ
ε : ℝ≥0∞
⊢ (fun x => ε ≤ ↑‖f x‖₊) = fun x => ε ^ p.toReal ≤ ↑‖f x‖₊ ^ p.toReal
state_after: case h.e'_3.h.e'_6.h.e'_6.h.e'_2.h.a
α : Type u_1
E : Type u_2
m0 : MeasurableSpace α
inst✝ : NormedAddCommGroup E
p : ℝ≥0∞
μ : Measure α
f : α → E
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
hf : AEStronglyMeasurable f μ
ε : ℝ≥0∞
x : α
⊢ ε ≤ ↑‖f x‖₊ ↔ ε ^ p.toReal ≤ ↑‖f x‖₊ ^ p.toReal

tactic: rw [ENNReal.rpow_le_rpow_iff (ENNReal.toReal_pos hp_ne_zero hp_ne_top)]
state_before: case h.e'_3.h.e'_6.h.e'_6.h.e'_2.h.a
α : Type u_1
E : Type u_2
m0 : MeasurableSpace α
inst✝ : NormedAddCommGroup E
p : ℝ≥0∞
μ : Measure α
f : α → E
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
hf : AEStronglyMeasurable f μ
ε : ℝ≥0∞
x : α
⊢ ε ≤ ↑‖f x‖₊ ↔ ε ^ p.toReal ≤ ↑‖f x‖₊ ^ p.toReal
state_after: no goals
Theorem: BoxIntegral.IntegrationParams.henstock_le_mcShane
File: Mathlib/Analysis/BoxIntegral/Partition/Filter.lean

tactic: trivial
state_before: ι : Type u_1
inst✝ : Fintype ι
I J : Box ι
c c₁ c₂ : ℝ≥0
r r₁ r₂ : (ι → ℝ) → ↑(Set.Ioi 0)
π π₁ π₂ : TaggedPrepartition I
l l₁ l₂ : IntegrationParams
⊢ Henstock ≤ McShane
state_after: no goals
Theorem: Cardinal.mk_finsupp_lift_of_infinite
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: apply le_antisymm
state_before: α : Type u
β : Type v
inst✝² : Infinite α
inst✝¹ : Zero β
inst✝ : Nontrivial β
⊢ #(α →₀ β) = max (lift.{v, u} #α) (lift.{u, v} #β)
state_after: case a
α : Type u
β : Type v
inst✝² : Infinite α
inst✝¹ : Zero β
inst✝ : Nontrivial β
⊢ #(α →₀ β) ≤ max (lift.{v, u} #α) (lift.{u, v} #β)

case a
α : Type u
β : Type v
inst✝² : Infinite α
inst✝¹ : Zero β
inst✝ : Nontrivial β
⊢ max (lift.{v, u} #α) (lift.{u, v} #β) ≤ #(α →₀ β)

tactic: calc
  #(α →₀ β) ≤ #(Finset (α × β)) := mk_le_of_injective (Finsupp.graph_injective α β)
  _ = #(α × β) := mk_finset_of_infinite _
  _ = max (lift.{v} #α) (lift.{u} #β) := by
    rw [mk_prod, mul_eq_max_of_aleph0_le_left] <;> simp
state_before: case a
α : Type u
β : Type v
inst✝² : Infinite α
inst✝¹ : Zero β
inst✝ : Nontrivial β
⊢ #(α →₀ β) ≤ max (lift.{v, u} #α) (lift.{u, v} #β)
state_after: no goals

tactic: rw [mk_prod, mul_eq_max_of_aleph0_le_left] <;> simp
state_before: α : Type u
β : Type v
inst✝² : Infinite α
inst✝¹ : Zero β
inst✝ : Nontrivial β
⊢ #(α × β) = max (lift.{v, u} #α) (lift.{u, v} #β)
state_after: no goals

tactic: apply max_le <;> rw [← lift_id #(α →₀ β), ← lift_umax]
state_before: case a
α : Type u
β : Type v
inst✝² : Infinite α
inst✝¹ : Zero β
inst✝ : Nontrivial β
⊢ max (lift.{v, u} #α) (lift.{u, v} #β) ≤ #(α →₀ β)
state_after: case a.h₁
α : Type u
β : Type v
inst✝² : Infinite α
inst✝¹ : Zero β
inst✝ : Nontrivial β
⊢ lift.{max u v, u} #α ≤ lift.{max v u, max v u} #(α →₀ β)

case a.h₂
α : Type u
β : Type v
inst✝² : Infinite α
inst✝¹ : Zero β
inst✝ : Nontrivial β
⊢ lift.{max v u, v} #β ≤ lift.{max v u, max v u} #(α →₀ β)

tactic: cases' exists_ne (0 : β) with b hb
state_before: case a.h₁
α : Type u
β : Type v
inst✝² : Infinite α
inst✝¹ : Zero β
inst✝ : Nontrivial β
⊢ lift.{max u v, u} #α ≤ lift.{max v u, max v u} #(α →₀ β)
state_after: case a.h₁.intro
α : Type u
β : Type v
inst✝² : Infinite α
inst✝¹ : Zero β
inst✝ : Nontrivial β
b : β
hb : b ≠ 0
⊢ lift.{max u v, u} #α ≤ lift.{max v u, max v u} #(α →₀ β)

tactic: exact lift_mk_le.{v}.2 ⟨⟨_, Finsupp.single_left_injective hb⟩⟩
state_before: case a.h₁.intro
α : Type u
β : Type v
inst✝² : Infinite α
inst✝¹ : Zero β
inst✝ : Nontrivial β
b : β
hb : b ≠ 0
⊢ lift.{max u v, u} #α ≤ lift.{max v u, max v u} #(α →₀ β)
state_after: no goals

tactic: inhabit α
state_before: case a.h₂
α : Type u
β : Type v
inst✝² : Infinite α
inst✝¹ : Zero β
inst✝ : Nontrivial β
⊢ lift.{max v u, v} #β ≤ lift.{max v u, max v u} #(α →₀ β)
state_after: case a.h₂
α : Type u
β : Type v
inst✝² : Infinite α
inst✝¹ : Zero β
inst✝ : Nontrivial β
inhabited_h : Inhabited α
⊢ lift.{max v u, v} #β ≤ lift.{max v u, max v u} #(α →₀ β)

tactic: exact lift_mk_le.{u}.2 ⟨⟨_, Finsupp.single_injective default⟩⟩
state_before: case a.h₂
α : Type u
β : Type v
inst✝² : Infinite α
inst✝¹ : Zero β
inst✝ : Nontrivial β
inhabited_h : Inhabited α
⊢ lift.{max v u, v} #β ≤ lift.{max v u, max v u} #(α →₀ β)
state_after: no goals
Theorem: Ideal.mem_jacobson_bot
File: Mathlib/RingTheory/JacobsonIdeal.lean

tactic: rwa [add_mul, one_mul, ← sub_eq_zero, mul_right_comm, mul_comm _ z, mul_right_comm]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
x : R
hx : x ∈ ⊥.jacobson
y z : R
hz : z * y * x + z - 1 ∈ ⊥
⊢ (x * y + 1) * z = 1
state_after: no goals

tactic: ring
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
x : R
h : ∀ (y : R), IsUnit (x * y + 1)
y b : R
hb : (x * y + 1) * b = 1
⊢ b * y * x + b - (x * y + 1) * b = 0
state_after: no goals
Theorem: Ordinal.zero_lt_card
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: simpa using nat_lt_card (n := 0)
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_3}
⊢ 0 < o.card ↔ 0 < o
state_after: no goals
Theorem: Submodule.one_le
File: Mathlib/Algebra/Algebra/Operations.lean

tactic: simp only [one_eq_span, span_le, Set.singleton_subset_iff, SetLike.mem_coe]
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n : A
⊢ 1 ≤ P ↔ 1 ∈ P
state_after: no goals
Theorem: TopCat.Presheaf.id_pushforward
File: Mathlib/Topology/Sheaves/Presheaf.lean

tactic: apply CategoryTheory.Functor.ext
state_before: C : Type u
inst✝ : Category.{v, u} C
X : TopCat
⊢ pushforward C (𝟙 X) = 𝟭 (Presheaf C X)
state_after: case h_map
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
⊢ autoParam
    (∀ (X_1 Y : Presheaf C X) (f : X_1 ⟶ Y),
      (pushforward C (𝟙 X)).map f = eqToHom ⋯ ≫ (𝟭 (Presheaf C X)).map f ≫ eqToHom ⋯)
    _auto✝

case h_obj
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
⊢ ∀ (X_1 : Presheaf C X), (pushforward C (𝟙 X)).obj X_1 = (𝟭 (Presheaf C X)).obj X_1

tactic: intros a b f
state_before: case h_map
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
⊢ autoParam
    (∀ (X_1 Y : Presheaf C X) (f : X_1 ⟶ Y),
      (pushforward C (𝟙 X)).map f = eqToHom ⋯ ≫ (𝟭 (Presheaf C X)).map f ≫ eqToHom ⋯)
    _auto✝
state_after: case h_map
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
a b : Presheaf C X
f : a ⟶ b
⊢ (pushforward C (𝟙 X)).map f = eqToHom ⋯ ≫ (𝟭 (Presheaf C X)).map f ≫ eqToHom ⋯

tactic: ext U
state_before: case h_map
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
a b : Presheaf C X
f : a ⟶ b
⊢ (pushforward C (𝟙 X)).map f = eqToHom ⋯ ≫ (𝟭 (Presheaf C X)).map f ≫ eqToHom ⋯
state_after: case h_map.w
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
a b : Presheaf C X
f : a ⟶ b
U : Opens ↑X
⊢ ((pushforward C (𝟙 X)).map f).app { unop := U } = (eqToHom ⋯ ≫ (𝟭 (Presheaf C X)).map f ≫ eqToHom ⋯).app { unop := U }

tactic: erw [NatTrans.congr f (Opens.op_map_id_obj (op U))]
state_before: case h_map.w
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
a b : Presheaf C X
f : a ⟶ b
U : Opens ↑X
⊢ ((pushforward C (𝟙 X)).map f).app { unop := U } = (eqToHom ⋯ ≫ (𝟭 (Presheaf C X)).map f ≫ eqToHom ⋯).app { unop := U }
state_after: case h_map.w
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
a b : Presheaf C X
f : a ⟶ b
U : Opens ↑X
⊢ a.map (eqToHom ⋯) ≫ f.app { unop := U } ≫ b.map (eqToHom ⋯) =
    (eqToHom ⋯ ≫ (𝟭 (Presheaf C X)).map f ≫ eqToHom ⋯).app { unop := U }

tactic: simp only [Functor.op_obj, eqToHom_refl, CategoryTheory.Functor.map_id,
  Category.comp_id, Category.id_comp, Functor.id_obj, Functor.id_map]
state_before: case h_map.w
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
a b : Presheaf C X
f : a ⟶ b
U : Opens ↑X
⊢ a.map (eqToHom ⋯) ≫ f.app { unop := U } ≫ b.map (eqToHom ⋯) =
    (eqToHom ⋯ ≫ (𝟭 (Presheaf C X)).map f ≫ eqToHom ⋯).app { unop := U }
state_after: no goals

tactic: apply Pushforward.id_eq
state_before: case h_obj
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
⊢ ∀ (X_1 : Presheaf C X), (pushforward C (𝟙 X)).obj X_1 = (𝟭 (Presheaf C X)).obj X_1
state_after: no goals
Theorem: MeasureTheory.AECover.integrable_of_lintegral_nnnorm_tendsto'
File: Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean

tactic: simpa only [ENNReal.ofReal_coe_nnreal] using htendsto
state_before: α : Type u_1
ι : Type u_2
E : Type u_3
inst✝³ : MeasurableSpace α
μ : Measure α
l : Filter ι
inst✝² : NormedAddCommGroup E
inst✝¹ : l.NeBot
inst✝ : l.IsCountablyGenerated
φ : ι → Set α
hφ : AECover μ l φ
f : α → E
I : ℝ≥0
hfm : AEStronglyMeasurable f μ
htendsto : Tendsto (fun i => ∫⁻ (x : α) in φ i, ↑‖f x‖₊ ∂μ) l (𝓝 ↑I)
⊢ Tendsto (fun i => ∫⁻ (x : α) in φ i, ↑‖f x‖₊ ∂μ) l (𝓝 (ENNReal.ofReal ↑I))
state_after: no goals
Theorem: Polynomial.irreducible_factor
File: Mathlib/FieldTheory/SplittingField/Construction.lean

tactic: rw [factor]
state_before: F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
f : K[X]
⊢ Irreducible f.factor
state_after: F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
f : K[X]
⊢ Irreducible (if H : ∃ g, Irreducible g ∧ g ∣ f then Classical.choose H else X)

tactic: split_ifs with H
state_before: F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
f : K[X]
⊢ Irreducible (if H : ∃ g, Irreducible g ∧ g ∣ f then Classical.choose H else X)
state_after: case pos
F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
f : K[X]
H : ∃ g, Irreducible g ∧ g ∣ f
⊢ Irreducible (Classical.choose H)

case neg
F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
f : K[X]
H : ¬∃ g, Irreducible g ∧ g ∣ f
⊢ Irreducible X

tactic: exact (Classical.choose_spec H).1
state_before: case pos
F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
f : K[X]
H : ∃ g, Irreducible g ∧ g ∣ f
⊢ Irreducible (Classical.choose H)
state_after: no goals

tactic: exact irreducible_X
state_before: case neg
F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
f : K[X]
H : ¬∃ g, Irreducible g ∧ g ∣ f
⊢ Irreducible X
state_after: no goals
Theorem: Real.div_sqrt
File: Mathlib/Data/Real/Sqrt.lean

tactic: rcases le_or_lt x 0 with h | h
state_before: x✝ y✝ x y : ℝ
⊢ x / √x = √x
state_after: case inl
x✝ y✝ x y : ℝ
h : x ≤ 0
⊢ x / √x = √x

case inr
x✝ y✝ x y : ℝ
h : 0 < x
⊢ x / √x = √x

tactic: rw [sqrt_eq_zero'.mpr h, div_zero]
state_before: case inl
x✝ y✝ x y : ℝ
h : x ≤ 0
⊢ x / √x = √x
state_after: no goals

tactic: rw [div_eq_iff (sqrt_ne_zero'.mpr h), mul_self_sqrt h.le]
state_before: case inr
x✝ y✝ x y : ℝ
h : 0 < x
⊢ x / √x = √x
state_after: no goals
Theorem: CategoryTheory.MorphismProperty.RespectsIso.cancel_left_isIso
File: Mathlib/CategoryTheory/MorphismProperty/Basic.lean

tactic: simpa using hP.1 (asIso f).symm (f ≫ g) h
state_before: C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{?u.10962, u_1} D
P : MorphismProperty C
hP : P.RespectsIso
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : IsIso f
h : P (f ≫ g)
⊢ P g
state_after: no goals
Theorem: Polynomial.isNilpotent_reflect_iff
File: Mathlib/RingTheory/Polynomial/Nilpotent.lean

tactic: simp only [Polynomial.isNilpotent_iff, coeff_reverse]
state_before: R : Type u_1
r : R
inst✝ : CommRing R
P✝ P : R[X]
N : ℕ
hN : P.natDegree ≤ N
⊢ IsNilpotent (reflect N P) ↔ IsNilpotent P
state_after: R : Type u_1
r : R
inst✝ : CommRing R
P✝ P : R[X]
N : ℕ
hN : P.natDegree ≤ N
⊢ (∀ (i : ℕ), IsNilpotent ((reflect N P).coeff i)) ↔ ∀ (i : ℕ), IsNilpotent (P.coeff i)

tactic: refine ⟨fun h i ↦ ?_, fun h i ↦ ?_⟩ <;> rcases le_or_lt i N with hi | hi
state_before: R : Type u_1
r : R
inst✝ : CommRing R
P✝ P : R[X]
N : ℕ
hN : P.natDegree ≤ N
⊢ (∀ (i : ℕ), IsNilpotent ((reflect N P).coeff i)) ↔ ∀ (i : ℕ), IsNilpotent (P.coeff i)
state_after: case refine_1.inl
R : Type u_1
r : R
inst✝ : CommRing R
P✝ P : R[X]
N : ℕ
hN : P.natDegree ≤ N
h : ∀ (i : ℕ), IsNilpotent ((reflect N P).coeff i)
i : ℕ
hi : i ≤ N
⊢ IsNilpotent (P.coeff i)

case refine_1.inr
R : Type u_1
r : R
inst✝ : CommRing R
P✝ P : R[X]
N : ℕ
hN : P.natDegree ≤ N
h : ∀ (i : ℕ), IsNilpotent ((reflect N P).coeff i)
i : ℕ
hi : N < i
⊢ IsNilpotent (P.coeff i)

case refine_2.inl
R : Type u_1
r : R
inst✝ : CommRing R
P✝ P : R[X]
N : ℕ
hN : P.natDegree ≤ N
h : ∀ (i : ℕ), IsNilpotent (P.coeff i)
i : ℕ
hi : i ≤ N
⊢ IsNilpotent ((reflect N P).coeff i)

case refine_2.inr
R : Type u_1
r : R
inst✝ : CommRing R
P✝ P : R[X]
N : ℕ
hN : P.natDegree ≤ N
h : ∀ (i : ℕ), IsNilpotent (P.coeff i)
i : ℕ
hi : N < i
⊢ IsNilpotent ((reflect N P).coeff i)

tactic: simpa [tsub_tsub_cancel_of_le hi] using h (N - i)
state_before: case refine_1.inl
R : Type u_1
r : R
inst✝ : CommRing R
P✝ P : R[X]
N : ℕ
hN : P.natDegree ≤ N
h : ∀ (i : ℕ), IsNilpotent ((reflect N P).coeff i)
i : ℕ
hi : i ≤ N
⊢ IsNilpotent (P.coeff i)
state_after: no goals

tactic: simp [coeff_eq_zero_of_natDegree_lt <| lt_of_le_of_lt hN hi]
state_before: case refine_1.inr
R : Type u_1
r : R
inst✝ : CommRing R
P✝ P : R[X]
N : ℕ
hN : P.natDegree ≤ N
h : ∀ (i : ℕ), IsNilpotent ((reflect N P).coeff i)
i : ℕ
hi : N < i
⊢ IsNilpotent (P.coeff i)
state_after: no goals

tactic: simpa [hi, revAt_le] using h (N - i)
state_before: case refine_2.inl
R : Type u_1
r : R
inst✝ : CommRing R
P✝ P : R[X]
N : ℕ
hN : P.natDegree ≤ N
h : ∀ (i : ℕ), IsNilpotent (P.coeff i)
i : ℕ
hi : i ≤ N
⊢ IsNilpotent ((reflect N P).coeff i)
state_after: no goals

tactic: simpa [revAt_eq_self_of_lt hi] using h i
state_before: case refine_2.inr
R : Type u_1
r : R
inst✝ : CommRing R
P✝ P : R[X]
N : ℕ
hN : P.natDegree ≤ N
h : ∀ (i : ℕ), IsNilpotent (P.coeff i)
i : ℕ
hi : N < i
⊢ IsNilpotent ((reflect N P).coeff i)
state_after: no goals
Theorem: MeasureTheory.lintegral_indicator_const_comp
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: erw [lintegral_comp (measurable_const.indicator hs) hf, lintegral_indicator_const hs,
  Measure.map_apply hf hs]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
mβ : MeasurableSpace β
f : α → β
s : Set β
hf : Measurable f
hs : MeasurableSet s
c : ℝ≥0∞
⊢ ∫⁻ (a : α), s.indicator (fun x => c) (f a) ∂μ = c * μ (f ⁻¹' s)
state_after: no goals
Theorem: Nat.digits_add_two_add_one
File: Mathlib/Data/Nat/Digits.lean

tactic: simp [digits, digitsAux_def]
state_before: n✝ b n : ℕ
⊢ (b + 2).digits (n + 1) = (n + 1) % (b + 2) :: (b + 2).digits ((n + 1) / (b + 2))
state_after: no goals
Theorem: Submonoid.LocalizationMap.mk'_spec'
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [mul_comm, mk'_spec]
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
x : M
y : ↥S
⊢ f.toMap ↑y * f.mk' x y = f.toMap x
state_after: no goals