ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Limits.imageSubobject_factors_comp_self
File: Mathlib/CategoryTheory/Subobject/Limits.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
inst✝ : HasImage f
W : C
k : W ⟶ X
⊢ (k ≫ factorThruImage f) ≫ (MonoOver.mk' (image.ι f)).arrow = k ≫ f
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Arrow.mapCechConerve_app
File: Mathlib/AlgebraicTopology/CechNerve.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
f✝ : Arrow C
inst✝² : ∀ (n : ℕ), HasWidePushout f✝.left (fun x => f✝.right) fun x => f✝.hom
f g : Arrow C
inst✝¹ : ∀ (n : ℕ), HasWidePushout f.left (fun x => f.right) fun x => f.hom
inst✝ : ∀ (n : ℕ), HasWidePushout g.left (fun x => g.right) fun x => g.hom
F : f ⟶ g
n : SimplexCategory
i : Fin (n.len + 1)
⊢ g.right ⟶ g.cechConerve.obj n
state_after: no goals
tactic: apply WidePushout.ι _ i
state_before: C : Type u
inst✝³ : Category.{v, u} C
f✝ : Arrow C
inst✝² : ∀ (n : ℕ), HasWidePushout f✝.left (fun x => f✝.right) fun x => f✝.hom
f g : Arrow C
inst✝¹ : ∀ (n : ℕ), HasWidePushout f.left (fun x => f.right) fun x => f.hom
inst✝ : ∀ (n : ℕ), HasWidePushout g.left (fun x => g.right) fun x => g.hom
F : f ⟶ g
n : SimplexCategory
i : Fin (n.len + 1)
⊢ f.hom ≫ (fun i => F.right ≫ WidePushout.ι (fun x => g.hom) i) i = F.left ≫ WidePushout.head fun x => g.hom
state_after: no goals
tactic: rw [← Arrow.w_assoc F, ← WidePushout.arrow_ι]
Theorem: Multiset.Ico_sub_Ico_left
File: Mathlib/Order/Interval/Multiset.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ c✝ d a b c : α
⊢ Ico a b - Ico a c = Ico (max a c) b
state_after: no goals
tactic: rw [Ico, Ico, Ico, ← Finset.sdiff_val, Finset.Ico_diff_Ico_left]
Theorem: LowerSet.erase_eq
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : Preorder α
s : LowerSet α
t : Set α
a : α
⊢ s.erase a = s ↔ a ∉ s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : Preorder α
s : LowerSet α
t : Set α
a : α
⊢ s.sdiff {a} = s ↔ a ∉ s
tactic: rw [← sdiff_singleton]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : Preorder α
s : LowerSet α
t : Set α
a : α
⊢ s.sdiff {a} = s ↔ a ∉ s
state_after: no goals
tactic: simp [-sdiff_singleton]
Theorem: MeasureTheory.measure_trim_toMeasurable_eq_zero
File: Mathlib/MeasureTheory/Measure/Trim.lean

Proof steps:
state_before: α : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
s : Set α
hm : m ≤ m0
hs : (μ.trim hm) s = 0
⊢ (μ.trim hm) (toMeasurable (μ.trim hm) s) = 0
state_after: no goals
tactic: rwa [@measure_toMeasurable _ m]
Theorem: Ordinal.bmex_not_mem_brange
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_4}
f : (a : Ordinal.{u_4}) → a < o → Ordinal.{max u_4 u_5}
⊢ o.bmex f ∉ o.brange f
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_4}
f : (a : Ordinal.{u_4}) → a < o → Ordinal.{max u_4 u_5}
⊢ o.bmex f ∉ range (o.familyOfBFamily f)
tactic: rw [← range_familyOfBFamily]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_4}
f : (a : Ordinal.{u_4}) → a < o → Ordinal.{max u_4 u_5}
⊢ o.bmex f ∉ range (o.familyOfBFamily f)
state_after: no goals
tactic: apply mex_not_mem_range
Theorem: IntermediateField.AdjoinSimple.isIntegral_gen
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
S : Set E
α : E
⊢ IsIntegral F (gen F α) ↔ IsIntegral F α
state_after: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
⊢ IsIntegral F (gen F α) ↔ IsIntegral F ((algebraMap (↥F⟮α⟯) E) (gen F α))
tactic: conv_rhs => rw [← AdjoinSimple.algebraMap_gen F α]
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
⊢ IsIntegral F (gen F α) ↔ IsIntegral F ((algebraMap (↥F⟮α⟯) E) (gen F α))
state_after: no goals
tactic: rw [isIntegral_algebraMap_iff (algebraMap F⟮α⟯ E).injective]
Theorem: Zspan.measure_fundamentalDomain_ne_zero
File: Mathlib/Algebra/Module/Zlattice/Basic.lean

