ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: support_fderiv_subset
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
x✝ x : E
⊢ x ∈ support (fderiv 𝕜 f) → x ∈ tsupport f
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
x✝ x : E
⊢ x ∉ tsupport f → fderiv 𝕜 f x = 0
tactic: rw [← not_imp_not, nmem_support]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
x✝ x : E
⊢ x ∉ tsupport f → fderiv 𝕜 f x = 0
state_after: no goals
tactic: exact fderiv_of_not_mem_tsupport _
Theorem: Set.mulIndicator_diff'
File: Mathlib/Algebra/Group/Indicator.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
inst✝ : Group G
s t : Set α
f✝ g : α → G
a : α
h : s ⊆ t
f : α → G
⊢ (t \ s).mulIndicator f = t.mulIndicator f / s.mulIndicator f
state_after: no goals
tactic: rw [mulIndicator_diff h, div_eq_mul_inv]
Theorem: Real.eq_Gamma_of_log_convex
File: Mathlib/Analysis/SpecialFunctions/Gamma/BohrMollerup.lean

Proof steps:
state_before: f : ℝ → ℝ
hf_conv : ConvexOn ℝ (Ioi 0) (log ∘ f)
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = y * f y
hf_pos : ∀ {y : ℝ}, 0 < y → 0 < f y
hf_one : f 1 = 1
⊢ EqOn f Gamma (Ioi 0)
state_after: f : ℝ → ℝ
hf_conv : ConvexOn ℝ (Ioi 0) (log ∘ f)
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = y * f y
hf_pos : ∀ {y : ℝ}, 0 < y → 0 < f y
hf_one : f 1 = 1
⊢ EqOn (log ∘ f) (log ∘ Gamma) (Ioi 0)
tactic: suffices EqOn (log ∘ f) (log ∘ Gamma) (Ioi (0 : ℝ)) from
    fun x hx ↦ log_injOn_pos (hf_pos hx) (Gamma_pos_of_pos hx) (this hx)
state_before: f : ℝ → ℝ
hf_conv : ConvexOn ℝ (Ioi 0) (log ∘ f)
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = y * f y
hf_pos : ∀ {y : ℝ}, 0 < y → 0 < f y
hf_one : f 1 = 1
⊢ EqOn (log ∘ f) (log ∘ Gamma) (Ioi 0)
state_after: f : ℝ → ℝ
hf_conv : ConvexOn ℝ (Ioi 0) (log ∘ f)
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = y * f y
hf_pos : ∀ {y : ℝ}, 0 < y → 0 < f y
hf_one : f 1 = 1
x : ℝ
hx : x ∈ Ioi 0
⊢ (log ∘ f) x = (log ∘ Gamma) x
tactic: intro x hx
state_before: f : ℝ → ℝ
hf_conv : ConvexOn ℝ (Ioi 0) (log ∘ f)
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = y * f y
hf_pos : ∀ {y : ℝ}, 0 < y → 0 < f y
hf_one : f 1 = 1
x : ℝ
hx : x ∈ Ioi 0
⊢ (log ∘ f) x = (log ∘ Gamma) x
state_after: case refine_2
f : ℝ → ℝ
hf_conv : ConvexOn ℝ (Ioi 0) (log ∘ f)
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = y * f y
hf_pos : ∀ {y : ℝ}, 0 < y → 0 < f y
hf_one : f 1 = 1
x : ℝ
hx : x ∈ Ioi 0
e1 : Tendsto (BohrMollerup.logGammaSeq x) atTop (𝓝 ((log ∘ f) x - (log ∘ f) 1))
⊢ (log ∘ f) x = (log ∘ Gamma) x

