ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AddSubgroup.cyclic_of_isolated_zero
File: Mathlib/GroupTheory/Archimedean.lean

Proof steps:
state_before: G : Type u_1
inst✝¹ : LinearOrderedAddCommGroup G
inst✝ : Archimedean G
H : AddSubgroup G
a : G
h₀ : 0 < a
hd : Disjoint (↑H) (Ioo 0 a)
⊢ ∃ b, H = closure {b}
state_after: case inl
G : Type u_1
inst✝¹ : LinearOrderedAddCommGroup G
inst✝ : Archimedean G
a : G
h₀ : 0 < a
hd : Disjoint (↑⊥) (Ioo 0 a)
⊢ ∃ b, ⊥ = closure {b}

case inr
G : Type u_1
inst✝¹ : LinearOrderedAddCommGroup G
inst✝ : Archimedean G
H : AddSubgroup G
a : G
h₀ : 0 < a
hd : Disjoint (↑H) (Ioo 0 a)
hbot : H ≠ ⊥
⊢ ∃ b, H = closure {b}
tactic: rcases eq_or_ne H ⊥ with rfl | hbot
Theorem: TopologicalSpace.Opens.op_map_id_obj
File: Mathlib/Topology/Category/TopCat/Opens.lean

Proof steps:
state_before: X Y Z : TopCat
U : (Opens ↑X)ᵒᵖ
⊢ (map (𝟙 X)).op.obj U = U
state_after: no goals
tactic: simp
Theorem: TopologicalSpace.OpenNhds.op_map_id_obj
File: Mathlib/Topology/Category/TopCat/OpenNhds.lean

Proof steps:
state_before: X Y : TopCat
f : X ⟶ Y
x : ↑X
U : (OpenNhds x)ᵒᵖ
⊢ (map (𝟙 X) x).op.obj U = U
state_after: no goals
tactic: simp
Theorem: descPochhammer_mul
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

Proof steps:
state_before: R : Type u
inst✝ : Ring R
n m : ℕ
⊢ descPochhammer R n * (descPochhammer R m).comp (X - ↑n) = descPochhammer R (n + m)
state_after: case zero
R : Type u
inst✝ : Ring R
n : ℕ
⊢ descPochhammer R n * (descPochhammer R 0).comp (X - ↑n) = descPochhammer R (n + 0)

case succ
R : Type u
inst✝ : Ring R
n m : ℕ
ih : descPochhammer R n * (descPochhammer R m).comp (X - ↑n) = descPochhammer R (n + m)
⊢ descPochhammer R n * (descPochhammer R (m + 1)).comp (X - ↑n) = descPochhammer R (n + (m + 1))
tactic: induction' m with m ih
Theorem: MeasureTheory.IsFundamentalDomain.setIntegral_eq_tsum'
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝¹² : Group G
inst✝¹¹ : Group H
inst✝¹⁰ : MulAction G α
inst✝⁹ : MeasurableSpace α
inst✝⁸ : MulAction H β
inst✝⁷ : MeasurableSpace β
inst✝⁶ : NormedAddCommGroup E
s t✝ : Set α
μ : Measure α
inst✝⁵ : MeasurableSpace G
inst✝⁴ : MeasurableSMul G α
inst✝³ : SMulInvariantMeasure G α μ
inst✝² : Countable G
ν : Measure α
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
h : IsFundamentalDomain G s μ
f : α → E
t : Set α
hf : IntegrableOn f t μ
⊢ ∑' (g : G), ∫ (x : α) in t ∩ g⁻¹ • s, f x ∂μ = ∑' (g : G), ∫ (x : α) in g⁻¹ • (g • t ∩ s), f x ∂μ
state_after: no goals
tactic: simp only [smul_set_inter, inv_smul_smul]
Theorem: dvd_mul_gcd_of_dvd_mul
File: Mathlib/Algebra/GCDMonoid/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
m n k : α
H : k ∣ m * n
⊢ k ∣ m * gcd k n
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
m n k : α
H : k ∣ n * m
⊢ k ∣ gcd k n * m
tactic: rw [mul_comm] at H ⊢
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
m n k : α
H : k ∣ n * m
⊢ k ∣ gcd k n * m
state_after: no goals
tactic: exact dvd_gcd_mul_of_dvd_mul H
Theorem: NormedAddGroupHom.opNorm_neg
File: Mathlib/Analysis/Normed/Group/Hom.lean

