ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AddCommMonoid.primaryComponent_coe
File: Mathlib/GroupTheory/Torsion.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
inst✝ : CommMonoid G
p : ℕ
hp : Fact (Nat.Prime p)
⊢ orderOf 1 = p ^ 0
state_after: no goals
tactic: rw [pow_zero, orderOf_one]
state_before: G : Type u_1
H : Type u_2
inst✝ : CommMonoid G
p : ℕ
hp : Fact (Nat.Prime p)
a✝ b✝ : G
hg₁ : a✝ ∈ {g | ∃ n, orderOf g = p ^ n}
hg₂ : b✝ ∈ {g | ∃ n, orderOf g = p ^ n}
⊢ ∃ m, (a✝ * b✝) ^ p ^ m = 1
state_after: case intro
G : Type u_1
H : Type u_2
inst✝ : CommMonoid G
p : ℕ
hp : Fact (Nat.Prime p)
a✝ b✝ : G
hg₁ : a✝ ∈ {g | ∃ n, orderOf g = p ^ n}
hg₂ : b✝ ∈ {g | ∃ n, orderOf g = p ^ n}
m : ℕ
hm : a✝ ^ p ^ m = 1
⊢ ∃ m, (a✝ * b✝) ^ p ^ m = 1
tactic: obtain ⟨m, hm⟩ := exists_orderOf_eq_prime_pow_iff.mp hg₁
state_before: case intro
G : Type u_1
H : Type u_2
inst✝ : CommMonoid G
p : ℕ
hp : Fact (Nat.Prime p)
a✝ b✝ : G
hg₁ : a✝ ∈ {g | ∃ n, orderOf g = p ^ n}
hg₂ : b✝ ∈ {g | ∃ n, orderOf g = p ^ n}
m : ℕ
hm : a✝ ^ p ^ m = 1
⊢ ∃ m, (a✝ * b✝) ^ p ^ m = 1
state_after: case intro.intro
G : Type u_1
H : Type u_2
inst✝ : CommMonoid G
p : ℕ
hp : Fact (Nat.Prime p)
a✝ b✝ : G
hg₁ : a✝ ∈ {g | ∃ n, orderOf g = p ^ n}
hg₂ : b✝ ∈ {g | ∃ n, orderOf g = p ^ n}
m : ℕ
hm : a✝ ^ p ^ m = 1
n : ℕ
hn : b✝ ^ p ^ n = 1
⊢ ∃ m, (a✝ * b✝) ^ p ^ m = 1
tactic: obtain ⟨n, hn⟩ := exists_orderOf_eq_prime_pow_iff.mp hg₂
state_before: case intro.intro
G : Type u_1
H : Type u_2
inst✝ : CommMonoid G
p : ℕ
hp : Fact (Nat.Prime p)
a✝ b✝ : G
hg₁ : a✝ ∈ {g | ∃ n, orderOf g = p ^ n}
hg₂ : b✝ ∈ {g | ∃ n, orderOf g = p ^ n}
m : ℕ
hm : a✝ ^ p ^ m = 1
n : ℕ
hn : b✝ ^ p ^ n = 1
⊢ ∃ m, (a✝ * b✝) ^ p ^ m = 1
state_after: no goals
tactic: exact
        ⟨m + n, by
          rw [mul_pow, pow_add, pow_mul, hm, one_pow, Monoid.one_mul, mul_comm, pow_mul, hn,
            one_pow]⟩
Theorem: QuadraticForm.dualProd_apply
File: Mathlib/LinearAlgebra/QuadraticForm/Dual.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid N
inst✝¹ : Module R M
inst✝ : Module R N
a : R
p : Module.Dual R M × M
⊢ (fun p => p.1 p.2) (a • p) = (a * a) • (fun p => p.1 p.2) p
state_after: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid N
inst✝¹ : Module R M
inst✝ : Module R N
a : R
p : Module.Dual R M × M
⊢ (a • p).1 (a • p).2 = (a * a) • p.1 p.2
tactic: dsimp only
state_before: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid N
inst✝¹ : Module R M
inst✝ : Module R N
a : R
p : Module.Dual R M × M
⊢ (a • p).1 (a • p).2 = (a * a) • p.1 p.2
state_after: no goals
tactic: rw [Prod.smul_fst, Prod.smul_snd, LinearMap.smul_apply, LinearMap.map_smul, smul_eq_mul,
      smul_eq_mul, smul_eq_mul, mul_assoc]
