ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasurableEmbedding.essSup_map_measure
File: Mathlib/MeasureTheory/Function/EssSup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝ : CompleteLattice β
γ : Type u_3
mγ : MeasurableSpace γ
f : α → γ
g : γ → β
hf : MeasurableEmbedding f
⊢ essSup g (Measure.map f μ) = essSup (g ∘ f) μ
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝ : CompleteLattice β
γ : Type u_3
mγ : MeasurableSpace γ
f : α → γ
g : γ → β
hf : MeasurableEmbedding f
⊢ essSup g (Measure.map f μ) ≤ essSup (g ∘ f) μ
tactic: refine le_antisymm ?_ (essSup_comp_le_essSup_map_measure hf.measurable.aemeasurable)
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝ : CompleteLattice β
γ : Type u_3
mγ : MeasurableSpace γ
f : α → γ
g : γ → β
hf : MeasurableEmbedding f
⊢ essSup g (Measure.map f μ) ≤ essSup (g ∘ f) μ
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝ : CompleteLattice β
γ : Type u_3
mγ : MeasurableSpace γ
f : α → γ
g : γ → β
hf : MeasurableEmbedding f
c : β
h_le : ∀ᶠ (n : β) in map (g ∘ f) (ae μ), n ≤ c
⊢ ∀ᶠ (n : β) in map g (ae (Measure.map f μ)), n ≤ c
tactic: refine limsSup_le_limsSup (by isBoundedDefault) (by isBoundedDefault) (fun c h_le => ?_)
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝ : CompleteLattice β
γ : Type u_3
mγ : MeasurableSpace γ
f : α → γ
g : γ → β
hf : MeasurableEmbedding f
c : β
h_le : ∀ᶠ (n : β) in map (g ∘ f) (ae μ), n ≤ c
⊢ ∀ᶠ (n : β) in map g (ae (Measure.map f μ)), n ≤ c
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝ : CompleteLattice β
γ : Type u_3
mγ : MeasurableSpace γ
f : α → γ
g : γ → β
hf : MeasurableEmbedding f
c : β
h_le : ∀ᵐ (a : α) ∂μ, (g ∘ f) a ≤ c
⊢ ∀ᵐ (a : γ) ∂Measure.map f μ, g a ≤ c
tactic: rw [eventually_map] at h_le ⊢
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝ : CompleteLattice β
γ : Type u_3
mγ : MeasurableSpace γ
f : α → γ
g : γ → β
hf : MeasurableEmbedding f
c : β
h_le : ∀ᵐ (a : α) ∂μ, (g ∘ f) a ≤ c
⊢ ∀ᵐ (a : γ) ∂Measure.map f μ, g a ≤ c
state_after: no goals
tactic: exact hf.ae_map_iff.mpr h_le
Theorem: MeasureTheory.measure_union_eq_top_iff
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
⊢ ¬μ (s ∪ t) = ⊤ ↔ ¬(μ s = ⊤ ∨ μ t = ⊤)
state_after: no goals
tactic: simp only [← lt_top_iff_ne_top, ← Ne.eq_def, not_or, measure_union_lt_top_iff]
Theorem: MeasureTheory.Submartingale.stoppedValue_leastGE
File: Mathlib/Probability/Martingale/BorelCantelli.lean

Proof steps:
state_before: Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
r : ℝ
⊢ Submartingale (fun i => stoppedValue f (leastGE f r i)) ℱ μ
state_after: Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
r : ℝ
⊢ ∀ (τ π : Ω → ℕ),
    IsStoppingTime ℱ τ →
      IsStoppingTime ℱ π →
        τ ≤ π →
          (∃ N, ∀ (x : Ω), π x ≤ N) →
            ∫ (x : Ω), stoppedValue (fun i => stoppedValue f (leastGE f r i)) τ x ∂μ ≤
              ∫ (x : Ω), stoppedValue (fun i => stoppedValue f (leastGE f r i)) π x ∂μ

case hadp
Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
r : ℝ
⊢ Adapted ℱ fun i => stoppedValue f (leastGE f r i)