Proof steps:
state_before: V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f✝ g f : NormedAddGroupHom V₁ V₂
⊢ ‖-f‖ = ‖f‖
state_after: no goals
tactic: simp only [norm_def, coe_neg, norm_neg, Pi.neg_apply]
Theorem: MeasureTheory.setLIntegral_empty
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
⊢ ∫⁻ (x : α) in ∅, f x ∂μ = 0
state_after: no goals
tactic: rw [Measure.restrict_empty, lintegral_zero_measure]
Theorem: UpperSet.infIrred_iff_of_finite
File: Mathlib/Order/Birkhoff.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : PartialOrder α
s : UpperSet α
inst✝ : Finite α
⊢ InfIrred s ↔ ∃ a, Ici a = s
state_after: case refine_1
α : Type u_1
inst✝¹ : PartialOrder α
s : UpperSet α
inst✝ : Finite α
hs : InfIrred s
⊢ ∃ a, Ici a = s

case refine_2
α : Type u_1
inst✝¹ : PartialOrder α
s : UpperSet α
inst✝ : Finite α
⊢ (∃ a, Ici a = s) → InfIrred s
tactic: refine ⟨fun hs ↦ ?_, ?_⟩
Theorem: Nat.mem_factoredNumbers'
File: Mathlib/NumberTheory/SmoothNumbers.lean

Proof steps:
state_before: s : Finset ℕ
m : ℕ
⊢ m ∈ factoredNumbers s ↔ ∀ (p : ℕ), Prime p → p ∣ m → p ∈ s
state_after: case intro.intro
s : Finset ℕ
m p : ℕ
hp₁ : 1 + s.sup id ≤ p
hp₂ : Prime p
⊢ m ∈ factoredNumbers s ↔ ∀ (p : ℕ), Prime p → p ∣ m → p ∈ s
tactic: obtain ⟨p, hp₁, hp₂⟩ := exists_infinite_primes (1 + Finset.sup s id)
state_before: case intro.intro
s : Finset ℕ
m p : ℕ
hp₁ : 1 + s.sup id ≤ p
hp₂ : Prime p
⊢ m ∈ factoredNumbers s ↔ ∀ (p : ℕ), Prime p → p ∣ m → p ∈ s
state_after: case intro.intro
s : Finset ℕ
m p : ℕ
hp₁ : 1 + s.sup id ≤ p
hp₂ : Prime p
⊢ (m ≠ 0 ∧ ∀ p ≤ m, Prime p → p ∣ m → p ∈ s) ↔ ∀ (p : ℕ), Prime p → p ∣ m → p ∈ s
tactic: rw [mem_factoredNumbers_iff_forall_le]
state_before: case intro.intro
s : Finset ℕ
m p : ℕ
hp₁ : 1 + s.sup id ≤ p
hp₂ : Prime p
⊢ (m ≠ 0 ∧ ∀ p ≤ m, Prime p → p ∣ m → p ∈ s) ↔ ∀ (p : ℕ), Prime p → p ∣ m → p ∈ s
state_after: case intro.intro
s : Finset ℕ
m p : ℕ
hp₁ : 1 + s.sup id ≤ p
hp₂ : Prime p
H : ∀ (p : ℕ), Prime p → p ∣ m → p ∈ s
h : m = 0
⊢ p < p
tactic: refine ⟨fun ⟨H₀, H₁⟩ ↦ fun p hp₁ hp₂ ↦ H₁ p (le_of_dvd (Nat.pos_of_ne_zero H₀) hp₂) hp₁ hp₂,
         fun H ↦ ⟨fun h ↦ lt_irrefl p ?_, fun p _ ↦ H p⟩⟩