state_before: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid N
inst✝¹ : Module R M
inst✝ : Module R N
p q : Module.Dual R M × M
⊢ (fun p => p.1 p.2) (p + q) = (fun p => p.1 p.2) p + (fun p => p.1 p.2) q + ((LinearMap.dualProd R M) p) q
state_after: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid N
inst✝¹ : Module R M
inst✝ : Module R N
p q : Module.Dual R M × M
⊢ (p + q).1 (p + q).2 = p.1 p.2 + q.1 q.2 + ((LinearMap.dualProd R M) p) q
tactic: dsimp only
state_before: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid N
inst✝¹ : Module R M
inst✝ : Module R N
p q : Module.Dual R M × M
⊢ (p + q).1 (p + q).2 = p.1 p.2 + q.1 q.2 + ((LinearMap.dualProd R M) p) q
state_after: no goals
tactic: rw [LinearMap.dualProd_apply_apply, Prod.fst_add, Prod.snd_add, LinearMap.add_apply, map_add,
        map_add, add_right_comm _ (q.1 q.2), add_comm (q.1 p.2) (p.1 q.2), ← add_assoc, ←
        add_assoc]
Theorem: AffineSubspace.sSameSide_vadd_right_iff
File: Mathlib/Analysis/Convex/Side.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
v : V
hv : v ∈ s.direction
⊢ s.SSameSide x (v +ᵥ y) ↔ s.SSameSide x y
state_after: no goals
tactic: rw [sSameSide_comm, sSameSide_vadd_left_iff hv, sSameSide_comm]
Theorem: MeasureTheory.SignedMeasure.withDensityᵥ_rnDeriv_eq
File: Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
s : SignedMeasure α
μ : Measure α
inst✝ : SigmaFinite μ
h : s ≪ᵥ μ.toENNRealVectorMeasure
⊢ μ.withDensityᵥ (s.rnDeriv μ) = s
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
s : SignedMeasure α
μ : Measure α
inst✝ : SigmaFinite μ
h : s.toJordanDecomposition.posPart ≪ μ ∧ s.toJordanDecomposition.negPart ≪ μ
⊢ μ.withDensityᵥ (s.rnDeriv μ) = s

α : Type u_1
β : Type u_2
m : MeasurableSpace α
s : SignedMeasure α
μ : Measure α
inst✝ : SigmaFinite μ
h : s.totalVariation ≪ μ.toENNRealVectorMeasure.ennrealToMeasure
⊢ μ.toENNRealVectorMeasure.ennrealToMeasure = μ
tactic: rw [absolutelyContinuous_ennreal_iff, (_ : μ.toENNRealVectorMeasure.ennrealToMeasure = μ),
    totalVariation_absolutelyContinuous_iff] at h
Theorem: LSeries.abscissaOfAbsConv_le_of_le_const_mul_rpow
File: Mathlib/NumberTheory/LSeries/Convergence.lean

Proof steps:
state_before: f : ℕ → ℂ
x : ℝ
h : ∃ C, ∀ (n : ℕ), n ≠ 0 → ‖f n‖ ≤ C * ↑n ^ x
⊢ abscissaOfAbsConv f ≤ ↑x + 1
state_after: f : ℕ → ℂ
x : ℝ
h : ∃ C, ∀ (n : ℕ), n ≠ 0 → ‖f n‖ ≤ C * ↑n ^ (x + 1 - 1)
⊢ abscissaOfAbsConv f ≤ ↑x + 1
tactic: rw [show x = x + 1 - 1 by ring] at h
state_before: f : ℕ → ℂ
x : ℝ
h : ∃ C, ∀ (n : ℕ), n ≠ 0 → ‖f n‖ ≤ C * ↑n ^ (x + 1 - 1)
⊢ abscissaOfAbsConv f ≤ ↑x + 1
state_after: f : ℕ → ℂ
x : ℝ
h : ∃ C, ∀ (n : ℕ), n ≠ 0 → ‖f n‖ ≤ C * ↑n ^ (x + 1 - 1)
H : ↑x + 1 < abscissaOfAbsConv f
⊢ False
tactic: by_contra! H
state_before: f : ℕ → ℂ
x : ℝ
h : ∃ C, ∀ (n : ℕ), n ≠ 0 → ‖f n‖ ≤ C * ↑n ^ (x + 1 - 1)
H : ↑x + 1 < abscissaOfAbsConv f
⊢ False
state_after: case intro.intro
f : ℕ → ℂ
x : ℝ
h : ∃ C, ∀ (n : ℕ), n ≠ 0 → ‖f n‖ ≤ C * ↑n ^ (x + 1 - 1)
H : ↑x + 1 < abscissaOfAbsConv f
y : ℝ
hy₁ : ↑x + 1 < ↑y
hy₂ : ↑y < abscissaOfAbsConv f
⊢ False
tactic: obtain ⟨y, hy₁, hy₂⟩ := EReal.exists_between_coe_real H
state_before: case intro.intro
f : ℕ → ℂ
x : ℝ
h : ∃ C, ∀ (n : ℕ), n ≠ 0 → ‖f n‖ ≤ C * ↑n ^ (x + 1 - 1)
H : ↑x + 1 < abscissaOfAbsConv f
y : ℝ
hy₁ : ↑x + 1 < ↑y
hy₂ : ↑y < abscissaOfAbsConv f
⊢ False
state_after: no goals
tactic: exact (LSeriesSummable_of_le_const_mul_rpow (s := y) (EReal.coe_lt_coe_iff.mp hy₁) h
    |>.abscissaOfAbsConv_le.trans_lt hy₂).false
