1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: HasCompactSupport.hasFDerivAt_convolution_left
File: Mathlib/Analysis/Convolution.lean

tactic: simp (config := { singlePass := true }) only [← convolution_flip]
state_before: 𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹⁷ : NormedAddCommGroup E
inst✝¹⁶ : NormedAddCommGroup E'
inst✝¹⁵ : NormedAddCommGroup E''
inst✝¹⁴ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y y' : E
inst✝¹³ : RCLike 𝕜
inst✝¹² : NormedSpace 𝕜 E
inst✝¹¹ : NormedSpace 𝕜 E'
inst✝¹⁰ : NormedSpace 𝕜 E''
inst✝⁹ : NormedSpace ℝ F
inst✝⁸ : NormedSpace 𝕜 F
n : ℕ∞
inst✝⁷ : CompleteSpace F
inst✝⁶ : MeasurableSpace G
μ ν : Measure G
L : E →L[𝕜] E' →L[𝕜] F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : BorelSpace G
inst✝³ : NormedSpace 𝕜 G
inst✝² : SigmaFinite μ
inst✝¹ : μ.IsAddLeftInvariant
inst✝ : μ.IsNegInvariant
hcf : HasCompactSupport f
hf : ContDiff 𝕜 1 f
hg : LocallyIntegrable g μ
x₀ : G
⊢ HasFDerivAt (f ⋆[L, μ] g) ((fderiv 𝕜 f ⋆[precompL G L, μ] g) x₀) x₀
state_after: 𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹⁷ : NormedAddCommGroup E
inst✝¹⁶ : NormedAddCommGroup E'
inst✝¹⁵ : NormedAddCommGroup E''
inst✝¹⁴ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y y' : E
inst✝¹³ : RCLike 𝕜
inst✝¹² : NormedSpace 𝕜 E
inst✝¹¹ : NormedSpace 𝕜 E'
inst✝¹⁰ : NormedSpace 𝕜 E''
inst✝⁹ : NormedSpace ℝ F
inst✝⁸ : NormedSpace 𝕜 F
n : ℕ∞
inst✝⁷ : CompleteSpace F
inst✝⁶ : MeasurableSpace G
μ ν : Measure G
L : E →L[𝕜] E' →L[𝕜] F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : BorelSpace G
inst✝³ : NormedSpace 𝕜 G
inst✝² : SigmaFinite μ
inst✝¹ : μ.IsAddLeftInvariant
inst✝ : μ.IsNegInvariant
hcf : HasCompactSupport f
hf : ContDiff 𝕜 1 f
hg : LocallyIntegrable g μ
x₀ : G
⊢ HasFDerivAt (g ⋆[L.flip, μ] f) ((g ⋆[(precompL G L).flip, μ] fderiv 𝕜 f) x₀) x₀

tactic: exact hcf.hasFDerivAt_convolution_right L.flip hg hf x₀
state_before: 𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹⁷ : NormedAddCommGroup E
inst✝¹⁶ : NormedAddCommGroup E'
inst✝¹⁵ : NormedAddCommGroup E''
inst✝¹⁴ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y y' : E
inst✝¹³ : RCLike 𝕜
inst✝¹² : NormedSpace 𝕜 E
inst✝¹¹ : NormedSpace 𝕜 E'
inst✝¹⁰ : NormedSpace 𝕜 E''
inst✝⁹ : NormedSpace ℝ F
inst✝⁸ : NormedSpace 𝕜 F
n : ℕ∞
inst✝⁷ : CompleteSpace F
inst✝⁶ : MeasurableSpace G
μ ν : Measure G
L : E →L[𝕜] E' →L[𝕜] F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : BorelSpace G
inst✝³ : NormedSpace 𝕜 G
inst✝² : SigmaFinite μ
inst✝¹ : μ.IsAddLeftInvariant
inst✝ : μ.IsNegInvariant
hcf : HasCompactSupport f
hf : ContDiff 𝕜 1 f
hg : LocallyIntegrable g μ
x₀ : G
⊢ HasFDerivAt (g ⋆[L.flip, μ] f) ((g ⋆[(precompL G L).flip, μ] fderiv 𝕜 f) x₀) x₀
state_after: no goals
Theorem: WType.depth_pos
File: Mathlib/Data/W/Basic.lean