state_before: case intro.intro
s : Finset ℕ
m p : ℕ
hp₁ : 1 + s.sup id ≤ p
hp₂ : Prime p
H : ∀ (p : ℕ), Prime p → p ∣ m → p ∈ s
h : m = 0
⊢ p < p
state_after: no goals
tactic: calc
    p ≤ s.sup id := Finset.le_sup (f := @id ℕ) <| H p hp₂ <| h.symm ▸ dvd_zero p
    _ < 1 + s.sup id := lt_one_add _
    _ ≤ p := hp₁
Theorem: CategoryTheory.StructuredArrow.post_map
File: Mathlib/CategoryTheory/Comma/StructuredArrow.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
S✝ S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
A : Type u₃
inst✝¹ : Category.{v₃, u₃} A
B : Type u₄
inst✝ : Category.{v₄, u₄} B
S : C
F : B ⥤ C
G : C ⥤ D
X✝ Y✝ : StructuredArrow S F
f : X✝ ⟶ Y✝
⊢ ((fun X => mk (G.map X.hom)) X✝).hom ≫ (F ⋙ G).map f.right = ((fun X => mk (G.map X.hom)) Y✝).hom
state_after: no goals
tactic: simp [Functor.comp_map, ← G.map_comp, ← f.w]
Theorem: Filter.tendsto_const_mul_atBot_of_pos
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : LinearOrderedField α
l : Filter β
f : β → α
r : α
hr : 0 < r
⊢ Tendsto (fun x => r * f x) l atBot ↔ Tendsto f l atBot
state_after: no goals
tactic: simpa only [← mul_neg, ← tendsto_neg_atTop_iff] using tendsto_const_mul_atTop_of_pos hr
Theorem: iSup_univ
File: Mathlib/Order/CompleteLattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : β → α
⊢ ⨆ x ∈ univ, f x = ⨆ x, f x
state_after: no goals
tactic: simp
Theorem: one_lt_mul_iff
File: Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean

Proof steps:
state_before: α : Type u
inst✝ : CanonicallyOrderedCommMonoid α
a b c d : α
⊢ 1 < a * b ↔ 1 < a ∨ 1 < b
state_after: no goals
tactic: simp only [one_lt_iff_ne_one, Ne, mul_eq_one_iff, not_and_or]
Theorem: Finset.map_subtype_embedding_Iic
File: Mathlib/Order/Interval/Finset/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrderBot α
a : Subtype p
hp : ∀ ⦃a x : α⦄, x ≤ a → p a → p x
⊢ map (Embedding.subtype p) (Iic a) = Iic ↑a
state_after: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrderBot α
a : Subtype p
hp : ∀ ⦃a x : α⦄, x ≤ a → p a → p x
⊢ map (Embedding.subtype p) (Finset.subtype p (Iic ↑a)) = Iic ↑a
tactic: rw [subtype_Iic_eq]
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrderBot α
a : Subtype p
hp : ∀ ⦃a x : α⦄, x ≤ a → p a → p x
⊢ map (Embedding.subtype p) (Finset.subtype p (Iic ↑a)) = Iic ↑a
state_after: no goals
tactic: exact Finset.subtype_map_of_mem fun x hx => hp (mem_Iic.1 hx) a.prop
Theorem: exists_maximalIdeal_pow_eq_of_principal
File: Mathlib/RingTheory/DiscreteValuationRing/TFAE.lean

Proof steps:
state_before: R : Type u_1
inst✝⁶ : CommRing R
K : Type u_2
inst✝⁵ : Field K
inst✝⁴ : Algebra R K
inst✝³ : IsFractionRing R K
inst✝² : IsNoetherianRing R
inst✝¹ : LocalRing R
inst✝ : IsDomain R
h' : Submodule.IsPrincipal (maximalIdeal R)
I : Ideal R
hI : I ≠ ⊥
⊢ ∃ n, I = maximalIdeal R ^ n
state_after: case pos
R : Type u_1
inst✝⁶ : CommRing R
K : Type u_2
inst✝⁵ : Field K
inst✝⁴ : Algebra R K
inst✝³ : IsFractionRing R K
inst✝² : IsNoetherianRing R
inst✝¹ : LocalRing R
inst✝ : IsDomain R
h' : Submodule.IsPrincipal (maximalIdeal R)
I : Ideal R
hI : I ≠ ⊥
h : IsField R
⊢ ∃ n, I = maximalIdeal R ^ n