Theorem: FreeAddSemigroup.lift_of_add
File: Mathlib/Algebra/Free.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : Semigroup β
f : α → β
x : α
y : FreeSemigroup α
⊢ (lift f) (of x * y) = f x * (lift f) y
state_after: no goals
tactic: rw [map_mul, lift_of]
Theorem: nndist_div_left
File: Mathlib/Topology/MetricSpace/IsometricSMul.lean

Proof steps:
state_before: M : Type u
G : Type v
X : Type w
inst✝³ : Group G
inst✝² : PseudoMetricSpace G
inst✝¹ : IsometricSMul G G
inst✝ : IsometricSMul Gᵐᵒᵖ G
a b c : G
⊢ nndist (a / b) (a / c) = nndist b c
state_after: no goals
tactic: simp [div_eq_mul_inv]
Theorem: Nat.div_mul_div_le_div
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a✝ b✝ c✝ d m n k : ℕ
p q : ℕ → Prop
a b c : ℕ
⊢ a / c * b / a ≤ b / c
state_after: case inl
a b✝ c✝ d m n k : ℕ
p q : ℕ → Prop
b c : ℕ
⊢ 0 / c * b / 0 ≤ b / c

case inr
a✝ b✝ c✝ d m n k : ℕ
p q : ℕ → Prop
a b c : ℕ
ha : a > 0
⊢ a / c * b / a ≤ b / c
tactic: obtain rfl | ha := Nat.eq_zero_or_pos a
Theorem: LaurentSeries.coeff_coe_powerSeries
File: Mathlib/RingTheory/LaurentSeries.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
x : PowerSeries R
n : ℕ
⊢ ((ofPowerSeries ℤ R) x).coeff ↑n = (PowerSeries.coeff R n) x
state_after: no goals
tactic: rw [ofPowerSeries_apply_coeff]
Theorem: coe_lowerClosure
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 α
inst✝ : Preorder β
s✝ t : Set α
x : α
s : Set α
⊢ ↑(lowerClosure s) = ⋃ a ∈ s, Iic a
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s✝ t : Set α
x : α
s : Set α
x✝ : α
⊢ x✝ ∈ ↑(lowerClosure s) ↔ x✝ ∈ ⋃ a ∈ s, Iic a
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s✝ t : Set α
x : α
s : Set α
x✝ : α
⊢ x✝ ∈ ↑(lowerClosure s) ↔ x✝ ∈ ⋃ a ∈ s, Iic a
state_after: no goals
tactic: simp
Theorem: ENNReal.half_pos
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a ≠ 0
⊢ 0 < a / 2
state_after: no goals
tactic: simp only [div_pos_iff, ne_eq, h, not_false_eq_true, two_ne_top, and_self]
Theorem: Real.arccos_eq_arcsin
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