case refine_1
f : ℝ → ℝ
hf_conv : ConvexOn ℝ (Ioi 0) (log ∘ f)
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = y * f y
hf_pos : ∀ {y : ℝ}, 0 < y → 0 < f y
hf_one : f 1 = 1
x : ℝ
hx : x ∈ Ioi 0
⊢ ∀ {y : ℝ}, 0 < y → (log ∘ f) (y + 1) = (log ∘ f) y + log y
tactic: have e1 := BohrMollerup.tendsto_logGammaSeq hf_conv ?_ hx
Theorem: Subgroup.range_mem_rightTransversals
File: Mathlib/GroupTheory/Complement.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
f : Quotient (QuotientGroup.rightRel H) → G
hf : ∀ (q : Quotient (QuotientGroup.rightRel H)), Quotient.mk'' (f q) = q
⊢ Function.Injective ((range f).restrict Quotient.mk'')
state_after: case mk.intro.mk.intro
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
f : Quotient (QuotientGroup.rightRel H) → G
hf : ∀ (q : Quotient (QuotientGroup.rightRel H)), Quotient.mk'' (f q) = q
q₁ q₂ : Quotient (QuotientGroup.rightRel H)
h : (range f).restrict Quotient.mk'' ⟨f q₁, ⋯⟩ = (range f).restrict Quotient.mk'' ⟨f q₂, ⋯⟩
⊢ ⟨f q₁, ⋯⟩ = ⟨f q₂, ⋯⟩
tactic: rintro ⟨-, q₁, rfl⟩ ⟨-, q₂, rfl⟩ h
state_before: case mk.intro.mk.intro
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
f : Quotient (QuotientGroup.rightRel H) → G
hf : ∀ (q : Quotient (QuotientGroup.rightRel H)), Quotient.mk'' (f q) = q
q₁ q₂ : Quotient (QuotientGroup.rightRel H)
h : (range f).restrict Quotient.mk'' ⟨f q₁, ⋯⟩ = (range f).restrict Quotient.mk'' ⟨f q₂, ⋯⟩
⊢ ⟨f q₁, ⋯⟩ = ⟨f q₂, ⋯⟩
state_after: no goals
tactic: exact Subtype.ext <| congr_arg f <| ((hf q₁).symm.trans h).trans (hf q₂)
Theorem: String.Iterator.Valid.setCurr
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: c : Char
it : Iterator
h : it.Valid
⊢ (it.setCurr c).Valid
state_after: c : Char
it : Iterator
h✝ : it.Valid
l r : List Char
h : ValidFor l r it
⊢ (it.setCurr c).Valid
tactic: let ⟨l, r, h⟩ := h.validFor
state_before: c : Char
it : Iterator
h✝ : it.Valid
l r : List Char
h : ValidFor l r it
⊢ (it.setCurr c).Valid
state_after: no goals
tactic: exact h.setCurr'.valid
Theorem: eq_star_of_eq_star
File: Mathlib/Algebra/Star/Basic.lean

Proof steps:
state_before: R : Type u
inst✝ : InvolutiveStar R
r s : R
h : r = star s
⊢ s = star r
state_after: no goals
tactic: simp [h]
Theorem: Fintype.card_option
File: Mathlib/Data/Fintype/Option.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
α : Type u_4
inst✝ : Fintype α
⊢ none ∉ map Embedding.some univ
state_after: no goals
tactic: simp
Theorem: Even.pow_nonneg
File: Mathlib/Algebra/Order/Ring/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝¹ : LinearOrderedSemiring R
a✝ b : R
m n : ℕ
inst✝ : ExistsAddOfLE R
hn : Even n
a : R
⊢ 0 ≤ a ^ n
state_after: case intro
α : Type u_1
M : Type u_2
R : Type u_3
inst✝¹ : LinearOrderedSemiring R
a✝ b : R
m : ℕ
inst✝ : ExistsAddOfLE R
a : R
k : ℕ
⊢ 0 ≤ a ^ (k + k)
tactic: obtain ⟨k, rfl⟩ := hn
state_before: case intro
α : Type u_1
M : Type u_2
R : Type u_3
inst✝¹ : LinearOrderedSemiring R
a✝ b : R
m : ℕ
inst✝ : ExistsAddOfLE R
a : R
k : ℕ
⊢ 0 ≤ a ^ (k + k)
state_after: case intro
α : Type u_1
M : Type u_2
R : Type u_3
inst✝¹ : LinearOrderedSemiring R
a✝ b : R
m : ℕ
inst✝ : ExistsAddOfLE R
a : R
k : ℕ
⊢ 0 ≤ a ^ k * a ^ k
tactic: rw [pow_add]
state_before: case intro
α : Type u_1
M : Type u_2
R : Type u_3
inst✝¹ : LinearOrderedSemiring R
a✝ b : R
m : ℕ
inst✝ : ExistsAddOfLE R
a : R
k : ℕ
⊢ 0 ≤ a ^ k * a ^ k
state_after: no goals
tactic: exact mul_self_nonneg _
Theorem: Complex.IsExpCmpFilter.isLittleO_pow_mul_exp
File: Mathlib/Analysis/SpecialFunctions/CompareExp.lean