case hint
Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
r : ℝ
⊢ ∀ (i : ℕ), Integrable (stoppedValue f (leastGE f r i)) μ
tactic: rw [submartingale_iff_expected_stoppedValue_mono]
Theorem: Behrend.div_lt_floor
File: Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x✝ : Fin n → ℕ
x : ℝ
hx : 2 / (1 - 2 / rexp 1) ≤ x
⊢ x / rexp 1 < ↑⌊x / 2⌋₊
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x✝ : Fin n → ℕ
x : ℝ
hx : 2 / (1 - 2 / rexp 1) ≤ x
⊢ x / rexp 1 ≤ x / 2 - 1
tactic: apply lt_of_le_of_lt _ (sub_one_lt_floor _)
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x✝ : Fin n → ℕ
x : ℝ
hx : 2 / (1 - 2 / rexp 1) ≤ x
⊢ x / rexp 1 ≤ x / 2 - 1
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x✝ : Fin n → ℕ
x : ℝ
hx : 2 / (1 - 2 / rexp 1) ≤ x
this : 0 < 1 - 2 / rexp 1
⊢ x / rexp 1 ≤ x / 2 - 1
tactic: have : 0 < 1 - 2 / exp 1 := by
    rw [sub_pos, div_lt_one (exp_pos _)]
    exact lt_of_le_of_lt (by norm_num) exp_one_gt_d9
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x✝ : Fin n → ℕ
x : ℝ
hx : 2 / (1 - 2 / rexp 1) ≤ x
this : 0 < 1 - 2 / rexp 1
⊢ x / rexp 1 ≤ x / 2 - 1
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x✝ : Fin n → ℕ
x : ℝ
hx : 2 / (1 - 2 / rexp 1) ≤ x
this : 0 < 1 - 2 / rexp 1
⊢ 0 < 2