case neg
R : Type u_1
inst✝⁶ : CommRing R
K : Type u_2
inst✝⁵ : Field K
inst✝⁴ : Algebra R K
inst✝³ : IsFractionRing R K
inst✝² : IsNoetherianRing R
inst✝¹ : LocalRing R
inst✝ : IsDomain R
h' : Submodule.IsPrincipal (maximalIdeal R)
I : Ideal R
hI : I ≠ ⊥
h : ¬IsField R
⊢ ∃ n, I = maximalIdeal R ^ n
tactic: by_cases h : IsField R
Theorem: AList.extract_eq_lookup_erase
File: Mathlib/Data/List/AList.lean

Proof steps:
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
s : AList β
⊢ extract a s = (lookup a s, erase a s)
state_after: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
s : AList β
⊢ dlookup a s.entries = lookup a s ∧ { entries := kerase a s.entries, nodupKeys := ⋯ } = erase a s
tactic: simp [extract]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
s : AList β
⊢ dlookup a s.entries = lookup a s ∧ { entries := kerase a s.entries, nodupKeys := ⋯ } = erase a s
state_after: no goals
tactic: constructor <;> rfl
Theorem: Finset.prod_dite_eq
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a✝ : α
f g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
a : α
b : (x : α) → a = x → β
⊢ (∏ x ∈ s, if h : a = x then b x h else 1) = if a ∈ s then b a ⋯ else 1
state_after: case pos
ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a✝ : α
f g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
a : α
b : (x : α) → a = x → β
h : a ∈ s
⊢ (∏ x ∈ s, if h : a = x then b x h else 1) = b a ⋯

case neg
ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a✝ : α
f g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
a : α
b : (x : α) → a = x → β
h : a ∉ s
⊢ (∏ x ∈ s, if h : a = x then b x h else 1) = 1
tactic: split_ifs with h
Theorem: LinearEquiv.snd_comp_prodComm
File: Mathlib/LinearAlgebra/Prod.lean

Proof steps:
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
⊢ LinearMap.snd R M₂ M ∘ₗ ↑(prodComm R M M₂) = LinearMap.fst R M M₂
state_after: no goals
tactic: ext <;> simp
Theorem: BoxIntegral.Prepartition.iUnion_restrict
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

Proof steps:
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
⊢ (π.restrict J).iUnion = ↑J ∩ π.iUnion
state_after: no goals
tactic: simp [restrict, ← inter_iUnion, ← iUnion_def]
Theorem: ConcaveOn.set_average_mem_hypograph
File: Mathlib/Analysis/Convex/Integral.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : CompleteSpace E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
μ : Measure α
s : Set E
t : Set α
f : α → E
g : E → ℝ
C : ℝ
hg : ConcaveOn ℝ s g
hgc : ContinuousOn g s
hsc : IsClosed s
h0 : μ t ≠ 0
ht : μ t ≠ ⊤
hfs : ∀ᵐ (x : α) ∂μ.restrict t, f x ∈ s
hfi : IntegrableOn f t μ
hgi : IntegrableOn (g ∘ f) t μ
⊢ (⨍ (x : α) in t, f x ∂μ, ⨍ (x : α) in t, g (f x) ∂μ) ∈ {p | p.1 ∈ s ∧ p.2 ≤ g p.1}
state_after: no goals
tactic: simpa only [mem_setOf_eq, Pi.neg_apply, average_neg, neg_le_neg_iff] using
    hg.neg.set_average_mem_epigraph hgc.neg hsc h0 ht hfs hfi hgi.neg