Proof steps:
state_before: E : Type u_1
ι : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
b : Basis ι ℝ E
inst✝³ : Finite ι
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
⊢ μ (fundamentalDomain b) ≠ 0
state_after: E : Type u_1
ι : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
b : Basis ι ℝ E
inst✝³ : Finite ι
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
⊢ Countable ↥(span ℤ (Set.range ⇑b)).toAddSubgroup
tactic: convert (Zspan.isAddFundamentalDomain b μ).measure_ne_zero (NeZero.ne μ)
state_before: E : Type u_1
ι : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
b : Basis ι ℝ E
inst✝³ : Finite ι
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
⊢ Countable ↥(span ℤ (Set.range ⇑b)).toAddSubgroup
state_after: E : Type u_1
ι : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
b : Basis ι ℝ E
inst✝³ : Finite ι
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
⊢ Countable ↥(span ℤ (Set.range ⇑b))
tactic: simp only [mem_toAddSubgroup]
state_before: E : Type u_1
ι : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
b : Basis ι ℝ E
inst✝³ : Finite ι
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
⊢ Countable ↥(span ℤ (Set.range ⇑b))
state_after: no goals
tactic: infer_instance
Theorem: ContinuousLinearMapWOT.embedding_inducingFn
File: Mathlib/Analysis/Normed/Operator/WeakOperatorTopology.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : RCLike 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : TopologicalSpace E
inst✝² : Module 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
⊢ Embedding ⇑(inducingFn 𝕜 E F)
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : RCLike 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : TopologicalSpace E
inst✝² : Module 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
A B : E →WOT[𝕜]F
hAB : (inducingFn 𝕜 E F) A = (inducingFn 𝕜 E F) B
⊢ A = B
tactic: refine Function.Injective.embedding_induced fun A B hAB => ?_
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : RCLike 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : TopologicalSpace E
inst✝² : Module 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
A B : E →WOT[𝕜]F
hAB : (inducingFn 𝕜 E F) A = (inducingFn 𝕜 E F) B
⊢ A = B
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : RCLike 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : TopologicalSpace E
inst✝² : Module 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
A B : E →WOT[𝕜]F
hAB : (inducingFn 𝕜 E F) A = (inducingFn 𝕜 E F) B
⊢ ∀ (x : E) (y : NormedSpace.Dual 𝕜 F), y (A x) = y (B x)
tactic: rw [ext_dual_iff]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : RCLike 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : TopologicalSpace E
inst✝² : Module 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
A B : E →WOT[𝕜]F
hAB : (inducingFn 𝕜 E F) A = (inducingFn 𝕜 E F) B
⊢ ∀ (x : E) (y : NormedSpace.Dual 𝕜 F), y (A x) = y (B x)
state_after: no goals
tactic: simpa [Function.funext_iff] using hAB
Theorem: MonoidHom.smulOneHom_apply
File: Mathlib/Algebra/Group/Action/Defs.lean