tactic: cases t
state_before: α : Type u_1
β : α → Type u_2
inst✝ : (a : α) → Fintype (β a)
t : WType β
⊢ 0 < t.depth
state_after: case mk
α : Type u_1
β : α → Type u_2
inst✝ : (a : α) → Fintype (β a)
a✝ : α
f✝ : β a✝ → WType β
⊢ 0 < (mk a✝ f✝).depth

tactic: apply Nat.succ_pos
state_before: case mk
α : Type u_1
β : α → Type u_2
inst✝ : (a : α) → Fintype (β a)
a✝ : α
f✝ : β a✝ → WType β
⊢ 0 < (mk a✝ f✝).depth
state_after: no goals
Theorem: Real.negMulLog_mul
File: Mathlib/Analysis/SpecialFunctions/Log/NegMulLog.lean

tactic: simp only [negMulLog, neg_mul, neg_add_rev]
state_before: x y : ℝ
⊢ (x * y).negMulLog = y * x.negMulLog + x * y.negMulLog
state_after: x y : ℝ
⊢ -(x * y * log (x * y)) = y * -(x * log x) + x * -(y * log y)

tactic: by_cases hx : x = 0
state_before: x y : ℝ
⊢ -(x * y * log (x * y)) = y * -(x * log x) + x * -(y * log y)
state_after: case pos
x y : ℝ
hx : x = 0
⊢ -(x * y * log (x * y)) = y * -(x * log x) + x * -(y * log y)

case neg
x y : ℝ
hx : ¬x = 0
⊢ -(x * y * log (x * y)) = y * -(x * log x) + x * -(y * log y)

tactic: by_cases hy : y = 0
state_before: case neg
x y : ℝ
hx : ¬x = 0
⊢ -(x * y * log (x * y)) = y * -(x * log x) + x * -(y * log y)
state_after: case pos
x y : ℝ
hx : ¬x = 0
hy : y = 0
⊢ -(x * y * log (x * y)) = y * -(x * log x) + x * -(y * log y)

case neg
x y : ℝ
hx : ¬x = 0
hy : ¬y = 0
⊢ -(x * y * log (x * y)) = y * -(x * log x) + x * -(y * log y)

tactic: rw [log_mul hx hy]
state_before: case neg
x y : ℝ
hx : ¬x = 0
hy : ¬y = 0
⊢ -(x * y * log (x * y)) = y * -(x * log x) + x * -(y * log y)
state_after: case neg
x y : ℝ
hx : ¬x = 0
hy : ¬y = 0
⊢ -(x * y * (log x + log y)) = y * -(x * log x) + x * -(y * log y)

tactic: ring
state_before: case neg
x y : ℝ
hx : ¬x = 0
hy : ¬y = 0
⊢ -(x * y * (log x + log y)) = y * -(x * log x) + x * -(y * log y)
state_after: no goals

tactic: simp [hx]
state_before: case pos
x y : ℝ
hx : x = 0
⊢ -(x * y * log (x * y)) = y * -(x * log x) + x * -(y * log y)
state_after: no goals

tactic: simp [hy]
state_before: case pos
x y : ℝ
hx : ¬x = 0
hy : y = 0
⊢ -(x * y * log (x * y)) = y * -(x * log x) + x * -(y * log y)
state_after: no goals
Theorem: vadd_vsub_vadd_cancel_left
File: Mathlib/Algebra/AddTorsor.lean

tactic: rw [vsub_vadd_eq_vsub_sub, vadd_vsub_assoc, add_sub_cancel_left]
state_before: G : Type u_1
P : Type u_2
inst✝¹ : AddCommGroup G
inst✝ : AddTorsor G P
v : G
p₁ p₂ : P
⊢ v +ᵥ p₁ -ᵥ (v +ᵥ p₂) = p₁ -ᵥ p₂
state_after: no goals
Theorem: MeasureTheory.IsSetSemiring.empty_not_mem_diffFinset
File: Mathlib/MeasureTheory/SetSemiring.lean

tactic: classical
simp only [diffFinset, mem_sdiff, Finset.mem_singleton, eq_self_iff_true, not_true,
  and_false_iff, not_false_iff]
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
hC : IsSetSemiring C
hs : s ∈ C
ht : t ∈ C
⊢ ∅ ∉ hC.diffFinset hs ht
state_after: no goals