Proof steps:
state_before: l : Filter ℂ
b₁ b₂ : ℝ
hl : IsExpCmpFilter l
hb : b₁ < b₂
m n : ℕ
⊢ (fun z => z ^ m * cexp (↑b₁ * z)) =o[l] fun z => z ^ n * cexp (↑b₂ * z)
state_after: no goals
tactic: simpa only [cpow_natCast] using hl.isLittleO_cpow_mul_exp hb m n
Theorem: CategoryTheory.ShortComplex.LeftHomologyData.ofZeros_f'
File: Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.LeftHomologyData
A : C
hf : S.f = 0
hg : S.g = 0
⊢ (ofZeros S hf hg).f' = 0
state_after: no goals
tactic: rw [← cancel_mono ((ofZeros S hf hg).i), zero_comp, f'_i, hf]
Theorem: FreeMagma.hom_ext
File: Mathlib/Algebra/Free.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : Mul β
f g : FreeMagma α →ₙ* β
h : ⇑f ∘ of = ⇑g ∘ of
x : FreeMagma α
⊢ ∀ (x y : FreeMagma α), f x = g x → f y = g y → f (x * y) = g (x * y)
state_after: α : Type u
β : Type v
inst✝ : Mul β
f g : FreeMagma α →ₙ* β
h : ⇑f ∘ of = ⇑g ∘ of
x x✝ y✝ : FreeMagma α
a✝¹ : f x✝ = g x✝
a✝ : f y✝ = g y✝
⊢ f (x✝ * y✝) = g (x✝ * y✝)
tactic: intros
state_before: α : Type u
β : Type v
inst✝ : Mul β
f g : FreeMagma α →ₙ* β
h : ⇑f ∘ of = ⇑g ∘ of
x x✝ y✝ : FreeMagma α
a✝¹ : f x✝ = g x✝
a✝ : f y✝ = g y✝
⊢ f (x✝ * y✝) = g (x✝ * y✝)
state_after: no goals
tactic: simp only [map_mul, *]
Theorem: ENNReal.sub_div
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
h : 0 < b → b < a → c ≠ 0
⊢ (a - b) / c = a / c - b / c
state_after: a b c d : ℝ≥0∞
r p q : ℝ≥0
h : 0 < b → b < a → c ≠ 0
⊢ (a - b) * c⁻¹ = a * c⁻¹ - b * c⁻¹
tactic: simp_rw [div_eq_mul_inv]
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
h : 0 < b → b < a → c ≠ 0
⊢ (a - b) * c⁻¹ = a * c⁻¹ - b * c⁻¹
state_after: no goals
tactic: exact ENNReal.sub_mul (by simpa using h)
Theorem: Set.image_eq_iUnion
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
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 α
b : β
⊢ b ∈ f '' s ↔ b ∈ ⋃ i ∈ s, {f i}
state_after: no goals
tactic: simp [@eq_comm β b]
Theorem: String.modify_of_valid
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: f : Char → Char
cs cs' : List Char
⊢ { data := cs ++ cs' }.modify { byteIdx := utf8Len cs } f = { data := cs ++ List.modifyHead f cs' }
state_after: f : Char → Char
cs cs' : List Char
⊢ { data := cs ++ List.modifyHead (fun x => f (cs'.headD default)) cs' } = { data := cs ++ List.modifyHead f cs' }
tactic: rw [modify, set_of_valid, get_of_valid]
state_before: f : Char → Char
cs cs' : List Char
⊢ { data := cs ++ List.modifyHead (fun x => f (cs'.headD default)) cs' } = { data := cs ++ List.modifyHead f cs' }
state_after: no goals
tactic: cases cs' <;> rfl
Theorem: Matroid.map_image_base_iff
File: Mathlib/Data/Matroid/Map.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f : α → β
E I s : Set α
M : Matroid α
N : Matroid β
hf : InjOn f M.E
B : Set α
hB : B ⊆ M.E
⊢ (M.map f hf).Base (f '' B) ↔ M.Base B
state_after: α : Type u_1
β : Type u_2
f : α → β
E I s : Set α
M : Matroid α
N : Matroid β
hf : InjOn f M.E
B : Set α
hB : B ⊆ M.E
⊢ (∃ B₀, M.Base B₀ ∧ f '' B = f '' B₀) ↔ M.Base B
tactic: rw [map_base_iff]
state_before: α : Type u_1
β : Type u_2
f : α → β
E I s : Set α
M : Matroid α
N : Matroid β
hf : InjOn f M.E
B : Set α
hB : B ⊆ M.E
⊢ (∃ B₀, M.Base B₀ ∧ f '' B = f '' B₀) ↔ M.Base B
state_after: α : Type u_1
β : Type u_2
f : α → β
E I s : Set α
M : Matroid α
N : Matroid β
hf : InjOn f M.E
B : Set α
hB : B ⊆ M.E
x✝ : ∃ B₀, M.Base B₀ ∧ f '' B = f '' B₀
J : Set α
hJ : M.Base J
hIJ : f '' B = f '' J
⊢ M.Base B
tactic: refine ⟨fun ⟨J, hJ, hIJ⟩ ↦ ?_, fun h ↦ ⟨B, h, rfl⟩⟩
state_before: α : Type u_1
β : Type u_2
f : α → β
E I s : Set α
M : Matroid α
N : Matroid β
hf : InjOn f M.E
B : Set α
hB : B ⊆ M.E
x✝ : ∃ B₀, M.Base B₀ ∧ f '' B = f '' B₀
J : Set α
hJ : M.Base J
hIJ : f '' B = f '' J
⊢ M.Base B
state_after: α : Type u_1
β : Type u_2
f : α → β
E I s : Set α
M : Matroid α
N : Matroid β
hf : InjOn f M.E
B : Set α
hB : B ⊆ M.E
x✝ : ∃ B₀, M.Base B₀ ∧ f '' B = f '' B₀
J : Set α
hJ : M.Base J
hIJ : B = J
⊢ M.Base B
tactic: rw [hf.image_eq_image_iff hB hJ.subset_ground] at hIJ
state_before: α : Type u_1
β : Type u_2
f : α → β
E I s : Set α
M : Matroid α
N : Matroid β
hf : InjOn f M.E
B : Set α
hB : B ⊆ M.E
x✝ : ∃ B₀, M.Base B₀ ∧ f '' B = f '' B₀
J : Set α
hJ : M.Base J
hIJ : B = J
⊢ M.Base B
state_after: no goals
tactic: rwa [hIJ]
Theorem: Set.Finite.interior_biInter
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι✝ : Sort w
α : Type u_1
β : Type u_2
x : X
s✝ s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
ι : Type u_3
s : Set ι
hs : s.Finite
f : ι → Set X
⊢ interior (⋂ i ∈ ∅, f i) = ⋂ i ∈ ∅, interior (f i)
state_after: no goals
tactic: simp
state_before: X : Type u
Y : Type v
ι✝ : Sort w
α : Type u_1
β : Type u_2
x : X
s✝ s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
ι : Type u_3
s : Set ι
hs : s.Finite
f : ι → Set X
⊢ ∀ {a : ι} {s : Set ι},
    a ∉ s →
      s.Finite →
        interior (⋂ i ∈ s, f i) = ⋂ i ∈ s, interior (f i) →
          interior (⋂ i ∈ insert a s, f i) = ⋂ i ∈ insert a s, interior (f i)
state_after: X : Type u
Y : Type v
ι✝ : Sort w
α : Type u_1
β : Type u_2
x : X
s✝¹ s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
ι : Type u_3
s : Set ι
hs : s.Finite
f : ι → Set X
a✝³ : ι
s✝ : Set ι
a✝² : a✝³ ∉ s✝
a✝¹ : s✝.Finite
a✝ : interior (⋂ i ∈ s✝, f i) = ⋂ i ∈ s✝, interior (f i)
⊢ interior (⋂ i ∈ insert a✝³ s✝, f i) = ⋂ i ∈ insert a✝³ s✝, interior (f i)
tactic: intros
state_before: X : Type u
Y : Type v
ι✝ : Sort w
α : Type u_1
β : Type u_2
x : X
s✝¹ s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
ι : Type u_3
s : Set ι
hs : s.Finite
f : ι → Set X
a✝³ : ι
s✝ : Set ι
a✝² : a✝³ ∉ s✝
a✝¹ : s✝.Finite
a✝ : interior (⋂ i ∈ s✝, f i) = ⋂ i ∈ s✝, interior (f i)
⊢ interior (⋂ i ∈ insert a✝³ s✝, f i) = ⋂ i ∈ insert a✝³ s✝, interior (f i)
state_after: no goals
tactic: simp [*]
Theorem: CategoryTheory.MonoidalCategory.eqToHom_whiskerRight
File: Mathlib/CategoryTheory/Monoidal/Category.lean

Proof steps:
state_before: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
U V W X✝ Y✝ Z✝ X Y : C
f : X = Y
Z : C
⊢ eqToHom f ▷ Z = eqToHom ⋯
state_after: case refl
C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
U V W X✝ Y Z✝ X Z : C
⊢ eqToHom ⋯ ▷ Z = eqToHom ⋯
tactic: cases f
state_before: case refl
C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
U V W X✝ Y Z✝ X Z : C
⊢ eqToHom ⋯ ▷ Z = eqToHom ⋯
state_after: no goals
tactic: simp only [id_whiskerRight, eqToHom_refl]
Theorem: Filter.EventuallyEq.sub_eq
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
inst✝ : AddGroup β
f g : α → β
l : Filter α
h : f =ᶠ[l] g
⊢ f - g =ᶠ[l] 0
state_after: no goals
tactic: simpa using ((EventuallyEq.refl l f).sub h).symm
Theorem: convexJoin_segments
File: Mathlib/Analysis/Convex/Join.lean

Proof steps:
state_before: ι : Sort u_1
𝕜 : Type u_2
E : Type u_3
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t u : Set E
x y a b c d : E
⊢ convexJoin 𝕜 (segment 𝕜 a b) (segment 𝕜 c d) = (convexHull 𝕜) {a, b, c, d}
state_after: no goals
tactic: simp_rw [← convexHull_pair, convexHull_insert (insert_nonempty _ _),
    convexHull_insert (singleton_nonempty _), convexJoin_assoc,
    convexHull_singleton]
Theorem: ContinuousMap.equivBoundedOfCompact_symm_apply
File: Mathlib/Topology/ContinuousFunction/Compact.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : CompactSpace α
inst✝¹ : MetricSpace β
inst✝ : NormedAddCommGroup E
f : C(α, β)
⊢ (mkOfCompact f).toContinuousMap = f
state_after: case h
α : Type u_1
β : Type u_2
E : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : CompactSpace α
inst✝¹ : MetricSpace β
inst✝ : NormedAddCommGroup E
f : C(α, β)
a✝ : α
⊢ (mkOfCompact f).toContinuousMap a✝ = f a✝
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
E : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : CompactSpace α
inst✝¹ : MetricSpace β
inst✝ : NormedAddCommGroup E
f : C(α, β)
a✝ : α
⊢ (mkOfCompact f).toContinuousMap a✝ = f a✝
state_after: no goals
tactic: rfl
state_before: α : Type u_1
β : Type u_2
E : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : CompactSpace α
inst✝¹ : MetricSpace β
inst✝ : NormedAddCommGroup E
f : α →ᵇ β
⊢ mkOfCompact f.toContinuousMap = f
state_after: case h
α : Type u_1
β : Type u_2
E : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : CompactSpace α
inst✝¹ : MetricSpace β
inst✝ : NormedAddCommGroup E
f : α →ᵇ β
x✝ : α
⊢ (mkOfCompact f.toContinuousMap) x✝ = f x✝
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
E : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : CompactSpace α
inst✝¹ : MetricSpace β
inst✝ : NormedAddCommGroup E
f : α →ᵇ β
x✝ : α
⊢ (mkOfCompact f.toContinuousMap) x✝ = f x✝
state_after: no goals
tactic: rfl
Theorem: tendsto_measure_Icc_nhdsWithin_right
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s t u : Set α
inst✝¹ : MeasurableSpace α
μ : Measure ℝ
inst✝ : IsFiniteMeasureOnCompacts μ
b : ℝ
⊢ Tendsto (fun δ => μ (Icc (b - δ) (b + δ))) (𝓝[≥] 0) (𝓝 (μ {b}))
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s t u : Set α
inst✝¹ : MeasurableSpace α
μ : Measure ℝ
inst✝ : IsFiniteMeasureOnCompacts μ
b : ℝ
⊢ ∀ s ∈ 𝓝 (μ {b}), μ (Icc (b - 0) (b + 0)) ∈ s
tactic: simp only [← nhdsWithin_right_sup_nhds_singleton, nhdsWithin_singleton, tendsto_sup,
    tendsto_measure_Icc_nhdsWithin_right' μ b, true_and, tendsto_pure_left]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s t u : Set α
inst✝¹ : MeasurableSpace α
μ : Measure ℝ
inst✝ : IsFiniteMeasureOnCompacts μ
b : ℝ
⊢ ∀ s ∈ 𝓝 (μ {b}), μ (Icc (b - 0) (b + 0)) ∈ s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s✝ t u : Set α
inst✝¹ : MeasurableSpace α
μ : Measure ℝ
inst✝ : IsFiniteMeasureOnCompacts μ
b : ℝ
s : Set ℝ≥0∞
hs : s ∈ 𝓝 (μ {b})
⊢ μ (Icc (b - 0) (b + 0)) ∈ s
tactic: intro s hs
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s✝ t u : Set α
inst✝¹ : MeasurableSpace α
μ : Measure ℝ
inst✝ : IsFiniteMeasureOnCompacts μ
b : ℝ
s : Set ℝ≥0∞
hs : s ∈ 𝓝 (μ {b})
⊢ μ (Icc (b - 0) (b + 0)) ∈ s
state_after: no goals
tactic: simpa using mem_of_mem_nhds hs
Theorem: iteratedFDeriv_succ_const
File: Mathlib/Analysis/Calculus/ContDiff/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x✝ x₀ : E
c✝ : F
b : E × F → G
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
c : F
x : E
⊢ iteratedFDeriv 𝕜 (n + 1) (fun x => c) x = 0 x
state_after: no goals
tactic: simpa [← iteratedFDerivWithin_univ] using
    iteratedFDerivWithin_succ_const n c uniqueDiffOn_univ (mem_univ x)
Theorem: Topology.IsScott.monotone_of_continuous
File: Mathlib/Topology/Order/ScottTopology.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : TopologicalSpace α
inst✝³ : IsScott α
s : Set α
a : α
inst✝² : Preorder β
inst✝¹ : TopologicalSpace β
inst✝ : IsScott β
f : α → β
hf : Continuous f
x✝ b : α
hab : x✝ ≤ b
⊢ f x✝ ≤ f b
state_after: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : TopologicalSpace α
inst✝³ : IsScott α
s : Set α
a : α
inst✝² : Preorder β
inst✝¹ : TopologicalSpace β
inst✝ : IsScott β
f : α → β
hf : Continuous f
x✝ b : α
hab : x✝ ≤ b
h : ¬f x✝ ≤ f b
⊢ False
tactic: by_contra h
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : TopologicalSpace α
inst✝³ : IsScott α
s : Set α
a : α
inst✝² : Preorder β
inst✝¹ : TopologicalSpace β
inst✝ : IsScott β
f : α → β
hf : Continuous f
x✝ b : α
hab : x✝ ≤ b
h : ¬f x✝ ≤ f b
⊢ False
state_after: no goals
tactic: simpa only [mem_compl_iff, mem_preimage, mem_Iic, le_refl, not_true]
    using isUpperSet_of_isOpen ((isOpen_compl_iff.2 isClosed_Iic).preimage hf) hab h
Theorem: Fin.sum_univ_five
File: Mathlib/Algebra/BigOperators/Fin.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
f : Fin 5 → β
⊢ ∏ i : Fin 5, f i = f 0 * f 1 * f 2 * f 3 * f 4
state_after: α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
f : Fin 5 → β
⊢ f (castSucc 0) * f (castSucc 1) * f (castSucc 2) * f (castSucc 3) * f (last 4) = f 0 * f 1 * f 2 * f 3 * f 4
tactic: rw [prod_univ_castSucc, prod_univ_four]
state_before: α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
f : Fin 5 → β
⊢ f (castSucc 0) * f (castSucc 1) * f (castSucc 2) * f (castSucc 3) * f (last 4) = f 0 * f 1 * f 2 * f 3 * f 4
state_after: no goals
tactic: rfl
Theorem: LiouvilleNumber.remainder_pos
File: Mathlib/NumberTheory/Liouville/LiouvilleNumber.lean

Proof steps:
state_before: m : ℝ
hm : 1 < m
k x✝ : ℕ
⊢ 0 ≤ 1 / m ^ (x✝ + (k + 1))!
state_after: no goals
tactic: positivity
state_before: m : ℝ
hm : 1 < m
k : ℕ
⊢ 0 < 1 / m ^ (0 + (k + 1))!
state_after: no goals
tactic: positivity
Theorem: Int.map_fract
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝⁵ : LinearOrderedRing α
inst✝⁴ : LinearOrderedRing β
inst✝³ : FloorRing α
inst✝² : FloorRing β
inst✝¹ : FunLike F α β
inst✝ : RingHomClass F α β
a✝ : α
b : β
f : F
hf : StrictMono ⇑f
a : α
⊢ fract (f a) = f (fract a)
state_after: no goals
tactic: simp_rw [fract, map_sub, map_intCast, map_floor _ hf]
Theorem: ProbabilityTheory.Kernel.measure_eq_zero_or_one_of_indepSet_self
File: Mathlib/Probability/Independence/ZeroOne.lean

Proof steps:
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
s : ι → MeasurableSpace Ω
m m0 : MeasurableSpace Ω
κ : Kernel α Ω
μα : Measure α
μ : Measure Ω
inst✝ : ∀ (a : α), IsFiniteMeasure (κ a)
t : Set Ω
h_indep : IndepSet t t κ μα
⊢ ∀ᵐ (a : α) ∂μα, (κ a) t = 0 ∨ (κ a) t = 1
state_after: case h
α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
s : ι → MeasurableSpace Ω
m m0 : MeasurableSpace Ω
κ : Kernel α Ω
μα : Measure α
μ : Measure Ω
inst✝ : ∀ (a : α), IsFiniteMeasure (κ a)
t : Set Ω
h_indep : IndepSet t t κ μα
a : α
h_0_1_top : (κ a) t = 0 ∨ (κ a) t = 1 ∨ (κ a) t = ⊤
⊢ (κ a) t = 0 ∨ (κ a) t = 1
tactic: filter_upwards [measure_eq_zero_or_one_or_top_of_indepSet_self h_indep] with a h_0_1_top
state_before: case h
α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
s : ι → MeasurableSpace Ω
m m0 : MeasurableSpace Ω
κ : Kernel α Ω
μα : Measure α
μ : Measure Ω
inst✝ : ∀ (a : α), IsFiniteMeasure (κ a)
t : Set Ω
h_indep : IndepSet t t κ μα
a : α
h_0_1_top : (κ a) t = 0 ∨ (κ a) t = 1 ∨ (κ a) t = ⊤
⊢ (κ a) t = 0 ∨ (κ a) t = 1
state_after: no goals
tactic: simpa only [measure_ne_top (κ a), or_false] using h_0_1_top
Theorem: AddSubsemigroup.mem_sup_right
File: Mathlib/Algebra/Group/Subsemigroup/Membership.lean

Proof steps:
state_before: ι : Sort u_1
M : Type u_2
A : Type u_3
B : Type u_4
inst✝ : Mul M
S T : Subsemigroup M
⊢ ∀ {x : M}, x ∈ T → x ∈ S ⊔ T
state_after: ι : Sort u_1
M : Type u_2
A : Type u_3
B : Type u_4
inst✝ : Mul M
S T : Subsemigroup M
this : T ≤ S ⊔ T
⊢ ∀ {x : M}, x ∈ T → x ∈ S ⊔ T
tactic: have : T ≤ S ⊔ T := le_sup_right
state_before: ι : Sort u_1
M : Type u_2
A : Type u_3
B : Type u_4
inst✝ : Mul M
S T : Subsemigroup M
this : T ≤ S ⊔ T
⊢ ∀ {x : M}, x ∈ T → x ∈ S ⊔ T
state_after: no goals
tactic: tauto
Theorem: MeasureTheory.vadd_mem_ae
File: Mathlib/MeasureTheory/Group/Action.lean

Proof steps:
state_before: G : Type u
M : Type v
α : Type w
s✝ : Set α
m : MeasurableSpace α
inst✝³ : MeasurableSpace G
inst✝² : Group G
inst✝¹ : MulAction G α
μ : Measure α
inst✝ : SMulInvariantMeasure G α μ
c : G
s : Set α
⊢ c • s ∈ ae μ ↔ s ∈ ae μ
state_after: no goals
tactic: simp only [mem_ae_iff, ← smul_set_compl, measure_smul_eq_zero_iff]
Theorem: MeasureTheory.integrable_llr_tilted_left
File: Mathlib/MeasureTheory/Measure/LogLikelihoodRatio.lean

Proof steps:
state_before: α : Type u_1
mα : MeasurableSpace α
μ ν : Measure α
f : α → ℝ
inst✝¹ : IsFiniteMeasure μ
inst✝ : SigmaFinite ν
hμν : μ ≪ ν
hf : Integrable f μ
h_int : Integrable (llr μ ν) μ
hfμ : Integrable (fun x => rexp (f x)) μ
hfν : AEMeasurable f ν
⊢ Integrable (llr (μ.tilted f) ν) μ
state_after: α : Type u_1
mα : MeasurableSpace α
μ ν : Measure α
f : α → ℝ
inst✝¹ : IsFiniteMeasure μ
inst✝ : SigmaFinite ν
hμν : μ ≪ ν
hf : Integrable f μ
h_int : Integrable (llr μ ν) μ
hfμ : Integrable (fun x => rexp (f x)) μ
hfν : AEMeasurable f ν
⊢ Integrable (fun x => f x - log (∫ (z : α), rexp (f z) ∂μ) + llr μ ν x) μ
tactic: rw [integrable_congr (llr_tilted_left hμν hfμ hfν)]
state_before: α : Type u_1
mα : MeasurableSpace α
μ ν : Measure α
f : α → ℝ
inst✝¹ : IsFiniteMeasure μ
inst✝ : SigmaFinite ν
hμν : μ ≪ ν
hf : Integrable f μ
h_int : Integrable (llr μ ν) μ
hfμ : Integrable (fun x => rexp (f x)) μ
hfν : AEMeasurable f ν
⊢ Integrable (fun x => f x - log (∫ (z : α), rexp (f z) ∂μ) + llr μ ν x) μ
state_after: no goals
tactic: exact Integrable.add (hf.sub (integrable_const _)) h_int