case hc
α : Type u_1
β : Type u_2
n d k N : ℕ
x✝ : Fin n → ℕ
x : ℝ
hx : 2 / (1 - 2 / rexp 1) ≤ x
this : 0 < 1 - 2 / rexp 1
⊢ 2 ≠ 0
tactic: rwa [le_sub_comm, div_eq_mul_one_div x, div_eq_mul_one_div x, ← mul_sub, div_sub', ←
    div_eq_mul_one_div, mul_div_assoc', one_le_div, ← div_le_iff this]
Theorem: IsPrimitiveRoot.minpoly_eq_pow_coprime
File: Mathlib/RingTheory/RootsOfUnity/Minpoly.lean

Proof steps:
state_before: n : ℕ
K : Type u_1
inst✝² : CommRing K
μ : K
h : IsPrimitiveRoot μ n
inst✝¹ : IsDomain K
inst✝ : CharZero K
m : ℕ
hcop : m.Coprime n
⊢ minpoly ℤ μ = minpoly ℤ (μ ^ m)
state_after: K : Type u_1
inst✝² : CommRing K
μ : K
inst✝¹ : IsDomain K
inst✝ : CharZero K
m : ℕ
⊢ ∀ {n : ℕ}, IsPrimitiveRoot μ n → m.Coprime n → minpoly ℤ μ = minpoly ℤ (μ ^ m)
tactic: revert n hcop
state_before: K : Type u_1
inst✝² : CommRing K
μ : K
inst✝¹ : IsDomain K
inst✝ : CharZero K
m : ℕ
⊢ ∀ {n : ℕ}, IsPrimitiveRoot μ n → m.Coprime n → minpoly ℤ μ = minpoly ℤ (μ ^ m)
state_after: case refine_1
K : Type u_1
inst✝² : CommRing K
μ : K
inst✝¹ : IsDomain K
inst✝ : CharZero K
m n✝ : ℕ
⊢ IsPrimitiveRoot μ n✝ → Nat.Coprime 0 n✝ → minpoly ℤ μ = minpoly ℤ (μ ^ 0)

case refine_2
K : Type u_1
inst✝² : CommRing K
μ : K
inst✝¹ : IsDomain K
inst✝ : CharZero K
m n✝ : ℕ
⊢ ∀ (x : ℕ), IsUnit x → IsPrimitiveRoot μ n✝ → x.Coprime n✝ → minpoly ℤ μ = minpoly ℤ (μ ^ x)

case refine_3
K : Type u_1
inst✝² : CommRing K
μ : K
inst✝¹ : IsDomain K
inst✝ : CharZero K
m n✝ : ℕ
⊢ ∀ (a p : ℕ),
    a ≠ 0 →
      Prime p →
        (IsPrimitiveRoot μ n✝ → a.Coprime n✝ → minpoly ℤ μ = minpoly ℤ (μ ^ a)) →
          IsPrimitiveRoot μ n✝ → (p * a).Coprime n✝ → minpoly ℤ μ = minpoly ℤ (μ ^ (p * a))
tactic: refine UniqueFactorizationMonoid.induction_on_prime m ?_ ?_ ?_
Theorem: associated_of_factorization_eq
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : UniqueFactorizationMonoid α
inst✝¹ : NormalizationMonoid α
inst✝ : DecidableEq α
a b : α
ha : a ≠ 0
hb : b ≠ 0
h : factorization a = factorization b
⊢ a ~ᵤ b
state_after: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : UniqueFactorizationMonoid α
inst✝¹ : NormalizationMonoid α
inst✝ : DecidableEq α
a b : α
ha : a ≠ 0
hb : b ≠ 0
h : normalizedFactors a = normalizedFactors b
⊢ a ~ᵤ b
tactic: simp_rw [factorization, AddEquiv.apply_eq_iff_eq] at h
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : UniqueFactorizationMonoid α
inst✝¹ : NormalizationMonoid α
inst✝ : DecidableEq α
a b : α
ha : a ≠ 0
hb : b ≠ 0
h : normalizedFactors a = normalizedFactors b
⊢ a ~ᵤ b
state_after: no goals
tactic: rwa [associated_iff_normalizedFactors_eq_normalizedFactors ha hb]
Theorem: IsBezout.dvd_gcd
File: Mathlib/RingTheory/PrincipalIdealDomain.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝¹ : CommRing R
x y z : R
inst✝ : IsPrincipal (Ideal.span {x, y})
hx : z ∣ x
hy : z ∣ y
⊢ z ∣ gcd x y
state_after: R : Type u
M : Type v
inst✝¹ : CommRing R
x y z : R
inst✝ : IsPrincipal (Ideal.span {x, y})
hx : Ideal.span {x} ≤ Ideal.span {z}
hy : Ideal.span {y} ≤ Ideal.span {z}
⊢ Ideal.span {gcd x y} ≤ Ideal.span {z}
tactic: rw [← Ideal.span_singleton_le_span_singleton] at hx hy ⊢
state_before: R : Type u
M : Type v
inst✝¹ : CommRing R
x y z : R
inst✝ : IsPrincipal (Ideal.span {x, y})
hx : Ideal.span {x} ≤ Ideal.span {z}
hy : Ideal.span {y} ≤ Ideal.span {z}
⊢ Ideal.span {gcd x y} ≤ Ideal.span {z}
state_after: R : Type u
M : Type v
inst✝¹ : CommRing R
x y z : R
inst✝ : IsPrincipal (Ideal.span {x, y})
hx : Ideal.span {x} ≤ Ideal.span {z}
hy : Ideal.span {y} ≤ Ideal.span {z}
⊢ Ideal.span {x} ≤ Ideal.span {z} ∧ Ideal.span {y} ≤ Ideal.span {z}
tactic: rw [span_gcd, Ideal.span_insert, sup_le_iff]
state_before: R : Type u
M : Type v
inst✝¹ : CommRing R
x y z : R
inst✝ : IsPrincipal (Ideal.span {x, y})
hx : Ideal.span {x} ≤ Ideal.span {z}
hy : Ideal.span {y} ≤ Ideal.span {z}
⊢ Ideal.span {x} ≤ Ideal.span {z} ∧ Ideal.span {y} ≤ Ideal.span {z}
state_after: no goals
tactic: exact ⟨hx, hy⟩
Theorem: Complex.IsExpCmpFilter.isLittleO_cpow_mul_exp
File: Mathlib/Analysis/SpecialFunctions/CompareExp.lean

Proof steps:
state_before: l : Filter ℂ
b₁ b₂ : ℝ
hl : IsExpCmpFilter l
hb : b₁ < b₂
a₁ a₂ z : ℂ
hz : z ≠ 0
⊢ (fun z => z ^ a₁ * cexp (↑b₁ * z)) z = (fun z => z ^ a₂ * cexp (↑b₁ * z) * z ^ (a₁ - a₂)) z
state_after: l : Filter ℂ
b₁ b₂ : ℝ
hl : IsExpCmpFilter l
hb : b₁ < b₂
a₁ a₂ z : ℂ
hz : z ≠ 0
⊢ z ^ a₁ * cexp (↑b₁ * z) = z ^ a₂ * cexp (↑b₁ * z) * z ^ (a₁ - a₂)
tactic: simp only
state_before: l : Filter ℂ
b₁ b₂ : ℝ
hl : IsExpCmpFilter l
hb : b₁ < b₂
a₁ a₂ z : ℂ
hz : z ≠ 0
⊢ z ^ a₁ * cexp (↑b₁ * z) = z ^ a₂ * cexp (↑b₁ * z) * z ^ (a₁ - a₂)
state_after: no goals
tactic: rw [mul_right_comm, ← cpow_add _ _ hz, add_sub_cancel]
state_before: l : Filter ℂ
b₁ b₂ : ℝ
hl : IsExpCmpFilter l
hb : b₁ < b₂
a₁ a₂ : ℂ
⊢ (fun z => z ^ a₂ * cexp (↑b₁ * z) * cexp (↑(b₂ - b₁) * z)) =ᶠ[l] fun z => z ^ a₂ * cexp (↑b₂ * z)
state_after: l : Filter ℂ
b₁ b₂ : ℝ
hl : IsExpCmpFilter l
hb : b₁ < b₂
a₁ a₂ : ℂ
⊢ (fun z => z ^ a₂ * cexp (↑b₂ * z)) =ᶠ[l] fun z => z ^ a₂ * cexp (↑b₂ * z)
tactic: simp only [ofReal_sub, sub_mul, mul_assoc, ← exp_add, add_sub_cancel]
state_before: l : Filter ℂ
b₁ b₂ : ℝ
hl : IsExpCmpFilter l
hb : b₁ < b₂
a₁ a₂ : ℂ
⊢ (fun z => z ^ a₂ * cexp (↑b₂ * z)) =ᶠ[l] fun z => z ^ a₂ * cexp (↑b₂ * z)
state_after: no goals
tactic: norm_cast
Theorem: Class.congToClass_empty
File: Mathlib/SetTheory/ZFC/Basic.lean

Proof steps:
state_before: ⊢ congToClass ∅ = ∅
state_after: case a
z : ZFSet
⊢ congToClass ∅ z ↔ ∅ z
tactic: ext z
state_before: case a
z : ZFSet
⊢ congToClass ∅ z ↔ ∅ z
state_after: case a
z : ZFSet
⊢ ¬{y | ↑y ∈ ∅} z
tactic: simp only [congToClass, not_empty_hom, iff_false_iff]
state_before: case a
z : ZFSet
⊢ ¬{y | ↑y ∈ ∅} z
state_after: no goals
tactic: exact Set.not_mem_empty z
Theorem: CategoryTheory.ShortComplex.map_X₂
File: Mathlib/Algebra/Homology/ShortComplex/Basic.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{?u.33376, u_1} C
inst✝³ : Category.{?u.33380, u_2} D
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
inst✝¹ : HasZeroMorphisms D
F : C ⥤ D
inst✝ : F.PreservesZeroMorphisms
⊢ F.map S.f ≫ F.map S.g = 0
state_after: no goals
tactic: rw [← F.map_comp, S.zero, F.map_zero]
Theorem: Rel.image_univ
File: Mathlib/Data/Rel.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : Rel α β
⊢ r.image Set.univ = r.codom
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
r : Rel α β
y : β
⊢ y ∈ r.image Set.univ ↔ y ∈ r.codom
tactic: ext y
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
r : Rel α β
y : β
⊢ y ∈ r.image Set.univ ↔ y ∈ r.codom
state_after: no goals
tactic: simp [mem_image, codom]
Theorem: List.Sublist.erase
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
inst✝ : BEq α
a : α
l₁ l₂ : List α
h : l₁ <+ l₂
⊢ l₁.erase a <+ l₂.erase a
state_after: α : Type u_1
inst✝ : BEq α
a : α
l₁ l₂ : List α
h : l₁ <+ l₂
⊢ eraseP (fun x => x == a) l₁ <+ eraseP (fun x => x == a) l₂
tactic: simp only [erase_eq_eraseP']
state_before: α : Type u_1
inst✝ : BEq α
a : α
l₁ l₂ : List α
h : l₁ <+ l₂
⊢ eraseP (fun x => x == a) l₁ <+ eraseP (fun x => x == a) l₂
state_after: no goals
tactic: exact h.eraseP
Theorem: CategoryTheory.FunctorToTypes.binaryCoproductEquiv_symm_apply
File: Mathlib/CategoryTheory/Limits/Shapes/FunctorToTypes.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
F G : C ⥤ Type w
a : C
x✝ : (F ⨿ G).obj a
⊢ (fun z => (binaryCoproductIso F G).inv.app a z) ((fun z => (binaryCoproductIso F G).hom.app a z) x✝) = x✝
state_after: no goals
tactic: simp only [hom_inv_id_app_apply]
state_before: C : Type u
inst✝ : Category.{v, u} C
F G : C ⥤ Type w
a : C
x✝ : F.obj a ⊕ G.obj a
⊢ (fun z => (binaryCoproductIso F G).hom.app a z) ((fun z => (binaryCoproductIso F G).inv.app a z) x✝) = x✝
state_after: no goals
tactic: simp only [inv_hom_id_app_apply]
Theorem: Real.BohrMollerup.f_add_nat_ge
File: Mathlib/Analysis/SpecialFunctions/Gamma/BohrMollerup.lean

Proof steps:
state_before: f : ℝ → ℝ
x : ℝ
n : ℕ
hf_conv : ConvexOn ℝ (Ioi 0) f
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : 2 ≤ n
hx : 0 < x
⊢ f ↑n + x * log (↑n - 1) ≤ f (↑n + x)
state_after: f : ℝ → ℝ
x : ℝ
n : ℕ
hf_conv : ConvexOn ℝ (Ioi 0) f
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : 2 ≤ n
hx : 0 < x
npos : 0 < ↑n - 1
⊢ f ↑n + x * log (↑n - 1) ≤ f (↑n + x)
tactic: have npos : 0 < (n : ℝ) - 1 := by rw [← Nat.cast_one, sub_pos, Nat.cast_lt]; linarith
state_before: f : ℝ → ℝ
x : ℝ
n : ℕ
hf_conv : ConvexOn ℝ (Ioi 0) f
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : 2 ≤ n
hx : 0 < x
npos : 0 < ↑n - 1
⊢ f ↑n + x * log (↑n - 1) ≤ f (↑n + x)
state_after: f : ℝ → ℝ
x : ℝ
n : ℕ
hf_conv : ConvexOn ℝ (Ioi 0) f
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : 2 ≤ n
hx : 0 < x
npos : 0 < ↑n - 1
c : (f ↑n - f (↑n - 1)) / (↑n - (↑n - 1)) ≤ (f (↑n + x) - f ↑n) / (↑n + x - ↑n)
⊢ f ↑n + x * log (↑n - 1) ≤ f (↑n + x)
tactic: have c :=
    (convexOn_iff_slope_mono_adjacent.mp <| hf_conv).2 npos (by linarith : 0 < (n : ℝ) + x)
      (by linarith : (n : ℝ) - 1 < (n : ℝ)) (by linarith)
state_before: f : ℝ → ℝ
x : ℝ
n : ℕ
hf_conv : ConvexOn ℝ (Ioi 0) f
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : 2 ≤ n
hx : 0 < x
npos : 0 < ↑n - 1
c : (f ↑n - f (↑n - 1)) / (↑n - (↑n - 1)) ≤ (f (↑n + x) - f ↑n) / (↑n + x - ↑n)
⊢ f ↑n + x * log (↑n - 1) ≤ f (↑n + x)
state_after: f : ℝ → ℝ
x : ℝ
n : ℕ
hf_conv : ConvexOn ℝ (Ioi 0) f
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : 2 ≤ n
hx : 0 < x
npos : 0 < ↑n - 1
c : f ↑n - f (↑n - 1) ≤ (f (↑n + x) - f ↑n) / x
⊢ f ↑n + x * log (↑n - 1) ≤ f (↑n + x)
tactic: rw [add_sub_cancel_left, sub_sub_cancel, div_one] at c
state_before: f : ℝ → ℝ
x : ℝ
n : ℕ
hf_conv : ConvexOn ℝ (Ioi 0) f
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : 2 ≤ n
hx : 0 < x
npos : 0 < ↑n - 1
c : f ↑n - f (↑n - 1) ≤ (f (↑n + x) - f ↑n) / x
⊢ f ↑n + x * log (↑n - 1) ≤ f (↑n + x)
state_after: f : ℝ → ℝ
x : ℝ
n : ℕ
hf_conv : ConvexOn ℝ (Ioi 0) f
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : 2 ≤ n
hx : 0 < x
npos : 0 < ↑n - 1
c : f ↑n - f (↑n - 1) ≤ (f (↑n + x) - f ↑n) / x
this : f (↑n - 1) = f ↑n - log (↑n - 1)
⊢ f ↑n + x * log (↑n - 1) ≤ f (↑n + x)
tactic: have : f (↑n - 1) = f n - log (↑n - 1) := by
    -- Porting note: was
    -- nth_rw_rhs 1 [(by ring : (n : ℝ) = ↑n - 1 + 1)]
    -- rw [hf_feq npos, add_sub_cancel]
    rw [eq_sub_iff_add_eq, ← hf_feq npos, sub_add_cancel]
state_before: f : ℝ → ℝ
x : ℝ
n : ℕ
hf_conv : ConvexOn ℝ (Ioi 0) f
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : 2 ≤ n
hx : 0 < x
npos : 0 < ↑n - 1
c : f ↑n - f (↑n - 1) ≤ (f (↑n + x) - f ↑n) / x
this : f (↑n - 1) = f ↑n - log (↑n - 1)
⊢ f ↑n + x * log (↑n - 1) ≤ f (↑n + x)
state_after: no goals
tactic: rwa [this, le_div_iff hx, sub_sub_cancel, le_sub_iff_add_le, mul_comm _ x, add_comm] at c
Theorem: WeierstrassCurve.Affine.map_negAddY
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W : Affine R
S : Type v
inst✝ : CommRing S
f : R →+* S
x₁ x₂ y₁ L : R
⊢ (map W f).toAffine.negAddY (f x₁) (f x₂) (f y₁) (f L) = f (W.negAddY x₁ x₂ y₁ L)
state_after: R : Type u
inst✝¹ : CommRing R
W : Affine R
S : Type v
inst✝ : CommRing S
f : R →+* S
x₁ x₂ y₁ L : R
⊢ f L * (f (W.addX x₁ x₂ L) - f x₁) + f y₁ = f (L * (W.addX x₁ x₂ L - x₁) + y₁)
tactic: simp only [negAddY, map_addX]
state_before: R : Type u
inst✝¹ : CommRing R
W : Affine R
S : Type v
inst✝ : CommRing S
f : R →+* S
x₁ x₂ y₁ L : R
⊢ f L * (f (W.addX x₁ x₂ L) - f x₁) + f y₁ = f (L * (W.addX x₁ x₂ L - x₁) + y₁)
state_after: no goals
tactic: map_simp
Theorem: SemistandardYoungTableau.row_weak_of_le
File: Mathlib/Combinatorics/Young/SemistandardTableau.lean

Proof steps:
state_before: μ : YoungDiagram
T : SemistandardYoungTableau μ
i j1 j2 : ℕ
hj : j1 ≤ j2
cell : (i, j2) ∈ μ
⊢ T i j1 ≤ T i j2
state_after: case inl
μ : YoungDiagram
T : SemistandardYoungTableau μ
i j1 j2 : ℕ
hj : j1 ≤ j2
cell : (i, j2) ∈ μ
h : j1 = j2
⊢ T i j1 ≤ T i j2

case inr
μ : YoungDiagram
T : SemistandardYoungTableau μ
i j1 j2 : ℕ
hj : j1 ≤ j2
cell : (i, j2) ∈ μ
h : j1 < j2
⊢ T i j1 ≤ T i j2
tactic: cases' eq_or_lt_of_le hj with h h
Theorem: CategoryTheory.GradedObject.single_map_singleObjApplyIsoOfEq_hom
File: Mathlib/CategoryTheory/GradedObject/Single.lean

Proof steps:
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{u_3, u_2} C
inst✝¹ : HasInitial C
inst✝ : DecidableEq J
j : J
X Y : C
f : X ⟶ Y
i : J
h : i = j
⊢ (single j).map f i ≫ (singleObjApplyIsoOfEq j Y i h).hom = (singleObjApplyIsoOfEq j X i h).hom ≫ f
state_after: J : Type u_1
C : Type u_2
inst✝² : Category.{u_3, u_2} C
inst✝¹ : HasInitial C
inst✝ : DecidableEq J
X Y : C
f : X ⟶ Y
i : J
⊢ (single i).map f i ≫ (singleObjApplyIsoOfEq i Y i ⋯).hom = (singleObjApplyIsoOfEq i X i ⋯).hom ≫ f
tactic: subst h
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{u_3, u_2} C
inst✝¹ : HasInitial C
inst✝ : DecidableEq J
X Y : C
f : X ⟶ Y
i : J
⊢ (single i).map f i ≫ (singleObjApplyIsoOfEq i Y i ⋯).hom = (singleObjApplyIsoOfEq i X i ⋯).hom ≫ f
state_after: no goals
tactic: simp [singleObjApplyIsoOfEq, single]
Theorem: Metric.emetric_ball
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 : α
ε : ℝ
⊢ EMetric.ball x (ENNReal.ofReal ε) = ball x ε
state_after: case h
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x : α
ε : ℝ
y : α
⊢ y ∈ EMetric.ball x (ENNReal.ofReal ε) ↔ y ∈ ball x ε
tactic: ext y
state_before: case h
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x : α
ε : ℝ
y : α
⊢ y ∈ EMetric.ball x (ENNReal.ofReal ε) ↔ y ∈ ball x ε
state_after: case h
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x : α
ε : ℝ
y : α
⊢ ENNReal.ofReal (dist y x) < ENNReal.ofReal ε ↔ dist y x < ε
tactic: simp only [EMetric.mem_ball, mem_ball, edist_dist]
state_before: case h
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x : α
ε : ℝ
y : α
⊢ ENNReal.ofReal (dist y x) < ENNReal.ofReal ε ↔ dist y x < ε
state_after: no goals
tactic: exact ENNReal.ofReal_lt_ofReal_iff_of_nonneg dist_nonneg
Theorem: DFinsupp.update_eq_sub_add_single
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β✝ : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β✝ i)
s : Finset ι
x : (i : ↑↑s) → β✝ ↑i
i✝ : ι
f✝ : Π₀ (i : ι), β✝ i
b✝ : β✝ i✝
j : ι
β : ι → Type u_1
inst✝ : (i : ι) → AddGroup (β i)
f : Π₀ (i : ι), β i
i : ι
b : β i
⊢ update i f b = f - single i (f i) + single i b
state_after: no goals
tactic: rw [update_eq_erase_add_single f i b, erase_eq_sub_single f i]
Theorem: boole_mul
File: Mathlib/Algebra/Ring/Defs.lean

Proof steps:
state_before: α✝ : Type u
β : Type v
γ : Type w
R : Type x
α : Type u_1
inst✝¹ : MulZeroOneClass α
P : Prop
inst✝ : Decidable P
a : α
⊢ (if P then 1 else 0) * a = if P then a else 0
state_after: no goals
tactic: simp
Theorem: Submodule.ker_liftQ_eq_bot
File: Mathlib/LinearAlgebra/Quotient.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
r : R
x y : M
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
p p' : Submodule R M
R₂ : Type u_3
M₂ : Type u_4
inst✝² : Ring R₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R₂ M₂
τ₁₂ : R →+* R₂
q : Submodule R₂ M₂
f : M →ₛₗ[τ₁₂] M₂
h : p ≤ ker f
h' : ker f ≤ p
⊢ ker (p.liftQ f h) = ⊥
state_after: no goals
tactic: rw [ker_liftQ, le_antisymm h h', mkQ_map_self]
Theorem: SatisfiesM_Option_eq
File: .lake/packages/batteries/Batteries/Classes/SatisfiesM.lean

Proof steps:
state_before: α✝ : Type u_1
p : α✝ → Prop
x : Option α✝
⊢ SatisfiesM p x → ∀ (a : α✝), x = some a → p a
state_after: α✝ : Type u_1
p : α✝ → Prop
⊢ ∀ {x : Option α✝}, SatisfiesM p x → ∀ (a : α✝), x = some a → p a
tactic: revert x
state_before: α✝ : Type u_1
p : α✝ → Prop
⊢ ∀ {x : Option α✝}, SatisfiesM p x → ∀ (a : α✝), x = some a → p a
state_after: no goals
tactic: intro | some _, ⟨some ⟨_, h⟩, rfl⟩, _, rfl => exact h
Theorem: IsPGroup.cyclic_center_quotient_of_card_eq_prime_sq
File: Mathlib/GroupTheory/PGroup.lean

Proof steps:
state_before: p : ℕ
G : Type u_1
inst✝¹ : Group G
inst✝ : Fact (Nat.Prime p)
n : ℕ
hGpn : Nat.card G = p ^ n
hG : Nat.card G = p ^ 2
⊢ IsCyclic (G ⧸ center G)
state_after: p : ℕ
G : Type u_1
inst✝¹ : Group G
inst✝ : Fact (Nat.Prime p)
n : ℕ
hGpn : Nat.card G = p ^ n
hG : Nat.card G = p ^ 2
⊢ Nat.card (G ⧸ center G) ∣ p
tactic: apply isCyclic_of_card_dvd_prime (p := p)
state_before: p : ℕ
G : Type u_1
inst✝¹ : Group G
inst✝ : Fact (Nat.Prime p)
n : ℕ
hGpn : Nat.card G = p ^ n
hG : Nat.card G = p ^ 2
⊢ Nat.card (G ⧸ center G) ∣ p
state_after: p : ℕ
G : Type u_1
inst✝¹ : Group G
inst✝ : Fact (Nat.Prime p)
n : ℕ
hGpn : Nat.card G = p ^ n
hG : Nat.card G = p ^ 2
⊢ p * Nat.card (G ⧸ center G) ∣ Nat.card ↥(center G) * (center G).index
tactic: rw [← mul_dvd_mul_iff_left (NeZero.ne p), ← sq, ← hG, ← (center G).card_mul_index]
state_before: p : ℕ
G : Type u_1
inst✝¹ : Group G
inst✝ : Fact (Nat.Prime p)
n : ℕ
hGpn : Nat.card G = p ^ n
hG : Nat.card G = p ^ 2
⊢ p * Nat.card (G ⧸ center G) ∣ Nat.card ↥(center G) * (center G).index
state_after: case h
p : ℕ
G : Type u_1
inst✝¹ : Group G
inst✝ : Fact (Nat.Prime p)
n : ℕ
hGpn : Nat.card G = p ^ n
hG : Nat.card G = p ^ 2
⊢ p ∣ Nat.card ↥(center G)
tactic: apply mul_dvd_mul_right
state_before: case h
p : ℕ
G : Type u_1
inst✝¹ : Group G
inst✝ : Fact (Nat.Prime p)
n : ℕ
hGpn : Nat.card G = p ^ n
hG : Nat.card G = p ^ 2
⊢ p ∣ Nat.card ↥(center G)
state_after: case h.intro.intro
p : ℕ
G : Type u_1
inst✝¹ : Group G
inst✝ : Fact (Nat.Prime p)
n : ℕ
hGpn : Nat.card G = p ^ n
hG : Nat.card G = p ^ 2
k : ℕ
hk0 : k > 0
hk : Nat.card ↥(center G) = p ^ k
⊢ p ∣ Nat.card ↥(center G)
tactic: rcases card_center_eq_prime_pow hG zero_lt_two with ⟨k, hk0, hk⟩
state_before: case h.intro.intro
p : ℕ
G : Type u_1
inst✝¹ : Group G
inst✝ : Fact (Nat.Prime p)
n : ℕ
hGpn : Nat.card G = p ^ n
hG : Nat.card G = p ^ 2
k : ℕ
hk0 : k > 0
hk : Nat.card ↥(center G) = p ^ k
⊢ p ∣ Nat.card ↥(center G)
state_after: case h.intro.intro
p : ℕ
G : Type u_1
inst✝¹ : Group G
inst✝ : Fact (Nat.Prime p)
n : ℕ
hGpn : Nat.card G = p ^ n
hG : Nat.card G = p ^ 2
k : ℕ
hk0 : k > 0
hk : Nat.card ↥(center G) = p ^ k
⊢ p ∣ p ^ k
tactic: rw [hk]
state_before: case h.intro.intro
p : ℕ
G : Type u_1
inst✝¹ : Group G
inst✝ : Fact (Nat.Prime p)
n : ℕ
hGpn : Nat.card G = p ^ n
hG : Nat.card G = p ^ 2
k : ℕ
hk0 : k > 0
hk : Nat.card ↥(center G) = p ^ k
⊢ p ∣ p ^ k
state_after: no goals
tactic: exact dvd_pow_self p hk0.ne'
Theorem: Univ.isAddSubmonoid
File: Mathlib/Deprecated/Submonoid.lean

Proof steps:
state_before: M : Type u_1
inst✝¹ : Monoid M
s : Set M
A : Type u_2
inst✝ : AddMonoid A
t : Set A
⊢ IsSubmonoid Set.univ
state_after: no goals
tactic: constructor <;> simp