Proof steps:
state_before: x✝ y x : ℝ
h : 0 ≤ x
⊢ 0 ≤ 2
state_after: no goals
tactic: norm_num
Theorem: CategoryTheory.Sieve.generate_le_iff
File: Mathlib/CategoryTheory/Sites/Sieves.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y✝ Z : C
f✝ : Y✝ ⟶ X
S✝ R✝ : Sieve X
R : Presieve X
S : Sieve X
ss : R ≤ S.arrows
Y : C
f : Y ⟶ X
⊢ (generate R).arrows f → S.arrows f
state_after: case intro.intro.intro.intro
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y✝ Z✝ : C
f✝ : Y✝ ⟶ X
S✝ R✝ : Sieve X
R : Presieve X
S : Sieve X
ss : R ≤ S.arrows
Y Z : C
f : Y ⟶ Z
g : Z ⟶ X
hg : R g
⊢ S.arrows (f ≫ g)
tactic: rintro ⟨Z, f, g, hg, rfl⟩
state_before: case intro.intro.intro.intro
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y✝ Z✝ : C
f✝ : Y✝ ⟶ X
S✝ R✝ : Sieve X
R : Presieve X
S : Sieve X
ss : R ≤ S.arrows
Y Z : C
f : Y ⟶ Z
g : Z ⟶ X
hg : R g
⊢ S.arrows (f ≫ g)
state_after: no goals
tactic: exact S.downward_closed (ss Z hg) f
Theorem: Subgroup.MemRightTransversals.finite_iff
File: Mathlib/GroupTheory/Complement.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : S ∈ rightTransversals ↑H
⊢ Finite ↑S ↔ H.FiniteIndex
state_after: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : S ∈ rightTransversals ↑H
⊢ Finite (G ⧸ H) ↔ H.FiniteIndex
tactic: rw [← (Subgroup.MemRightTransversals.toEquiv h).finite_iff,
    (QuotientGroup.quotientRightRelEquivQuotientLeftRel H).finite_iff]
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : S ∈ rightTransversals ↑H
⊢ Finite (G ⧸ H) ↔ H.FiniteIndex
state_after: no goals
tactic: exact ⟨fun _ ↦ finiteIndex_of_finite_quotient H, fun _ ↦ finite_quotient_of_finiteIndex H⟩
Theorem: PrimeSpectrum.isClosed_singleton_iff_isMaximal
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
x : PrimeSpectrum R
⊢ IsClosed {x} ↔ x.asIdeal.IsMaximal
state_after: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
x : PrimeSpectrum R
⊢ zeroLocus ↑x.asIdeal ⊆ {x} ↔ x.asIdeal.IsMaximal
tactic: rw [← closure_subset_iff_isClosed, ← zeroLocus_vanishingIdeal_eq_closure,
      vanishingIdeal_singleton]
state_before: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
x : PrimeSpectrum R
⊢ zeroLocus ↑x.asIdeal ⊆ {x} ↔ x.asIdeal.IsMaximal
state_after: case mp
R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
x : PrimeSpectrum R
H : zeroLocus ↑x.asIdeal ⊆ {x}
⊢ x.asIdeal.IsMaximal

case mpr
R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
x : PrimeSpectrum R
H : x.asIdeal.IsMaximal
⊢ zeroLocus ↑x.asIdeal ⊆ {x}
tactic: constructor <;> intro H
Theorem: _private.Mathlib.NumberTheory.Padics.Hensel.0.calc_deriv_dist
File: Mathlib/NumberTheory/Padics/Hensel.lean

Proof steps:
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
z z' z1 : ℤ_[p]
hz' : z' = z - z1
hz1 : ‖z1‖ = ‖Polynomial.eval z F‖ / ‖Polynomial.eval a (Polynomial.derivative F)‖
n : ℕ
hz : ih_gen n z
⊢ ‖z' - z‖ = ‖z1‖
state_after: no goals
tactic: simp only [sub_eq_add_neg, add_assoc, hz', add_add_neg_cancel'_right, norm_neg]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
z z' z1 : ℤ_[p]
hz' : z' = z - z1
hz1 : ‖z1‖ = ‖Polynomial.eval z F‖ / ‖Polynomial.eval a (Polynomial.derivative F)‖
n : ℕ
hz : ih_gen n z
⊢ ‖Polynomial.eval z F‖ / ‖Polynomial.eval a (Polynomial.derivative F)‖ ≤
    ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2 * T_gen p F a ^ 2 ^ n /
      ‖Polynomial.eval a (Polynomial.derivative F)‖