Theorem: SemidirectProduct.hom_ext
File: Mathlib/GroupTheory/SemidirectProduct.lean

Proof steps:
state_before: N : Type u_1
G : Type u_2
H : Type u_3
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
f₁ : N →* H
f₂ : G →* H
h : ∀ (g : G), f₁.comp (MulEquiv.toMonoidHom (φ g)) = (MulEquiv.toMonoidHom (MulAut.conj (f₂ g))).comp f₁
f g : N ⋊[φ] G →* H
hl : f.comp inl = g.comp inl
hr : f.comp inr = g.comp inr
⊢ f = g
state_after: N : Type u_1
G : Type u_2
H : Type u_3
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
f₁ : N →* H
f₂ : G →* H
h : ∀ (g : G), f₁.comp (MulEquiv.toMonoidHom (φ g)) = (MulEquiv.toMonoidHom (MulAut.conj (f₂ g))).comp f₁
f g : N ⋊[φ] G →* H
hl : f.comp inl = g.comp inl
hr : f.comp inr = g.comp inr
⊢ lift (f.comp inl) (f.comp inr) ⋯ = lift (g.comp inl) (g.comp inr) ⋯
tactic: rw [lift_unique f, lift_unique g]
state_before: N : Type u_1
G : Type u_2
H : Type u_3
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
f₁ : N →* H
f₂ : G →* H
h : ∀ (g : G), f₁.comp (MulEquiv.toMonoidHom (φ g)) = (MulEquiv.toMonoidHom (MulAut.conj (f₂ g))).comp f₁
f g : N ⋊[φ] G →* H
hl : f.comp inl = g.comp inl
hr : f.comp inr = g.comp inr
⊢ lift (f.comp inl) (f.comp inr) ⋯ = lift (g.comp inl) (g.comp inr) ⋯
state_after: no goals
tactic: simp only [*]
Theorem: ker_nhds
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x : X
⊢ (𝓝 x).ker = {x}
state_after: no goals
tactic: simp [ker_nhds_eq_specializes]
Theorem: Ideal.mem_leadingCoeff
File: Mathlib/RingTheory/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
S : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Semiring S
I : Ideal R[X]
x : R
⊢ x ∈ I.leadingCoeff ↔ ∃ p ∈ I, p.leadingCoeff = x
state_after: R : Type u
S : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Semiring S
I : Ideal R[X]
x : R
⊢ (∃ i, x ∈ I.leadingCoeffNth i) ↔ ∃ p ∈ I, p.leadingCoeff = x

case H
R : Type u
S : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Semiring S
I : Ideal R[X]
x : R
⊢ Directed (fun x x_1 => x ≤ x_1) fun n => I.leadingCoeffNth n
tactic: rw [leadingCoeff, Submodule.mem_iSup_of_directed]
state_before: case H
R : Type u
S : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Semiring S
I : Ideal R[X]
x : R
⊢ Directed (fun x x_1 => x ≤ x_1) fun n => I.leadingCoeffNth n
state_after: case H
R : Type u
S : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Semiring S
I : Ideal R[X]
x : R
i j : ℕ
⊢ ∃ z,
    (fun x x_1 => x ≤ x_1) ((fun n => I.leadingCoeffNth n) i) ((fun n => I.leadingCoeffNth n) z) ∧
      (fun x x_1 => x ≤ x_1) ((fun n => I.leadingCoeffNth n) j) ((fun n => I.leadingCoeffNth n) z)
tactic: intro i j
state_before: case H
R : Type u
S : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Semiring S
I : Ideal R[X]
x : R
i j : ℕ
⊢ ∃ z,
    (fun x x_1 => x ≤ x_1) ((fun n => I.leadingCoeffNth n) i) ((fun n => I.leadingCoeffNth n) z) ∧
      (fun x x_1 => x ≤ x_1) ((fun n => I.leadingCoeffNth n) j) ((fun n => I.leadingCoeffNth n) z)