tactic: simp only [diffFinset, mem_sdiff, Finset.mem_singleton, eq_self_iff_true, not_true,
  and_false_iff, not_false_iff]
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
hC : IsSetSemiring C
hs : s ∈ C
ht : t ∈ C
⊢ ∅ ∉ hC.diffFinset hs ht
state_after: no goals
Theorem: NonUnitalSubalgebra.star_adjoin_comm
File: Mathlib/Algebra/Star/NonUnitalSubalgebra.lean

tactic: simpa only [star_star] using NonUnitalSubalgebra.star_mono (this (star s))
state_before: F : Type v'
R' : Type u'
R : Type u
A : Type v
B : Type w
C : Type w'
inst✝¹³ : CommSemiring R
inst✝¹² : StarRing R
inst✝¹¹ : NonUnitalSemiring A
inst✝¹⁰ : StarRing A
inst✝⁹ : Module R A
inst✝⁸ : IsScalarTower R A A
inst✝⁷ : SMulCommClass R A A
inst✝⁶ : StarModule R A
inst✝⁵ : NonUnitalSemiring B
inst✝⁴ : StarRing B
inst✝³ : Module R B
inst✝² : IsScalarTower R B B
inst✝¹ : SMulCommClass R B B
inst✝ : StarModule R B
s : Set A
this : ∀ (t : Set A), NonUnitalAlgebra.adjoin R (star t) ≤ star (NonUnitalAlgebra.adjoin R t)
⊢ star (NonUnitalAlgebra.adjoin R s) ≤ NonUnitalAlgebra.adjoin R (star s)
state_after: no goals
Theorem: RelEmbedding.eq_preimage
File: Mathlib/Order/RelIso/Basic.lean