Proof steps:
state_before: M✝ : Type u_1
N✝ : Type u_2
G : Type u_3
H : Type u_4
A : Type u_5
B : Type u_6
α : Type u_7
β : Type u_8
γ : Type u_9
δ : Type u_10
M : Type ?u.36861
N : Type ?u.36864
inst✝³ : Monoid M
inst✝² : MulOneClass N
inst✝¹ : MulAction M N
inst✝ : IsScalarTower M N N
x y : M
⊢ { toFun := fun x => x • 1, map_one' := ⋯ }.toFun (x * y) =
    { toFun := fun x => x • 1, map_one' := ⋯ }.toFun x * { toFun := fun x => x • 1, map_one' := ⋯ }.toFun y
state_after: no goals
tactic: rw [smul_one_mul, smul_smul]
Theorem: Finset.sum_eq_sum_Ico_succ_bot
File: Mathlib/Algebra/BigOperators/Intervals.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
inst✝ : CommMonoid M
s₂ s₁ s : Finset α
a✝ : α
g f✝ : α → M
a b : ℕ
hab : a < b
f : ℕ → M
⊢ ∏ k ∈ Ico a b, f k = f a * ∏ k ∈ Ico (a + 1) b, f k
state_after: α : Type u_1
M : Type u_2
inst✝ : CommMonoid M
s₂ s₁ s : Finset α
a✝ : α
g f✝ : α → M
a b : ℕ
hab : a < b
f : ℕ → M
ha : a ∉ Ico (a + 1) b
⊢ ∏ k ∈ Ico a b, f k = f a * ∏ k ∈ Ico (a + 1) b, f k
tactic: have ha : a ∉ Ico (a + 1) b := by simp
state_before: α : Type u_1
M : Type u_2
inst✝ : CommMonoid M
s₂ s₁ s : Finset α
a✝ : α
g f✝ : α → M
a b : ℕ
hab : a < b
f : ℕ → M
ha : a ∉ Ico (a + 1) b
⊢ ∏ k ∈ Ico a b, f k = f a * ∏ k ∈ Ico (a + 1) b, f k
state_after: no goals
tactic: rw [← prod_insert ha, Nat.Ico_insert_succ_left hab]
Theorem: Ordinal.nfp_mul_zero
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

Proof steps:
state_before: a : Ordinal.{u_1}
⊢ nfp (fun x => a * x) 0 = 0
state_after: a : Ordinal.{u_1}
⊢ ∀ (n : ℕ), (fun x => a * x)^[n] 0 ≤ 0
tactic: rw [← Ordinal.le_zero, nfp_le_iff]
state_before: a : Ordinal.{u_1}
⊢ ∀ (n : ℕ), (fun x => a * x)^[n] 0 ≤ 0
state_after: a : Ordinal.{u_1}
n : ℕ
⊢ (fun x => a * x)^[n] 0 ≤ 0
tactic: intro n
state_before: a : Ordinal.{u_1}
n : ℕ
⊢ (fun x => a * x)^[n] 0 ≤ 0
state_after: case zero
a : Ordinal.{u_1}
⊢ (fun x => a * x)^[0] 0 ≤ 0

case succ
a : Ordinal.{u_1}
n : ℕ
hn : (fun x => a * x)^[n] 0 ≤ 0
⊢ (fun x => a * x)^[n + 1] 0 ≤ 0
tactic: induction' n with n hn
state_before: case succ
a : Ordinal.{u_1}
n : ℕ
hn : (fun x => a * x)^[n] 0 ≤ 0
⊢ (fun x => a * x)^[n + 1] 0 ≤ 0
state_after: no goals
tactic: rwa [iterate_succ_apply, mul_zero]
Theorem: List.modifyNthTail_modifyNthTail_same
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f g : List α → List α
n : ℕ
l : List α
⊢ modifyNthTail g n (modifyNthTail f n l) = modifyNthTail (g ∘ f) n l
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f g : List α → List α
n : ℕ
l : List α
⊢ modifyNthTail (fun l => modifyNthTail g 0 (f l)) n l = modifyNthTail (g ∘ f) n l
tactic: rw [modifyNthTail_modifyNthTail_le n n l (le_refl n), Nat.sub_self]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f g : List α → List α
n : ℕ
l : List α
⊢ modifyNthTail (fun l => modifyNthTail g 0 (f l)) n l = modifyNthTail (g ∘ f) n l
state_after: no goals
tactic: rfl
Theorem: ENNReal.tendsto_mul
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ha : a ≠ 0 ∨ b ≠ ⊤
hb : b ≠ 0 ∨ a ≠ ⊤
⊢ Tendsto (fun p => p.1 * p.2) (𝓝 (a, b)) (𝓝 (a * b))
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ha : a ≠ 0 ∨ b ≠ ⊤
hb : b ≠ 0 ∨ a ≠ ⊤
ht : ∀ (b : ℝ≥0∞), b ≠ 0 → Tendsto (fun p => p.1 * p.2) (𝓝 (⊤, b)) (𝓝 ⊤)
⊢ Tendsto (fun p => p.1 * p.2) (𝓝 (a, b)) (𝓝 (a * b))
tactic: have ht : ∀ b : ℝ≥0∞, b ≠ 0 →
      Tendsto (fun p : ℝ≥0∞ × ℝ≥0∞ => p.1 * p.2) (𝓝 (∞, b)) (𝓝 ∞) := fun b hb => by
    refine tendsto_nhds_top_iff_nnreal.2 fun n => ?_
    rcases lt_iff_exists_nnreal_btwn.1 (pos_iff_ne_zero.2 hb) with ⟨ε, hε, hεb⟩
    have : ∀ᶠ c : ℝ≥0∞ × ℝ≥0∞ in 𝓝 (∞, b), ↑n / ↑ε < c.1 ∧ ↑ε < c.2 :=
      (lt_mem_nhds <| div_lt_top coe_ne_top hε.ne').prod_nhds (lt_mem_nhds hεb)
    refine this.mono fun c hc => ?_
    exact (ENNReal.div_mul_cancel hε.ne' coe_ne_top).symm.trans_lt (mul_lt_mul hc.1 hc.2)
Theorem: Lat.Iso.mk_inv_toSupHom_toFun
File: Mathlib/Order/Category/Lat.lean

Proof steps:
state_before: α β : Lat
e : ↑α ≃o ↑β
⊢ { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ } ≫ { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ } = 𝟙 α
state_after: case w
α β : Lat
e : ↑α ≃o ↑β
x✝ : (forget Lat).obj α
⊢ ({ toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ } ≫ { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ }) x✝ = (𝟙 α) x✝
tactic: ext
state_before: case w
α β : Lat
e : ↑α ≃o ↑β
x✝ : (forget Lat).obj α
⊢ ({ toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ } ≫ { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ }) x✝ = (𝟙 α) x✝
state_after: no goals
tactic: exact e.symm_apply_apply _
state_before: α β : Lat
e : ↑α ≃o ↑β
⊢ { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ } ≫ { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ } = 𝟙 β
state_after: case w
α β : Lat
e : ↑α ≃o ↑β
x✝ : (forget Lat).obj β
⊢ ({ toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ } ≫ { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ }) x✝ = (𝟙 β) x✝
tactic: ext
state_before: case w
α β : Lat
e : ↑α ≃o ↑β
x✝ : (forget Lat).obj β
⊢ ({ toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ } ≫ { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ }) x✝ = (𝟙 β) x✝
state_after: no goals
tactic: exact e.apply_symm_apply _
Theorem: inf_idem
File: Mathlib/Order/Lattice.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : SemilatticeInf α
a✝ b c d a : α
⊢ a ⊓ a = a
state_after: no goals
tactic: simp
Theorem: HurwitzKernelBounds.isBigO_exp_neg_mul_of_le
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/Bounds.lean

Proof steps:
state_before: c d : ℝ
hcd : c ≤ d
⊢ (fun t => rexp (-d * t)) =O[atTop] fun t => rexp (-c * t)
state_after: case hfg
c d : ℝ
hcd : c ≤ d
⊢ ∀ᶠ (x : ℝ) in atTop, ‖rexp (-d * x)‖ ≤ rexp (-c * x)
tactic: apply Eventually.isBigO
state_before: case hfg
c d : ℝ
hcd : c ≤ d
⊢ ∀ᶠ (x : ℝ) in atTop, ‖rexp (-d * x)‖ ≤ rexp (-c * x)
state_after: case h
c d : ℝ
hcd : c ≤ d
t : ℝ
ht : 0 < t
⊢ ‖rexp (-d * t)‖ ≤ rexp (-c * t)
tactic: filter_upwards [eventually_gt_atTop 0] with t ht
state_before: case h
c d : ℝ
hcd : c ≤ d
t : ℝ
ht : 0 < t
⊢ ‖rexp (-d * t)‖ ≤ rexp (-c * t)
state_after: no goals
tactic: rwa [norm_of_nonneg (exp_pos _).le, exp_le_exp, mul_le_mul_right ht, neg_le_neg_iff]
Theorem: Real.Angle.cos_add
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: θ₁ θ₂ : Angle
⊢ (θ₁ + θ₂).cos = θ₁.cos * θ₂.cos - θ₁.sin * θ₂.sin
state_after: case h
θ₁ : Angle
x✝ : ℝ
⊢ (θ₁ + ↑x✝).cos = θ₁.cos * (↑x✝).cos - θ₁.sin * (↑x✝).sin
tactic: induction θ₂ using Real.Angle.induction_on
state_before: case h
θ₁ : Angle
x✝ : ℝ
⊢ (θ₁ + ↑x✝).cos = θ₁.cos * (↑x✝).cos - θ₁.sin * (↑x✝).sin
state_after: case h.h
x✝¹ x✝ : ℝ
⊢ (↑x✝ + ↑x✝¹).cos = (↑x✝).cos * (↑x✝¹).cos - (↑x✝).sin * (↑x✝¹).sin
tactic: induction θ₁ using Real.Angle.induction_on
state_before: case h.h
x✝¹ x✝ : ℝ
⊢ (↑x✝ + ↑x✝¹).cos = (↑x✝).cos * (↑x✝¹).cos - (↑x✝).sin * (↑x✝¹).sin
state_after: no goals
tactic: exact Real.cos_add _ _
Theorem: Function.Periodic.sub_nat_mul_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✝ : Ring α
h : Periodic f c
n : ℕ
⊢ f (x - ↑n * c) = f x
state_after: no goals
tactic: simpa only [nsmul_eq_mul] using h.sub_nsmul_eq n
Theorem: vsub_right_cancel
File: Mathlib/Algebra/AddTorsor.lean

Proof steps:
state_before: G : Type u_1
P : Type u_2
inst✝ : AddGroup G
T : AddTorsor G P
p₁ p₂ p : P
h : p -ᵥ p₁ = p -ᵥ p₂
⊢ p₁ = p₂
state_after: G : Type u_1
P : Type u_2
inst✝ : AddGroup G
T : AddTorsor G P
p₁ p₂ p : P
h : p -ᵥ p₁ = p -ᵥ p₂
⊢ p -ᵥ p₂ +ᵥ p₁ = p -ᵥ p₂ +ᵥ p₂
tactic: refine vadd_left_cancel (p -ᵥ p₂) ?_
state_before: G : Type u_1
P : Type u_2
inst✝ : AddGroup G
T : AddTorsor G P
p₁ p₂ p : P
h : p -ᵥ p₁ = p -ᵥ p₂
⊢ p -ᵥ p₂ +ᵥ p₁ = p -ᵥ p₂ +ᵥ p₂
state_after: no goals
tactic: rw [vsub_vadd, ← h, vsub_vadd]
Theorem: EReal.neg_sub
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: x y : EReal
h1 : x ≠ ⊥ ∨ y ≠ ⊥
h2 : x ≠ ⊤ ∨ y ≠ ⊤
⊢ -(x - y) = -x + y
state_after: no goals
tactic: rw [sub_eq_add_neg, neg_add _ _, sub_eq_add_neg, neg_neg] <;> simp_all
Theorem: MonoidAlgebra.mem_adjoin_support
File: Mathlib/RingTheory/FiniteType.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
inst✝ : Monoid M
f : MonoidAlgebra R M
⊢ f ∈ adjoin R (⇑(of R M) '' ↑f.support)
state_after: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
inst✝ : Monoid M
f : MonoidAlgebra R M
⊢ span R (⇑(of R M) '' ↑f.support) ≤ Subalgebra.toSubmodule (adjoin R (⇑(of R M) '' ↑f.support))
tactic: suffices span R (of R M '' f.support) ≤ Subalgebra.toSubmodule (adjoin R (of R M '' f.support)) by
    exact this (mem_span_support f)
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
inst✝ : Monoid M
f : MonoidAlgebra R M
⊢ span R (⇑(of R M) '' ↑f.support) ≤ Subalgebra.toSubmodule (adjoin R (⇑(of R M) '' ↑f.support))
state_after: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
inst✝ : Monoid M
f : MonoidAlgebra R M
⊢ ⇑(of R M) '' ↑f.support ⊆ ↑(Subalgebra.toSubmodule (adjoin R (⇑(of R M) '' ↑f.support)))
tactic: rw [Submodule.span_le]
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
inst✝ : Monoid M
f : MonoidAlgebra R M
⊢ ⇑(of R M) '' ↑f.support ⊆ ↑(Subalgebra.toSubmodule (adjoin R (⇑(of R M) '' ↑f.support)))
state_after: no goals
tactic: exact subset_adjoin
Theorem: SeparationQuotient.isOpenMap_mk
File: Mathlib/Topology/Inseparable.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s✝ : Set X
f g : X → Y
t : Set (SeparationQuotient X)
s : Set X
hs : IsOpen s
⊢ IsOpen (mk ⁻¹' (mk '' s))
state_after: no goals
tactic: rwa [preimage_image_mk_open hs]
Theorem: Submodule.restrictScalars_eq_bot_iff
File: Mathlib/Algebra/Module/Submodule/RestrictScalars.lean

Proof steps:
state_before: S : Type u_1
R : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Semiring S
inst✝³ : Module S M
inst✝² : Module R M
inst✝¹ : SMul S R
inst✝ : IsScalarTower S R M
p : Submodule R M
⊢ restrictScalars S p = ⊥ ↔ p = ⊥
state_after: no goals
tactic: simp [SetLike.ext_iff]
Theorem: image_subtype_univ_ssubset_image_univ
File: Mathlib/Data/Fintype/Sum.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq β
k : β
b : α → β
hk : k ∈ image b univ
p : β → Prop
inst✝ : DecidablePred p
hp : ¬p k
⊢ image (fun i => b ↑i) univ ⊂ image b univ
state_after: case left
α : Type u_1
β : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq β
k : β
b : α → β
hk : k ∈ image b univ
p : β → Prop
inst✝ : DecidablePred p
hp : ¬p k
⊢ image (fun i => b ↑i) univ ⊆ image b univ

case right
α : Type u_1
β : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq β
k : β
b : α → β
hk : k ∈ image b univ
p : β → Prop
inst✝ : DecidablePred p
hp : ¬p k
⊢ ¬image b univ ⊆ image (fun i => b ↑i) univ
tactic: constructor
Theorem: tprod_setProd_singleton_right
File: Mathlib/Topology/Algebra/InfiniteSum/Constructions.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
s : Set β
c : γ
f : β × γ → α
⊢ ∏' (x : ↑(s ×ˢ {c})), f ↑x = ∏' (b : ↑s), f (↑b, c)
state_after: no goals
tactic: rw [tprod_congr_set_coe _ Set.prod_singleton, tprod_image _ (Prod.mk.inj_right c).injOn]
Theorem: Real.eulerMascheroniSeq'_one
File: Mathlib/NumberTheory/Harmonic/EulerMascheroni.lean

Proof steps:
state_before: ⊢ eulerMascheroniSeq' 1 = 1
state_after: no goals
tactic: simp [eulerMascheroniSeq']
Theorem: IsClosed.nhdsSet_le_sup'
File: Mathlib/Topology/NhdsSet.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : Filter X
s t s₁ s₂ t₁ t₂ : Set X
x : X
h : IsClosed t
⊢ 𝓝ˢ s ≤ 𝓝ˢ (t ∩ s) ⊔ 𝓟 tᶜ
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : Filter X
s t s₁ s₂ t₁ t₂ : Set X
x : X
h : IsClosed t
⊢ 𝓝ˢ s ≤ 𝓝ˢ (s ∩ t) ⊔ 𝓟 tᶜ
tactic: rw [Set.inter_comm]
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : Filter X
s t s₁ s₂ t₁ t₂ : Set X
x : X
h : IsClosed t
⊢ 𝓝ˢ s ≤ 𝓝ˢ (s ∩ t) ⊔ 𝓟 tᶜ
state_after: no goals
tactic: exact h.nhdsSet_le_sup s
Theorem: Surreal.Multiplication.P3_comm
File: Mathlib/SetTheory/Surreal/Multiplication.lean

Proof steps:
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
⊢ P3 x₁ x₂ y₁ y₂ ↔ P3 y₁ y₂ x₁ x₂
state_after: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
⊢ ⟦x₂ * y₁⟧ + ⟦x₁ * y₂⟧ < ⟦x₁ * y₁⟧ + ⟦x₂ * y₂⟧ ↔ ⟦y₁ * x₂⟧ + ⟦y₂ * x₁⟧ < ⟦y₁ * x₁⟧ + ⟦y₂ * x₂⟧
tactic: rw [P3, P3, add_comm]
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
⊢ ⟦x₂ * y₁⟧ + ⟦x₁ * y₂⟧ < ⟦x₁ * y₁⟧ + ⟦x₂ * y₂⟧ ↔ ⟦y₁ * x₂⟧ + ⟦y₂ * x₁⟧ < ⟦y₁ * x₁⟧ + ⟦y₂ * x₂⟧
state_after: no goals
tactic: congr! 2 <;> rw [quot_mul_comm]
Theorem: Pi.hasProd
File: Mathlib/Topology/Algebra/InfiniteSum/Constructions.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
π : α → Type u_6
inst✝¹ : (x : α) → CommMonoid (π x)
inst✝ : (x : α) → TopologicalSpace (π x)
f : ι → (x : α) → π x
g : (x : α) → π x
⊢ HasProd f g ↔ ∀ (x : α), HasProd (fun i => f i x) (g x)
state_after: no goals
tactic: simp only [HasProd, tendsto_pi_nhds, prod_apply]
Theorem: Finset.measurable_range_sup'
File: Mathlib/MeasureTheory/Order/Lattice.lean

Proof steps:
state_before: M : Type u_1
inst✝³ : MeasurableSpace M
α : Type u_2
m : MeasurableSpace α
μ : Measure α
f✝ g : α → M
δ : Type u_3
inst✝² : MeasurableSpace δ
inst✝¹ : SemilatticeSup α
inst✝ : MeasurableSup₂ α
f : ℕ → δ → α
n : ℕ
hf : ∀ k ≤ n, Measurable (f k)
⊢ Measurable ((range (n + 1)).sup' ⋯ f)
state_after: M : Type u_1
inst✝³ : MeasurableSpace M
α : Type u_2
m : MeasurableSpace α
μ : Measure α
f✝ g : α → M
δ : Type u_3
inst✝² : MeasurableSpace δ
inst✝¹ : SemilatticeSup α
inst✝ : MeasurableSup₂ α
f : ℕ → δ → α
n : ℕ
hf : ∀ k < n.succ, Measurable (f k)
⊢ Measurable ((range (n + 1)).sup' ⋯ f)
tactic: simp_rw [← Nat.lt_succ_iff] at hf
state_before: M : Type u_1
inst✝³ : MeasurableSpace M
α : Type u_2
m : MeasurableSpace α
μ : Measure α
f✝ g : α → M
δ : Type u_3
inst✝² : MeasurableSpace δ
inst✝¹ : SemilatticeSup α
inst✝ : MeasurableSup₂ α
f : ℕ → δ → α
n : ℕ
hf : ∀ k < n.succ, Measurable (f k)
⊢ Measurable ((range (n + 1)).sup' ⋯ f)
state_after: M : Type u_1
inst✝³ : MeasurableSpace M
α : Type u_2
m : MeasurableSpace α
μ : Measure α
f✝ g : α → M
δ : Type u_3
inst✝² : MeasurableSpace δ
inst✝¹ : SemilatticeSup α
inst✝ : MeasurableSup₂ α
f : ℕ → δ → α
n : ℕ
hf : ∀ k < n.succ, Measurable (f k)
⊢ ∀ n_1 ∈ range (n + 1), Measurable (f n_1)
tactic: refine Finset.measurable_sup' _ ?_
state_before: M : Type u_1
inst✝³ : MeasurableSpace M
α : Type u_2
m : MeasurableSpace α
μ : Measure α
f✝ g : α → M
δ : Type u_3
inst✝² : MeasurableSpace δ
inst✝¹ : SemilatticeSup α
inst✝ : MeasurableSup₂ α
f : ℕ → δ → α
n : ℕ
hf : ∀ k < n.succ, Measurable (f k)
⊢ ∀ n_1 ∈ range (n + 1), Measurable (f n_1)
state_after: no goals
tactic: simpa [Finset.mem_range]
Theorem: ContMDiffWithinAt.div_const
File: Mathlib/Geometry/Manifold/Algebra/Monoid.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
H : Type u_2
inst✝¹¹ : TopologicalSpace H
E : Type u_3
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
I : ModelWithCorners 𝕜 E H
G : Type u_4
inst✝⁸ : DivInvMonoid G
inst✝⁷ : TopologicalSpace G
inst✝⁶ : ChartedSpace H G
inst✝⁵ : SmoothMul I G
E' : Type u_5
inst✝⁴ : NormedAddCommGroup E'
inst✝³ : NormedSpace 𝕜 E'
H' : Type u_6
inst✝² : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M : Type u_7
inst✝¹ : TopologicalSpace M
inst✝ : ChartedSpace H' M
f : M → G
s : Set M
x : M
n : ℕ∞
c : G
hf : ContMDiffWithinAt I' I n f s x
⊢ ContMDiffWithinAt I' I n (fun x => f x / c) s x
state_after: no goals
tactic: simpa only [div_eq_mul_inv] using hf.mul contMDiffWithinAt_const
Theorem: Finsupp.mapRange_single
File: Mathlib/Data/Finsupp/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝² : Zero M
inst✝¹ : Zero N
inst✝ : Zero P
f : M → N
hf : f 0 = 0
a : α
b : M
a' : α
⊢ (mapRange f hf (single a b)) a' = (single a (f b)) a'
state_after: no goals
tactic: classical simpa only [single_eq_pi_single] using Pi.apply_single _ (fun _ => hf) a _ a'