state_after: no goals
tactic: exact
    ⟨i + j, I.leadingCoeffNth_mono (Nat.le_add_right _ _),
      I.leadingCoeffNth_mono (Nat.le_add_left _ _)⟩
Theorem: Submodule.mem_annihilator
File: Mathlib/RingTheory/Ideal/Operations.lean

Proof steps:
state_before: R : Type u
M : Type v
M' : Type u_1
F : Type u_2
G : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
I J : Ideal R
N P : Submodule R M
r : R
⊢ r ∈ N.annihilator ↔ ∀ n ∈ N, r • n = 0
state_after: R : Type u
M : Type v
M' : Type u_1
F : Type u_2
G : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
I J : Ideal R
N P : Submodule R M
r : R
⊢ (∀ (a : M) (b : a ∈ N), ↑(r • ⟨a, b⟩) = ↑0) ↔ ∀ n ∈ N, r • n = 0
tactic: simp_rw [annihilator, Module.mem_annihilator, Subtype.forall, Subtype.ext_iff]
state_before: R : Type u
M : Type v
M' : Type u_1
F : Type u_2
G : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
I J : Ideal R
N P : Submodule R M
r : R
⊢ (∀ (a : M) (b : a ∈ N), ↑(r • ⟨a, b⟩) = ↑0) ↔ ∀ n ∈ N, r • n = 0
state_after: no goals
tactic: rfl
Theorem: NonUnitalRing.ext
File: Mathlib/Algebra/Ring/Ext.lean

Proof steps:
state_before: R : Type u
inst₁ inst₂ : NonUnitalRing R
h_add : HAdd.hAdd = HAdd.hAdd
h_mul : HMul.hMul = HMul.hMul
⊢ inst₁ = inst₂
state_after: R : Type u
inst₁ inst₂ : NonUnitalRing R
h_add : HAdd.hAdd = HAdd.hAdd
h_mul : HMul.hMul = HMul.hMul
this : toNonUnitalNonAssocRing = toNonUnitalNonAssocRing
⊢ inst₁ = inst₂
tactic: have : inst₁.toNonUnitalNonAssocRing = inst₂.toNonUnitalNonAssocRing := by
    ext : 1 <;> assumption
state_before: R : Type u
inst₁ inst₂ : NonUnitalRing R
h_add : HAdd.hAdd = HAdd.hAdd
h_mul : HMul.hMul = HMul.hMul
this : toNonUnitalNonAssocRing = toNonUnitalNonAssocRing
⊢ inst₁ = inst₂
state_after: case mk
R : Type u
inst₂ : NonUnitalRing R
toNonUnitalNonAssocRing✝ : NonUnitalNonAssocRing R
mul_assoc✝ : ∀ (a b c : R), a * b * c = a * (b * c)
h_add : HAdd.hAdd = HAdd.hAdd
h_mul : HMul.hMul = HMul.hMul
this : toNonUnitalNonAssocRing = toNonUnitalNonAssocRing
⊢ mk mul_assoc✝ = inst₂
tactic: cases inst₁
state_before: case mk
R : Type u
inst₂ : NonUnitalRing R
toNonUnitalNonAssocRing✝ : NonUnitalNonAssocRing R
mul_assoc✝ : ∀ (a b c : R), a * b * c = a * (b * c)
h_add : HAdd.hAdd = HAdd.hAdd
h_mul : HMul.hMul = HMul.hMul
this : toNonUnitalNonAssocRing = toNonUnitalNonAssocRing
⊢ mk mul_assoc✝ = inst₂
state_after: case mk.mk
R : Type u
toNonUnitalNonAssocRing✝¹ : NonUnitalNonAssocRing R
mul_assoc✝¹ : ∀ (a b c : R), a * b * c = a * (b * c)
toNonUnitalNonAssocRing✝ : NonUnitalNonAssocRing R
mul_assoc✝ : ∀ (a b c : R), a * b * c = a * (b * c)
h_add : HAdd.hAdd = HAdd.hAdd
h_mul : HMul.hMul = HMul.hMul
this : toNonUnitalNonAssocRing = toNonUnitalNonAssocRing
⊢ mk mul_assoc✝¹ = mk mul_assoc✝
tactic: cases inst₂
state_before: case mk.mk
R : Type u
toNonUnitalNonAssocRing✝¹ : NonUnitalNonAssocRing R
mul_assoc✝¹ : ∀ (a b c : R), a * b * c = a * (b * c)
toNonUnitalNonAssocRing✝ : NonUnitalNonAssocRing R
mul_assoc✝ : ∀ (a b c : R), a * b * c = a * (b * c)
h_add : HAdd.hAdd = HAdd.hAdd
h_mul : HMul.hMul = HMul.hMul
this : toNonUnitalNonAssocRing = toNonUnitalNonAssocRing
⊢ mk mul_assoc✝¹ = mk mul_assoc✝
state_after: no goals
tactic: congr
Theorem: Algebra.FormallyUnramified.lift_unique_of_ringHom
File: Mathlib/RingTheory/Unramified/Basic.lean