tactic: ext a b
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
f : r ↪r s
⊢ r = ⇑f ⁻¹'o s
state_after: case h.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
f : r ↪r s
a b : α
⊢ r a b ↔ (⇑f ⁻¹'o s) a b

tactic: exact f.map_rel_iff.symm
state_before: case h.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
f : r ↪r s
a b : α
⊢ r a b ↔ (⇑f ⁻¹'o s) a b
state_after: no goals
Theorem: FractionalIdeal.map_map_symm
File: Mathlib/RingTheory/FractionalIdeal/Operations.lean

tactic: rw [← map_comp, g.symm_comp, map_id]
state_before: R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
P' : Type u_3
inst✝³ : CommRing P'
inst✝² : Algebra R P'
loc' : IsLocalization S P'
P'' : Type u_4
inst✝¹ : CommRing P''
inst✝ : Algebra R P''
loc'' : IsLocalization S P''
I J : FractionalIdeal S P
g✝ : P →ₐ[R] P'
g : P ≃ₐ[R] P'
⊢ map (↑g.symm) (map (↑g) I) = I
state_after: no goals
Theorem: Matroid.comapOn_preimage_eq
File: Mathlib/Data/Matroid/Map.lean

tactic: rw [comapOn, restrict_eq_self_iff]
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E✝ I✝ s : Set α
M : Matroid α
N✝ : Matroid β
E B I : Set α
N : Matroid β
f : α → β
⊢ N.comapOn (f ⁻¹' N.E) f = N.comap f
state_after: α : Type u_1
β : Type u_2
f✝ : α → β
E✝ I✝ s : Set α
M : Matroid α
N✝ : Matroid β
E B I : Set α
N : Matroid β
f : α → β
⊢ f ⁻¹' N.E = (N.comap f).E

tactic: rfl
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E✝ I✝ s : Set α
M : Matroid α
N✝ : Matroid β
E B I : Set α
N : Matroid β
f : α → β
⊢ f ⁻¹' N.E = (N.comap f).E
state_after: no goals
Theorem: Filter.lift'_iInf_of_map_univ
File: Mathlib/Order/Filter/Lift.lean

tactic: simp only [inf_principal, comp, hg]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f✝ f₁ f₂ : Filter α
h h₁ h₂ : Set α → Set β
f : ι → Filter α
g : Set α → Set β
hg : ∀ {s t : Set α}, g (s ∩ t) = g s ∩ g t
hg' : g univ = univ
s t : Set α
⊢ (𝓟 ∘ g) (s ∩ t) = (𝓟 ∘ g) s ⊓ (𝓟 ∘ g) t
state_after: no goals

tactic: rw [Function.comp_apply, hg', principal_univ]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f✝ f₁ f₂ : Filter α
h h₁ h₂ : Set α → Set β
f : ι → Filter α
g : Set α → Set β
hg : ∀ {s t : Set α}, g (s ∩ t) = g s ∩ g t
hg' : g univ = univ
⊢ (𝓟 ∘ g) univ = ⊤
state_after: no goals
Theorem: NonUnitalAlgHom.mk_coe
File: Mathlib/Algebra/Algebra/NonUnitalHom.lean

tactic: rfl
state_before: R : Type u
S : Type u₁
T : Type u_1
inst✝⁸ : Monoid R
inst✝⁷ : Monoid S
inst✝⁶ : Monoid T
φ : R →* S
A : Type v
B : Type w
C : Type w₁
inst✝⁵ : NonUnitalNonAssocSemiring A
inst✝⁴ : DistribMulAction R A
inst✝³ : NonUnitalNonAssocSemiring B
inst✝² : DistribMulAction S B
inst✝¹ : NonUnitalNonAssocSemiring C
inst✝ : DistribMulAction T C
f : A →ₛₙₐ[φ] B
h₁ : ∀ (m : R) (x : A), f (m • x) = φ m • f x
h₂ : { toFun := ⇑f, map_smul' := h₁ }.toFun 0 = 0
h₃ :
  ∀ (x y : A),
    { toFun := ⇑f, map_smul' := h₁ }.toFun (x + y) =
      { toFun := ⇑f, map_smul' := h₁ }.toFun x + { toFun := ⇑f, map_smul' := h₁ }.toFun y
h₄ :
  ∀ (x y : A),
    { toFun := ⇑f, map_smul' := h₁, map_zero' := h₂, map_add' := h₃ }.toFun (x * y) =
      { toFun := ⇑f, map_smul' := h₁, map_zero' := h₂, map_add' := h₃ }.toFun x *
        { toFun := ⇑f, map_smul' := h₁, map_zero' := h₂, map_add' := h₃ }.toFun y
⊢ { toFun := ⇑f, map_smul' := h₁, map_zero' := h₂, map_add' := h₃, map_mul' := h₄ } = f
state_after: no goals
Theorem: Ordinal.nadd_nat
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

tactic: induction' n with n hn
state_before: a b c : Ordinal.{u}
n : ℕ
⊢ a ♯ ↑n = a + ↑n
state_after: case zero
a b c : Ordinal.{u}
⊢ a ♯ ↑0 = a + ↑0

case succ
a b c : Ordinal.{u}
n : ℕ
hn : a ♯ ↑n = a + ↑n
⊢ a ♯ ↑(n + 1) = a + ↑(n + 1)

tactic: simp
state_before: case zero
a b c : Ordinal.{u}
⊢ a ♯ ↑0 = a + ↑0
state_after: no goals

tactic: rw [Nat.cast_succ, add_one_eq_succ, nadd_succ, add_succ, hn]
state_before: case succ
a b c : Ordinal.{u}
n : ℕ
hn : a ♯ ↑n = a + ↑n
⊢ a ♯ ↑(n + 1) = a + ↑(n + 1)
state_after: no goals
Theorem: IntermediateField.sInf_toSubalgebra
File: Mathlib/FieldTheory/Adjoin.lean

tactic: simp [Set.sUnion_image]
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set (IntermediateField F E)
⊢ ↑(sInf S).toSubalgebra = ↑(sInf (toSubalgebra '' S))
state_after: no goals
Theorem: groupCohomology.mem_range_of_mem_oneCoboundaries
File: Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean

tactic: rcases h with ⟨x, rfl⟩
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
f : ↥(oneCocycles A)
h : f ∈ oneCoboundaries A
⊢ ↑f ∈ LinearMap.range (dZero A)
state_after: case intro
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
x : CoeSort.coe A
⊢ ↑((LinearMap.codRestrict (oneCocycles A) (dZero A) ⋯) x) ∈ LinearMap.range (dZero A)

tactic: exact ⟨x, rfl⟩
state_before: case intro
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
x : CoeSort.coe A
⊢ ↑((LinearMap.codRestrict (oneCocycles A) (dZero A) ⋯) x) ∈ LinearMap.range (dZero A)
state_after: no goals
Theorem: Matrix.rank_submatrix_le
File: Mathlib/Data/Matrix/Rank.lean

tactic: rw [rank, rank, mulVecLin_submatrix, LinearMap.range_comp, LinearMap.range_comp,
  show LinearMap.funLeft R R e.symm = LinearEquiv.funCongrLeft R R e.symm from rfl,
  LinearEquiv.range, Submodule.map_top]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝⁴ : Fintype n
inst✝³ : Fintype o
inst✝² : CommRing R
inst✝¹ : StrongRankCondition R
inst✝ : Fintype m
f : n → m
e : n ≃ m
A : Matrix m m R
⊢ (A.submatrix f ⇑e).rank ≤ A.rank
state_after: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝⁴ : Fintype n
inst✝³ : Fintype o
inst✝² : CommRing R
inst✝¹ : StrongRankCondition R
inst✝ : Fintype m
f : n → m
e : n ≃ m
A : Matrix m m R
⊢ finrank R ↥(Submodule.map (LinearMap.funLeft R R f) (LinearMap.range A.mulVecLin)) ≤
    finrank R ↥(LinearMap.range A.mulVecLin)

tactic: exact Submodule.finrank_map_le _ _
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝⁴ : Fintype n
inst✝³ : Fintype o
inst✝² : CommRing R
inst✝¹ : StrongRankCondition R
inst✝ : Fintype m
f : n → m
e : n ≃ m
A : Matrix m m R
⊢ finrank R ↥(Submodule.map (LinearMap.funLeft R R f) (LinearMap.range A.mulVecLin)) ≤
    finrank R ↥(LinearMap.range A.mulVecLin)
state_after: no goals
Theorem: MeasureTheory.integral_diff
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: rw [eq_sub_iff_add_eq, ← integral_union, diff_union_of_subset hts]
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
ht : MeasurableSet t
hfs : IntegrableOn f s μ
hts : t ⊆ s
⊢ ∫ (x : X) in s \ t, f x ∂μ = ∫ (x : X) in s, f x ∂μ - ∫ (x : X) in t, f x ∂μ
state_after: case hst
X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
ht : MeasurableSet t
hfs : IntegrableOn f s μ
hts : t ⊆ s
⊢ Disjoint (s \ t) t

case ht
X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
ht : MeasurableSet t
hfs : IntegrableOn f s μ
hts : t ⊆ s
⊢ MeasurableSet t

case hfs
X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
ht : MeasurableSet t
hfs : IntegrableOn f s μ
hts : t ⊆ s
⊢ IntegrableOn f (s \ t) μ

case hft
X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
ht : MeasurableSet t
hfs : IntegrableOn f s μ
hts : t ⊆ s
⊢ IntegrableOn f t μ

tactic: exacts [disjoint_sdiff_self_left, ht, hfs.mono_set diff_subset, hfs.mono_set hts]
state_before: case hst
X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
ht : MeasurableSet t
hfs : IntegrableOn f s μ
hts : t ⊆ s
⊢ Disjoint (s \ t) t

case ht
X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
ht : MeasurableSet t
hfs : IntegrableOn f s μ
hts : t ⊆ s
⊢ MeasurableSet t

case hfs
X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
ht : MeasurableSet t
hfs : IntegrableOn f s μ
hts : t ⊆ s
⊢ IntegrableOn f (s \ t) μ

case hft
X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
ht : MeasurableSet t
hfs : IntegrableOn f s μ
hts : t ⊆ s
⊢ IntegrableOn f t μ
state_after: no goals
Theorem: Cardinal.aleph_zero
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rw [aleph, add_zero, aleph'_omega]
state_before: ⊢ aleph 0 = ℵ₀
state_after: no goals
Theorem: Ring.inverse_unit
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

tactic: rw [inverse, dif_pos u.isUnit, IsUnit.unit_of_val_units]
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : MonoidWithZero M₀
u : M₀ˣ
⊢ inverse ↑u = ↑u⁻¹
state_after: no goals
Theorem: CategoryTheory.IsHomLift.eqToHom_domain_lift_id
File: Mathlib/CategoryTheory/FiberedCategory/HomLift.lean

tactic: subst hR hab
state_before: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p✝ p : 𝒳 ⥤ 𝒮
a b : 𝒳
hab : a = b
R : 𝒮
hR : p.obj a = R
⊢ p.IsHomLift (𝟙 R) (eqToHom hab)
state_after: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p✝ p : 𝒳 ⥤ 𝒮
a : 𝒳
⊢ p.IsHomLift (𝟙 (p.obj a)) (eqToHom ⋯)

tactic: simp
state_before: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p✝ p : 𝒳 ⥤ 𝒮
a : 𝒳
⊢ p.IsHomLift (𝟙 (p.obj a)) (eqToHom ⋯)
state_after: no goals
Theorem: YoungDiagram.rowLens_length_ofRowLens
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

tactic: simp only [length_rowLens, colLen, Nat.find_eq_iff, mem_cells, mem_ofRowLens,
  lt_self_iff_false, IsEmpty.exists_iff, Classical.not_not]
state_before: w : List ℕ
hw : List.Sorted (fun x x_1 => x ≥ x_1) w
hpos : ∀ x ∈ w, 0 < x
⊢ (ofRowLens w hw).rowLens.length = w.length
state_after: w : List ℕ
hw : List.Sorted (fun x x_1 => x ≥ x_1) w
hpos : ∀ x ∈ w, 0 < x
⊢ ¬False ∧ ∀ n < w.length, ∃ (h : n < w.length), 0 < w.get ⟨n, ⋯⟩

tactic: exact ⟨not_false, fun n hn => ⟨hn, hpos _ (List.get_mem _ _ hn)⟩⟩
state_before: w : List ℕ
hw : List.Sorted (fun x x_1 => x ≥ x_1) w
hpos : ∀ x ∈ w, 0 < x
⊢ ¬False ∧ ∀ n < w.length, ∃ (h : n < w.length), 0 < w.get ⟨n, ⋯⟩
state_after: no goals
Theorem: NNReal.tendsto_pow_atTop_nhds_zero_iff
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: simpa [coe_pow, coe_zero, abs_eq, coe_lt_one, val_eq_coe] using
tendsto_pow_atTop_nhds_zero_iff.mp <| tendsto_coe.mpr h
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
r : ℝ≥0
h : Tendsto (fun n => r ^ n) atTop (𝓝 0)
⊢ r < 1
state_after: no goals
Theorem: Set.image_op_smul
File: Mathlib/Data/Set/Pointwise/SMul.lean

tactic: rw [← image2_smul, ← image2_mul, image2_image_left, image2_swap]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Mul α
s t u : Set α
a : α
⊢ op '' s • t = t * s
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Mul α
s t u : Set α
a : α
⊢ image2 (fun a b => SMul.smul (op b) a) t s = image2 (fun x x_1 => x * x_1) t s

tactic: rfl
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Mul α
s t u : Set α
a : α
⊢ image2 (fun a b => SMul.smul (op b) a) t s = image2 (fun x x_1 => x * x_1) t s
state_after: no goals
Theorem: Set.image_iUnion
File: Mathlib/Data/Set/Lattice.lean

tactic: ext1 x
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β
s : ι → Set α
⊢ f '' ⋃ i, s i = ⋃ i, f '' s i
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β
s : ι → Set α
x : β
⊢ x ∈ f '' ⋃ i, s i ↔ x ∈ ⋃ i, f '' s i

tactic: simp only [mem_image, mem_iUnion, ← exists_and_right, ← exists_and_left]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β
s : ι → Set α
x : β
⊢ x ∈ f '' ⋃ i, s i ↔ x ∈ ⋃ i, f '' s i
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β
s : ι → Set α
x : β
⊢ (∃ x_1 x_2, x_1 ∈ s x_2 ∧ f x_1 = x) ↔ ∃ i, ∃ x_1 ∈ s i, f x_1 = x

tactic: rw [exists_swap]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β
s : ι → Set α
x : β
⊢ (∃ x_1 x_2, x_1 ∈ s x_2 ∧ f x_1 = x) ↔ ∃ i, ∃ x_1 ∈ s i, f x_1 = x
state_after: no goals
Theorem: Set.range_list_map
File: Mathlib/Data/Set/List.lean

tactic: refine antisymm (range_subset_iff.2 fun l => forall_mem_map_iff.2 fun y _ => mem_range_self _)
    fun l hl => ?_
state_before: α : Type u_1
β : Type u_2
l : List α
f : α → β
⊢ range (map f) = {l | ∀ x ∈ l, x ∈ range f}
state_after: α : Type u_1
β : Type u_2
l✝ : List α
f : α → β
l : List β
hl : l ∈ {l | ∀ x ∈ l, x ∈ range f}
⊢ l ∈ range (map f)

tactic: induction' l with a l ihl
state_before: α : Type u_1
β : Type u_2
l✝ : List α
f : α → β
l : List β
hl : l ∈ {l | ∀ x ∈ l, x ∈ range f}
⊢ l ∈ range (map f)
state_after: case nil
α : Type u_1
β : Type u_2
l : List α
f : α → β
hl : [] ∈ {l | ∀ x ∈ l, x ∈ range f}
⊢ [] ∈ range (map f)

case cons
α : Type u_1
β : Type u_2
l✝ : List α
f : α → β
a : β
l : List β
ihl : l ∈ {l | ∀ x ∈ l, x ∈ range f} → l ∈ range (map f)
hl : a :: l ∈ {l | ∀ x ∈ l, x ∈ range f}
⊢ a :: l ∈ range (map f)

tactic: rcases ihl fun x hx => hl x <| subset_cons _ _ hx with ⟨l, rfl⟩
state_before: case cons
α : Type u_1
β : Type u_2
l✝ : List α
f : α → β
a : β
l : List β
ihl : l ∈ {l | ∀ x ∈ l, x ∈ range f} → l ∈ range (map f)
hl : a :: l ∈ {l | ∀ x ∈ l, x ∈ range f}
⊢ a :: l ∈ range (map f)
state_after: case cons.intro
α : Type u_1
β : Type u_2
l✝ : List α
f : α → β
a : β
l : List α
ihl : map f l ∈ {l | ∀ x ∈ l, x ∈ range f} → map f l ∈ range (map f)
hl : a :: map f l ∈ {l | ∀ x ∈ l, x ∈ range f}
⊢ a :: map f l ∈ range (map f)

tactic: rcases hl a (mem_cons_self _ _) with ⟨a, rfl⟩
state_before: case cons.intro
α : Type u_1
β : Type u_2
l✝ : List α
f : α → β
a : β
l : List α
ihl : map f l ∈ {l | ∀ x ∈ l, x ∈ range f} → map f l ∈ range (map f)
hl : a :: map f l ∈ {l | ∀ x ∈ l, x ∈ range f}
⊢ a :: map f l ∈ range (map f)
state_after: case cons.intro.intro
α : Type u_1
β : Type u_2
l✝ : List α
f : α → β
l : List α
ihl : map f l ∈ {l | ∀ x ∈ l, x ∈ range f} → map f l ∈ range (map f)
a : α
hl : f a :: map f l ∈ {l | ∀ x ∈ l, x ∈ range f}
⊢ f a :: map f l ∈ range (map f)

tactic: exact ⟨a :: l, map_cons _ _ _⟩
state_before: case cons.intro.intro
α : Type u_1
β : Type u_2
l✝ : List α
f : α → β
l : List α
ihl : map f l ∈ {l | ∀ x ∈ l, x ∈ range f} → map f l ∈ range (map f)
a : α
hl : f a :: map f l ∈ {l | ∀ x ∈ l, x ∈ range f}
⊢ f a :: map f l ∈ range (map f)
state_after: no goals

tactic: exact ⟨[], rfl⟩
state_before: case nil
α : Type u_1
β : Type u_2
l : List α
f : α → β
hl : [] ∈ {l | ∀ x ∈ l, x ∈ range f}
⊢ [] ∈ range (map f)
state_after: no goals
Theorem: ZNum.cast_succ
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← add_one, cast_add, cast_one]
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
n : ZNum
⊢ ↑n.succ = ↑n + 1
state_after: no goals
Theorem: Filter.frequently_const
File: Mathlib/Order/Filter/Basic.lean

tactic: by_cases p <;> simp [*]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
inst✝ : f.NeBot
p : Prop
⊢ (∃ᶠ (x : α) in f, p) ↔ p
state_after: no goals
Theorem: pos_of_smul_pos_left
File: Mathlib/Algebra/Order/Module/Defs.lean

tactic: rwa [smul_zero]
state_before: α : Type u_1
β : Type u_2
a a₁ a₂ : α
b b₁ b₂ : β
inst✝⁵ : Zero α
inst✝⁴ : Zero β
inst✝³ : SMulZeroClass α β
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : PosSMulReflectLT α β
h : 0 < a • b
ha : 0 ≤ a
⊢ a • 0 < a • b
state_after: no goals