state_after: case hab
p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
z z' z1 : ℤ_[p]
hz' : z' = z - z1
hz1 : ‖z1‖ = ‖Polynomial.eval z F‖ / ‖Polynomial.eval a (Polynomial.derivative F)‖
n : ℕ
hz : ih_gen n z
⊢ ‖Polynomial.eval z F‖ ≤ ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2 * T_gen p F a ^ 2 ^ n
tactic: gcongr
state_before: case hab
p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
z z' z1 : ℤ_[p]
hz' : z' = z - z1
hz1 : ‖z1‖ = ‖Polynomial.eval z F‖ / ‖Polynomial.eval a (Polynomial.derivative F)‖
n : ℕ
hz : ih_gen n z
⊢ ‖Polynomial.eval z F‖ ≤ ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2 * T_gen p F a ^ 2 ^ n
state_after: no goals
tactic: apply hz.2
Theorem: Ideal.isMaximal_of_isMaximal_disjoint
File: Mathlib/RingTheory/Jacobson.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝⁴ : CommRing R
inst✝³ : CommRing S
I✝ : Ideal R
y : R
inst✝² : Algebra R S
inst✝¹ : Away y S
inst✝ : IsJacobson R
I : Ideal R
hI : I.IsMaximal
hy : y ∉ I
⊢ (map (algebraMap R S) I).IsMaximal
state_after: R : Type u_1
S : Type u_2
inst✝⁴ : CommRing R
inst✝³ : CommRing S
I✝ : Ideal R
y : R
inst✝² : Algebra R S
inst✝¹ : Away y S
inst✝ : IsJacobson R
I : Ideal R
hI : I.IsMaximal
hy : y ∉ I
⊢ I.IsMaximal ∧ y ∉ I
tactic: rw [isMaximal_iff_isMaximal_disjoint S y,
    comap_map_of_isPrime_disjoint (powers y) S I (IsMaximal.isPrime hI)
      ((disjoint_powers_iff_not_mem y hI.isPrime.isRadical).2 hy)]
state_before: R : Type u_1
S : Type u_2
inst✝⁴ : CommRing R
inst✝³ : CommRing S
I✝ : Ideal R
y : R
inst✝² : Algebra R S
inst✝¹ : Away y S
inst✝ : IsJacobson R
I : Ideal R
hI : I.IsMaximal
hy : y ∉ I
⊢ I.IsMaximal ∧ y ∉ I
state_after: no goals
tactic: exact ⟨hI, hy⟩
Theorem: MeasureTheory.Measure.OuterRegular.smul
File: Mathlib/MeasureTheory/Measure/Regular.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ✝ μ : Measure α
inst✝ : μ.OuterRegular
x : ℝ≥0∞
hx : x ≠ ⊤
⊢ (x • μ).OuterRegular
state_after: case inl
α : Type u_1
β : Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ✝ μ : Measure α
inst✝ : μ.OuterRegular
hx : 0 ≠ ⊤
⊢ (0 • μ).OuterRegular

case inr
α : Type u_1
β : Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ✝ μ : Measure α
inst✝ : μ.OuterRegular
x : ℝ≥0∞
hx : x ≠ ⊤
h0 : x ≠ 0
⊢ (x • μ).OuterRegular
tactic: rcases eq_or_ne x 0 with (rfl | h0)
Theorem: finSuccEquiv'_below
File: Mathlib/Logic/Equiv/Fin.lean