Proof steps:
state_before: R : Type u
inst✝⁶ : CommSemiring R
A : Type u
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
B : Type u
inst✝³ : CommRing B
inst✝² : Algebra R B
I : Ideal B
inst✝¹ : FormallyUnramified R A
C : Type u
inst✝ : CommRing C
f : B →+* C
hf : IsNilpotent (RingHom.ker f)
g₁ g₂ : A →ₐ[R] B
h : f.comp ↑g₁ = f.comp ↑g₂
⊢ (Ideal.Quotient.mkₐ R (RingHom.ker f)).comp g₁ = (Ideal.Quotient.mkₐ R (RingHom.ker f)).comp g₂
state_after: case H
R : Type u
inst✝⁶ : CommSemiring R
A : Type u
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
B : Type u
inst✝³ : CommRing B
inst✝² : Algebra R B
I : Ideal B
inst✝¹ : FormallyUnramified R A
C : Type u
inst✝ : CommRing C
f : B →+* C
hf : IsNilpotent (RingHom.ker f)
g₁ g₂ : A →ₐ[R] B
h : f.comp ↑g₁ = f.comp ↑g₂
x : A
⊢ ((Ideal.Quotient.mkₐ R (RingHom.ker f)).comp g₁) x = ((Ideal.Quotient.mkₐ R (RingHom.ker f)).comp g₂) x
tactic: ext x
state_before: case H
R : Type u
inst✝⁶ : CommSemiring R
A : Type u
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
B : Type u
inst✝³ : CommRing B
inst✝² : Algebra R B
I : Ideal B
inst✝¹ : FormallyUnramified R A
C : Type u
inst✝ : CommRing C
f : B →+* C
hf : IsNilpotent (RingHom.ker f)
g₁ g₂ : A →ₐ[R] B
h : f.comp ↑g₁ = f.comp ↑g₂
x : A
⊢ ((Ideal.Quotient.mkₐ R (RingHom.ker f)).comp g₁) x = ((Ideal.Quotient.mkₐ R (RingHom.ker f)).comp g₂) x
state_after: case H
R : Type u
inst✝⁶ : CommSemiring R
A : Type u
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
B : Type u
inst✝³ : CommRing B
inst✝² : Algebra R B
I : Ideal B
inst✝¹ : FormallyUnramified R A
C : Type u
inst✝ : CommRing C
f : B →+* C
hf : IsNilpotent (RingHom.ker f)
g₁ g₂ : A →ₐ[R] B
h : f.comp ↑g₁ = f.comp ↑g₂
x : A
this : (f.comp ↑g₁) x = (f.comp ↑g₂) x
⊢ ((Ideal.Quotient.mkₐ R (RingHom.ker f)).comp g₁) x = ((Ideal.Quotient.mkₐ R (RingHom.ker f)).comp g₂) x
tactic: have := RingHom.congr_fun h x
state_before: case H
R : Type u
inst✝⁶ : CommSemiring R
A : Type u
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
B : Type u
inst✝³ : CommRing B
inst✝² : Algebra R B
I : Ideal B
inst✝¹ : FormallyUnramified R A
C : Type u
inst✝ : CommRing C
f : B →+* C
hf : IsNilpotent (RingHom.ker f)
g₁ g₂ : A →ₐ[R] B
h : f.comp ↑g₁ = f.comp ↑g₂
x : A
this : (f.comp ↑g₁) x = (f.comp ↑g₂) x
⊢ ((Ideal.Quotient.mkₐ R (RingHom.ker f)).comp g₁) x = ((Ideal.Quotient.mkₐ R (RingHom.ker f)).comp g₂) x
state_after: no goals
tactic: simpa only [Ideal.Quotient.eq, Function.comp_apply, AlgHom.coe_comp, Ideal.Quotient.mkₐ_eq_mk,
        RingHom.mem_ker, map_sub, sub_eq_zero]