Proof steps:
state_before: m✝ n : ℕ
i : Fin (n + 1)
m : Fin n
h : m.castSucc < i
⊢ (finSuccEquiv' i) m.castSucc = some m
state_after: no goals
tactic: rw [← Fin.succAbove_of_castSucc_lt _ _ h, finSuccEquiv'_succAbove]
Theorem: CategoryTheory.prodOpEquiv_functor_obj
File: Mathlib/CategoryTheory/Products/Basic.lean

Proof steps:
state_before: A : Type u₁
inst✝³ : Category.{v₁, u₁} A
B : Type u₂
inst✝² : Category.{v₂, u₂} B
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
x✝ : (C × D)ᵒᵖ
X : C
Y : D
⊢ { obj := fun X => (op (unop X).1, op (unop X).2), map := fun {X Y} f => (f.unop.1.op, f.unop.2.op), map_id := ⋯,
            map_comp := ⋯ }.map
        ((Iso.refl (𝟭 (C × D)ᵒᵖ)).hom.app (op (X, Y))) ≫
      (Iso.refl
              ({
                  obj := fun x =>
                    match x with
                    | (X, Y) => op (unop X, unop Y),
                  map := fun {X Y} x =>
                    match x with
                    | (f, g) => op (f.unop, g.unop),
                  map_id := ⋯, map_comp := ⋯ } ⋙
                { obj := fun X => (op (unop X).1, op (unop X).2), map := fun {X Y} f => (f.unop.1.op, f.unop.2.op),
                  map_id := ⋯, map_comp := ⋯ })).hom.app
        ({ obj := fun X => (op (unop X).1, op (unop X).2), map := fun {X Y} f => (f.unop.1.op, f.unop.2.op),
              map_id := ⋯, map_comp := ⋯ }.obj
          (op (X, Y))) =
    𝟙
      ({ obj := fun X => (op (unop X).1, op (unop X).2), map := fun {X Y} f => (f.unop.1.op, f.unop.2.op), map_id := ⋯,
            map_comp := ⋯ }.obj
        (op (X, Y)))
state_after: A : Type u₁
inst✝³ : Category.{v₁, u₁} A
B : Type u₂
inst✝² : Category.{v₂, u₂} B
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
x✝ : (C × D)ᵒᵖ
X : C
Y : D
⊢ (𝟙 (op X) ≫ 𝟙 (op X), 𝟙 (op Y) ≫ 𝟙 (op Y)) = (𝟙 (op X), 𝟙 (op Y))
tactic: dsimp
state_before: A : Type u₁
inst✝³ : Category.{v₁, u₁} A
B : Type u₂
inst✝² : Category.{v₂, u₂} B
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
x✝ : (C × D)ᵒᵖ
X : C
Y : D
⊢ (𝟙 (op X) ≫ 𝟙 (op X), 𝟙 (op Y) ≫ 𝟙 (op Y)) = (𝟙 (op X), 𝟙 (op Y))
state_after: no goals
tactic: ext <;> apply Category.id_comp
Theorem: MeasureTheory.Measure.dirac_bind
File: Mathlib/MeasureTheory/Measure/GiryMonad.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
m : Measure α
⊢ m.bind dirac = m
state_after: case h
α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
m : Measure α
s : Set α
hs : MeasurableSet s
⊢ (m.bind dirac) s = m s
tactic: ext1 s hs
state_before: case h
α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
m : Measure α
s : Set α
hs : MeasurableSet s
⊢ (m.bind dirac) s = m s
state_after: no goals
tactic: simp only [bind_apply hs measurable_dirac, dirac_apply' _ hs, lintegral_indicator 1 hs,
    Pi.one_apply, lintegral_one, restrict_apply, MeasurableSet.univ, univ_inter]
Theorem: Set.Nat.encard_range
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t : Set α
k : ℕ
⊢ {i | i < k}.encard = ↑k
state_after: case h.e'_2
α : Type u_1
β : Type u_2
s t : Set α
k : ℕ
⊢ {i | i < k}.encard = (↑(Finset.range k)).encard

case h.e'_3
α : Type u_1
β : Type u_2
s t : Set α
k : ℕ
⊢ ↑k = ↑(Finset.range k).card
tactic: convert encard_coe_eq_coe_finsetCard (Finset.range k) using 1
state_before: case h.e'_3
α : Type u_1
β : Type u_2
s t : Set α
k : ℕ
⊢ ↑k = ↑(Finset.range k).card
state_after: no goals
tactic: rw [Finset.card_range]
Theorem: Substring.ValidFor.bsize
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: l m r : List Char
⊢ { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l },
        stopPos := { byteIdx := utf8Len l + utf8Len m } }.bsize =
    utf8Len m
state_after: no goals
tactic: simp [Substring.bsize, Nat.add_sub_cancel_left]
Theorem: NumberField.ComplexEmbedding.IsConj.symm
File: Mathlib/NumberTheory/NumberField/Embeddings.lean

Proof steps:
state_before: K : Type u_1
inst✝² : Field K
k : Type u_2
inst✝¹ : Field k
inst✝ : Algebra k K
φ : K →+* ℂ
σ : K ≃ₐ[k] K
hσ : IsConj φ σ
x : K
⊢ (conjugate φ) x = (φ.comp ↑σ.symm) x
state_after: no goals
tactic: simpa using congr_arg star (hσ.eq (σ.symm x))
Theorem: AddHom.prod_unique
File: Mathlib/Algebra/Group/Prod.lean

Proof steps:
state_before: A : Type u_1
B : Type u_2
G : Type u_3
H : Type u_4
M : Type u_5
N : Type u_6
P : Type u_7
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
f : M →ₙ* N × P
x : M
⊢ (((fst N P).comp f).prod ((snd N P).comp f)) x = f x
state_after: no goals
tactic: simp only [prod_apply, coe_fst, coe_snd, comp_apply]
Theorem: Ordinal.IsNormal.apply_le_nfp
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

Proof steps:
state_before: f✝ : Ordinal.{u} → Ordinal.{u}
f : Ordinal.{u_1} → Ordinal.{u_1}
H : IsNormal f
a b : Ordinal.{u_1}
h : b ≤ nfp f a
⊢ f b ≤ nfp f a
state_after: no goals
tactic: simpa only [H.nfp_fp] using H.le_iff.2 h
Theorem: Polynomial.smul_eq_map
File: Mathlib/Algebra/Polynomial/GroupRingAction.lean

Proof steps:
state_before: M : Type u_1
inst✝² : Monoid M
R : Type u_2
inst✝¹ : Semiring R
inst✝ : MulSemiringAction M R
m : M
⊢ HSMul.hSMul m = map (MulSemiringAction.toRingHom M R m)
state_after: M : Type u_1
inst✝² : Monoid M
R : Type u_2
inst✝¹ : Semiring R
inst✝ : MulSemiringAction M R
m : M
⊢ DistribMulAction.toAddMonoidHom R[X] m = (mapRingHom (MulSemiringAction.toRingHom M R m)).toAddMonoidHom
tactic: suffices DistribMulAction.toAddMonoidHom R[X] m =
      (mapRingHom (MulSemiringAction.toRingHom M R m)).toAddMonoidHom by
    ext1 r
    exact DFunLike.congr_fun this r
state_before: M : Type u_1
inst✝² : Monoid M
R : Type u_2
inst✝¹ : Semiring R
inst✝ : MulSemiringAction M R
m : M
⊢ DistribMulAction.toAddMonoidHom R[X] m = (mapRingHom (MulSemiringAction.toRingHom M R m)).toAddMonoidHom
state_after: case h.h
M : Type u_1
inst✝² : Monoid M
R : Type u_2
inst✝¹ : Semiring R
inst✝ : MulSemiringAction M R
m : M
n : ℕ
r : R
⊢ ((DistribMulAction.toAddMonoidHom R[X] m).comp (monomial n).toAddMonoidHom) r =
    ((mapRingHom (MulSemiringAction.toRingHom M R m)).toAddMonoidHom.comp (monomial n).toAddMonoidHom) r
tactic: ext n r : 2
state_before: case h.h
M : Type u_1
inst✝² : Monoid M
R : Type u_2
inst✝¹ : Semiring R
inst✝ : MulSemiringAction M R
m : M
n : ℕ
r : R
⊢ ((DistribMulAction.toAddMonoidHom R[X] m).comp (monomial n).toAddMonoidHom) r =
    ((mapRingHom (MulSemiringAction.toRingHom M R m)).toAddMonoidHom.comp (monomial n).toAddMonoidHom) r
state_after: case h.h
M : Type u_1
inst✝² : Monoid M
R : Type u_2
inst✝¹ : Semiring R
inst✝ : MulSemiringAction M R
m : M
n : ℕ
r : R
⊢ m • (monomial n) r = map (MulSemiringAction.toRingHom M R m) ((monomial n) r)
tactic: change m • monomial n r = map (MulSemiringAction.toRingHom M R m) (monomial n r)
state_before: case h.h
M : Type u_1
inst✝² : Monoid M
R : Type u_2
inst✝¹ : Semiring R
inst✝ : MulSemiringAction M R
m : M
n : ℕ
r : R
⊢ m • (monomial n) r = map (MulSemiringAction.toRingHom M R m) ((monomial n) r)
state_after: no goals
tactic: rw [Polynomial.map_monomial, Polynomial.smul_monomial, MulSemiringAction.toRingHom_apply]
Theorem: mul_one_sub
File: Mathlib/Algebra/Ring/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : NonAssocRing α
a b : α
⊢ a * (1 - b) = a - a * b
state_after: no goals
tactic: rw [mul_sub, mul_one]
Theorem: Metric.mem_ball_self
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
h : 0 < ε
⊢ x ∈ ball x ε
state_after: no goals
tactic: rwa [mem_ball, dist_self]