Theorem: nhdsWithin_compl_singleton_sup_pure
File: Mathlib/Topology/ContinuousOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : TopologicalSpace α
a : α
⊢ 𝓝[≠] a ⊔ pure a = 𝓝 a
state_after: no goals
tactic: rw [← nhdsWithin_singleton, ← nhdsWithin_union, compl_union_self, nhdsWithin_univ]
Theorem: Subalgebra.comap_map_eq
File: Mathlib/RingTheory/Adjoin/Basic.lean

Proof steps:
state_before: R : Type uR
S✝ : Type uS
A : Type uA
B : Type uB
inst✝⁴ : CommSemiring R
inst✝³ : Ring A
inst✝² : Algebra R A
inst✝¹ : Ring B
inst✝ : Algebra R B
f : A →ₐ[R] B
S : Subalgebra R A
⊢ comap f (map f S) = S ⊔ adjoin R (⇑f ⁻¹' {0})
state_after: case a
R : Type uR
S✝ : Type uS
A : Type uA
B : Type uB
inst✝⁴ : CommSemiring R
inst✝³ : Ring A
inst✝² : Algebra R A
inst✝¹ : Ring B
inst✝ : Algebra R B
f : A →ₐ[R] B
S : Subalgebra R A
⊢ comap f (map f S) ≤ S ⊔ adjoin R (⇑f ⁻¹' {0})

case a
R : Type uR
S✝ : Type uS
A : Type uA
B : Type uB
inst✝⁴ : CommSemiring R
inst✝³ : Ring A
inst✝² : Algebra R A
inst✝¹ : Ring B
inst✝ : Algebra R B
f : A →ₐ[R] B
S : Subalgebra R A
⊢ S ⊔ adjoin R (⇑f ⁻¹' {0}) ≤ comap f (map f S)
tactic: apply le_antisymm
Theorem: gauge_of_subset_zero
File: Mathlib/Analysis/Convex/Gauge.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x : E
a : ℝ
h : s ⊆ 0
⊢ gauge s = 0
state_after: case inl
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
t : Set E
x : E
a : ℝ
h : ∅ ⊆ 0
⊢ gauge ∅ = 0

case inr
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
t : Set E
x : E
a : ℝ
h : {0} ⊆ 0
⊢ gauge {0} = 0
tactic: obtain rfl | rfl := subset_singleton_iff_eq.1 h
state_before: case inl
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
t : Set E
x : E
a : ℝ
h : ∅ ⊆ 0
⊢ gauge ∅ = 0

case inr
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
t : Set E
x : E
a : ℝ
h : {0} ⊆ 0
⊢ gauge {0} = 0
state_after: no goals
tactic: exacts [gauge_empty, gauge_zero']
Theorem: ENNReal.eq_div_iff
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
ha' : a ≠ ⊤
h : b = c / a
⊢ a * b = c
state_after: no goals
tactic: rw [h, ENNReal.mul_div_cancel' ha ha']
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
ha' : a ≠ ⊤
h : a * b = c
⊢ b = c / a
state_after: no goals
tactic: rw [← h, mul_div_assoc, ENNReal.mul_div_cancel' ha ha']