1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Nat.factorization_le_iff_dvd
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: constructor
state_before: a b m n✝ p d n : ℕ
hd : d ≠ 0
hn : n ≠ 0
⊢ d.factorization ≤ n.factorization ↔ d ∣ n
state_after: case mp
a b m n✝ p d n : ℕ
hd : d ≠ 0
hn : n ≠ 0
⊢ d.factorization ≤ n.factorization → d ∣ n

case mpr
a b m n✝ p d n : ℕ
hd : d ≠ 0
hn : n ≠ 0
⊢ d ∣ n → d.factorization ≤ n.factorization

tactic: intro hdn
state_before: case mp
a b m n✝ p d n : ℕ
hd : d ≠ 0
hn : n ≠ 0
⊢ d.factorization ≤ n.factorization → d ∣ n
state_after: case mp
a b m n✝ p d n : ℕ
hd : d ≠ 0
hn : n ≠ 0
hdn : d.factorization ≤ n.factorization
⊢ d ∣ n

tactic: set K := n.factorization - d.factorization with hK
state_before: case mp
a b m n✝ p d n : ℕ
hd : d ≠ 0
hn : n ≠ 0
hdn : d.factorization ≤ n.factorization
⊢ d ∣ n
state_after: case mp
a b m n✝ p d n : ℕ
hd : d ≠ 0
hn : n ≠ 0
hdn : d.factorization ≤ n.factorization
K : ℕ →₀ ℕ := n.factorization - d.factorization
hK : K = n.factorization - d.factorization
⊢ d ∣ n

tactic: rw [← factorization_prod_pow_eq_self hn, ← factorization_prod_pow_eq_self hd,
    ← Finsupp.prod_add_index' pow_zero pow_add, hK, add_tsub_cancel_of_le hdn]
state_before: case h
a b m n✝ p d n : ℕ
hd : d ≠ 0
hn : n ≠ 0
hdn : d.factorization ≤ n.factorization
K : ℕ →₀ ℕ := n.factorization - d.factorization
hK : K = n.factorization - d.factorization
⊢ n = d * K.prod fun x x_1 => x ^ x_1
state_after: no goals

tactic: rintro ⟨c, rfl⟩
state_before: case mpr
a b m n✝ p d n : ℕ
hd : d ≠ 0
hn : n ≠ 0
⊢ d ∣ n → d.factorization ≤ n.factorization
state_after: case mpr.intro
a b m n p d : ℕ
hd : d ≠ 0
c : ℕ
hn : d * c ≠ 0
⊢ d.factorization ≤ (d * c).factorization

tactic: rw [factorization_mul hd (right_ne_zero_of_mul hn)]
state_before: case mpr.intro
a b m n p d : ℕ
hd : d ≠ 0
c : ℕ
hn : d * c ≠ 0
⊢ d.factorization ≤ (d * c).factorization
state_after: case mpr.intro
a b m n p d : ℕ
hd : d ≠ 0
c : ℕ
hn : d * c ≠ 0
⊢ d.factorization ≤ d.factorization + c.factorization

tactic: simp
state_before: case mpr.intro
a b m n p d : ℕ
hd : d ≠ 0
c : ℕ
hn : d * c ≠ 0
⊢ d.factorization ≤ d.factorization + c.factorization
state_after: no goals
Theorem: Action.rightUnitor_hom_hom
File: Mathlib/RepresentationTheory/Action/Monoidal.lean

tactic: dsimp
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
X : Action V G
⊢ (ρ_ X).hom.hom = (ρ_ X.V).hom
state_after: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
X : Action V G
⊢ ((𝟙 X.V ⊗ 𝟙 (𝟙_ V)) ≫ (ρ_ X.V).hom) ≫ 𝟙 X.V = (ρ_ X.V).hom

tactic: simp
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
X : Action V G
⊢ ((𝟙 X.V ⊗ 𝟙 (𝟙_ V)) ≫ (ρ_ X.V).hom) ≫ 𝟙 X.V = (ρ_ X.V).hom
state_after: no goals
Theorem: InnerProductSpace.Core.inner_add_add_self
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: simp only [inner_add_left, inner_add_right]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝² : _root_.RCLike 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x y : F
⊢ ⟪x + y, x + y⟫_𝕜 = ⟪x, x⟫_𝕜 + ⟪x, y⟫_𝕜 + ⟪y, x⟫_𝕜 + ⟪y, y⟫_𝕜
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝² : _root_.RCLike 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x y : F
⊢ ⟪x, x⟫_𝕜 + ⟪y, x⟫_𝕜 + (⟪x, y⟫_𝕜 + ⟪y, y⟫_𝕜) = ⟪x, x⟫_𝕜 + ⟪x, y⟫_𝕜 + ⟪y, x⟫_𝕜 + ⟪y, y⟫_𝕜

tactic: ring
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝² : _root_.RCLike 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x y : F
⊢ ⟪x, x⟫_𝕜 + ⟪y, x⟫_𝕜 + (⟪x, y⟫_𝕜 + ⟪y, y⟫_𝕜) = ⟪x, x⟫_𝕜 + ⟪x, y⟫_𝕜 + ⟪y, x⟫_𝕜 + ⟪y, y⟫_𝕜
state_after: no goals
Theorem: Cardinal.le_of_dvd
File: Mathlib/SetTheory/Cardinal/Divisibility.lean

tactic: simpa only [hab, mul_one] using
  mul_le_mul_left' (one_le_iff_ne_zero.2 fun h : b = 0 => b0 (by rwa [h, mul_zero] at hab)) a
state_before: a✝ b✝ : Cardinal.{u}
n m : ℕ
a x : Cardinal.{u_1}
b0 : x ≠ 0
b : Cardinal.{u_1}
hab : x = a * b
⊢ a ≤ x
state_after: no goals

tactic: rwa [h, mul_zero] at hab
state_before: a✝ b✝ : Cardinal.{u}
n m : ℕ
a x : Cardinal.{u_1}
b0 : x ≠ 0
b : Cardinal.{u_1}
hab : x = a * b
h : b = 0
⊢ x = 0
state_after: no goals
Theorem: IsDedekindDomain.HeightOneSpectrum.int_valuation_ne_zero
File: Mathlib/RingTheory/DedekindDomain/AdicValuation.lean

tactic: rw [intValuationDef, if_neg hx]
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
x : R
hx : x ≠ 0
⊢ v.intValuationDef x ≠ 0
state_after: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
x : R
hx : x ≠ 0
⊢ ↑(ofAdd (-↑((Associates.mk v.asIdeal).count (Associates.mk (Ideal.span {x})).factors))) ≠ 0

tactic: exact WithZero.coe_ne_zero
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
x : R
hx : x ≠ 0
⊢ ↑(ofAdd (-↑((Associates.mk v.asIdeal).count (Associates.mk (Ideal.span {x})).factors))) ≠ 0
state_after: no goals
Theorem: CategoryTheory.Iso.hom_comp_eq_id
File: Mathlib/CategoryTheory/Iso.lean

tactic: rw [← eq_inv_comp, comp_id]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
α : X ≅ Y
f : Y ⟶ X
⊢ α.hom ≫ f = 𝟙 X ↔ f = α.inv
state_after: no goals
Theorem: RingCon.sup_def
File: Mathlib/RingTheory/Congruence/Basic.lean

tactic: rw [sup_eq_ringConGen]
state_before: α : Type u_1
R : Type u_2
inst✝¹ : Add R
inst✝ : Mul R
c d : RingCon R
⊢ c ⊔ d = ringConGen (⇑c ⊔ ⇑d)
state_after: α : Type u_1
R : Type u_2
inst✝¹ : Add R
inst✝ : Mul R
c d : RingCon R
⊢ (ringConGen fun x y => c x y ∨ d x y) = ringConGen (⇑c ⊔ ⇑d)

tactic: rfl
state_before: α : Type u_1
R : Type u_2
inst✝¹ : Add R
inst✝ : Mul R
c d : RingCon R
⊢ (ringConGen fun x y => c x y ∨ d x y) = ringConGen (⇑c ⊔ ⇑d)
state_after: no goals
Theorem: AlgEquiv.ofLinearEquiv_toLinearEquiv
File: Mathlib/Algebra/Algebra/Equiv.lean

tactic: ext
state_before: R : Type uR
A₁ : Type uA₁
A₂ : Type uA₂
A₃ : Type uA₃
A₁' : Type uA₁'
A₂' : Type uA₂'
A₃' : Type uA₃'
inst✝¹² : CommSemiring R
inst✝¹¹ : Semiring A₁
inst✝¹⁰ : Semiring A₂
inst✝⁹ : Semiring A₃
inst✝⁸ : Semiring A₁'
inst✝⁷ : Semiring A₂'
inst✝⁶ : Semiring A₃'
inst✝⁵ : Algebra R A₁
inst✝⁴ : Algebra R A₂
inst✝³ : Algebra R A₃
inst✝² : Algebra R A₁'
inst✝¹ : Algebra R A₂'
inst✝ : Algebra R A₃'
e : A₁ ≃ₐ[R] A₂
l : A₁ ≃ₗ[R] A₂
map_one✝ : l 1 = 1
map_mul✝ : ∀ (x y : A₁), l (x * y) = l x * l y
map_mul : e.toLinearEquiv 1 = 1
map_one : ∀ (x y : A₁), e.toLinearEquiv (x * y) = e.toLinearEquiv x * e.toLinearEquiv y
⊢ ofLinearEquiv e.toLinearEquiv map_mul map_one = e
state_after: case h
R : Type uR
A₁ : Type uA₁
A₂ : Type uA₂
A₃ : Type uA₃
A₁' : Type uA₁'
A₂' : Type uA₂'
A₃' : Type uA₃'
inst✝¹² : CommSemiring R
inst✝¹¹ : Semiring A₁
inst✝¹⁰ : Semiring A₂
inst✝⁹ : Semiring A₃
inst✝⁸ : Semiring A₁'
inst✝⁷ : Semiring A₂'
inst✝⁶ : Semiring A₃'
inst✝⁵ : Algebra R A₁
inst✝⁴ : Algebra R A₂
inst✝³ : Algebra R A₃
inst✝² : Algebra R A₁'
inst✝¹ : Algebra R A₂'
inst✝ : Algebra R A₃'
e : A₁ ≃ₐ[R] A₂
l : A₁ ≃ₗ[R] A₂
map_one✝ : l 1 = 1
map_mul✝ : ∀ (x y : A₁), l (x * y) = l x * l y
map_mul : e.toLinearEquiv 1 = 1
map_one : ∀ (x y : A₁), e.toLinearEquiv (x * y) = e.toLinearEquiv x * e.toLinearEquiv y
a✝ : A₁
⊢ (ofLinearEquiv e.toLinearEquiv map_mul map_one) a✝ = e a✝

tactic: rfl
state_before: case h
R : Type uR
A₁ : Type uA₁
A₂ : Type uA₂
A₃ : Type uA₃
A₁' : Type uA₁'
A₂' : Type uA₂'
A₃' : Type uA₃'
inst✝¹² : CommSemiring R
inst✝¹¹ : Semiring A₁
inst✝¹⁰ : Semiring A₂
inst✝⁹ : Semiring A₃
inst✝⁸ : Semiring A₁'
inst✝⁷ : Semiring A₂'
inst✝⁶ : Semiring A₃'
inst✝⁵ : Algebra R A₁
inst✝⁴ : Algebra R A₂
inst✝³ : Algebra R A₃
inst✝² : Algebra R A₁'
inst✝¹ : Algebra R A₂'
inst✝ : Algebra R A₃'
e : A₁ ≃ₐ[R] A₂
l : A₁ ≃ₗ[R] A₂
map_one✝ : l 1 = 1
map_mul✝ : ∀ (x y : A₁), l (x * y) = l x * l y
map_mul : e.toLinearEquiv 1 = 1
map_one : ∀ (x y : A₁), e.toLinearEquiv (x * y) = e.toLinearEquiv x * e.toLinearEquiv y
a✝ : A₁
⊢ (ofLinearEquiv e.toLinearEquiv map_mul map_one) a✝ = e a✝
state_after: no goals
Theorem: Filter.HasBasis.uniformEquicontinuous_iff_right
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

tactic: rw [uniformEquicontinuous_iff_uniformContinuous, UniformContinuous,
  (UniformFun.hasBasis_uniformity_of_basis ι α hα).tendsto_right_iff]
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
p : κ → Prop
s : κ → Set (α × α)
F : ι → β → α
hα : (𝓤 α).HasBasis p s
⊢ UniformEquicontinuous F ↔ ∀ (k : κ), p k → ∀ᶠ (xy : β × β) in 𝓤 β, ∀ (i : ι), (F i xy.1, F i xy.2) ∈ s k
state_after: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
p : κ → Prop
s : κ → Set (α × α)
F : ι → β → α
hα : (𝓤 α).HasBasis p s
⊢ (∀ (i : κ),
      p i →
        ∀ᶠ (x : β × β) in 𝓤 β,
          ((⇑UniformFun.ofFun ∘ swap F) x.1, (⇑UniformFun.ofFun ∘ swap F) x.2) ∈ (UniformFun.gen ι α ∘ s) i) ↔
    ∀ (k : κ), p k → ∀ᶠ (xy : β × β) in 𝓤 β, ∀ (i : ι), (F i xy.1, F i xy.2) ∈ s k

tactic: rfl
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
p : κ → Prop
s : κ → Set (α × α)
F : ι → β → α
hα : (𝓤 α).HasBasis p s
⊢ (∀ (i : κ),
      p i →
        ∀ᶠ (x : β × β) in 𝓤 β,
          ((⇑UniformFun.ofFun ∘ swap F) x.1, (⇑UniformFun.ofFun ∘ swap F) x.2) ∈ (UniformFun.gen ι α ∘ s) i) ↔
    ∀ (k : κ), p k → ∀ᶠ (xy : β × β) in 𝓤 β, ∀ (i : ι), (F i xy.1, F i xy.2) ∈ s k
state_after: no goals
Theorem: LocalizedModule.lift'_smul
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: rw [LocalizedModule.lift'_mk, LocalizedModule.smul'_mk, LocalizedModule.lift'_mk]
state_before: R : Type u_1
inst✝¹¹ : CommSemiring R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : AddCommMonoid M'
inst✝⁸ : AddCommMonoid M''
A : Type u_5
inst✝⁷ : CommSemiring A
inst✝⁶ : Algebra R A
inst✝⁵ : Module A M'
inst✝⁴ : IsLocalization S A
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
inst✝ : IsScalarTower R A M'
f : M →ₗ[R] M'
g✝ g : M →ₗ[R] M''
h : ∀ (x : ↥S), IsUnit ((algebraMap R (Module.End R M'')) ↑x)
r : R
m : LocalizedModule S M
a : M
b : ↥S
⊢ r • lift' S g h (mk a b) = lift' S g h (r • mk a b)
state_after: R : Type u_1
inst✝¹¹ : CommSemiring R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : AddCommMonoid M'
inst✝⁸ : AddCommMonoid M''
A : Type u_5
inst✝⁷ : CommSemiring A
inst✝⁶ : Algebra R A
inst✝⁵ : Module A M'
inst✝⁴ : IsLocalization S A
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
inst✝ : IsScalarTower R A M'
f : M →ₗ[R] M'
g✝ g : M →ₗ[R] M''
h : ∀ (x : ↥S), IsUnit ((algebraMap R (Module.End R M'')) ↑x)
r : R
m : LocalizedModule S M
a : M
b : ↥S
⊢ r • ↑⋯.unit⁻¹ (g a) = ↑⋯.unit⁻¹ (g (r • a))

tactic: rw [← map_smul, ← g.map_smul]
state_before: R : Type u_1
inst✝¹¹ : CommSemiring R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : AddCommMonoid M'
inst✝⁸ : AddCommMonoid M''
A : Type u_5
inst✝⁷ : CommSemiring A
inst✝⁶ : Algebra R A
inst✝⁵ : Module A M'
inst✝⁴ : IsLocalization S A
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
inst✝ : IsScalarTower R A M'
f : M →ₗ[R] M'
g✝ g : M →ₗ[R] M''
h : ∀ (x : ↥S), IsUnit ((algebraMap R (Module.End R M'')) ↑x)
r : R
m : LocalizedModule S M
a : M
b : ↥S
⊢ r • ↑⋯.unit⁻¹ (g a) = ↑⋯.unit⁻¹ (g (r • a))
state_after: no goals
Theorem: kstar_eq_self
File: Mathlib/Algebra/Order/Kleene.lean

tactic: rw [← h, kstar_mul_kstar]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
π : ι → Type u_4
inst✝ : KleeneAlgebra α
a b c : α
h : a∗ = a
⊢ a * a = a
state_after: no goals
Theorem: Nat.factorization_prime_le_iff_dvd
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: rw [← factorization_le_iff_dvd hd hn]
state_before: a b m n✝ p d n : ℕ
hd : d ≠ 0
hn : n ≠ 0
⊢ (∀ (p : ℕ), Prime p → d.factorization p ≤ n.factorization p) ↔ d ∣ n
state_after: a b m n✝ p d n : ℕ
hd : d ≠ 0
hn : n ≠ 0
⊢ (∀ (p : ℕ), Prime p → d.factorization p ≤ n.factorization p) ↔ d.factorization ≤ n.factorization

tactic: refine ⟨fun h p => (em p.Prime).elim (h p) fun hp => ?_, fun h p _ => h p⟩
state_before: a b m n✝ p d n : ℕ
hd : d ≠ 0
hn : n ≠ 0
⊢ (∀ (p : ℕ), Prime p → d.factorization p ≤ n.factorization p) ↔ d.factorization ≤ n.factorization
state_after: a b m n✝ p✝ d n : ℕ
hd : d ≠ 0
hn : n ≠ 0
h : ∀ (p : ℕ), Prime p → d.factorization p ≤ n.factorization p
p : ℕ
hp : ¬Prime p
⊢ d.factorization p ≤ n.factorization p

tactic: simp_rw [factorization_eq_zero_of_non_prime _ hp]
state_before: a b m n✝ p✝ d n : ℕ
hd : d ≠ 0
hn : n ≠ 0
h : ∀ (p : ℕ), Prime p → d.factorization p ≤ n.factorization p
p : ℕ
hp : ¬Prime p
⊢ d.factorization p ≤ n.factorization p
state_after: a b m n✝ p✝ d n : ℕ
hd : d ≠ 0
hn : n ≠ 0
h : ∀ (p : ℕ), Prime p → d.factorization p ≤ n.factorization p
p : ℕ
hp : ¬Prime p
⊢ 0 ≤ 0

tactic: rfl
state_before: a b m n✝ p✝ d n : ℕ
hd : d ≠ 0
hn : n ≠ 0
h : ∀ (p : ℕ), Prime p → d.factorization p ≤ n.factorization p
p : ℕ
hp : ¬Prime p
⊢ 0 ≤ 0
state_after: no goals
Theorem: ConvexOn.slope_le_of_hasDerivWithinAt_Iio
File: Mathlib/Analysis/Convex/Deriv.lean

tactic: apply ge_of_tendsto <| (hasDerivWithinAt_iff_tendsto_slope' not_mem_Iio_self).mp hf'
state_before: S : Set ℝ
f : ℝ → ℝ
x y f' : ℝ
hfc : ConvexOn ℝ S f
hx : x ∈ S
hy : y ∈ S
hxy : x < y
hf' : HasDerivWithinAt f f' (Iio y) y
⊢ slope f x y ≤ f'
state_after: S : Set ℝ
f : ℝ → ℝ
x y f' : ℝ
hfc : ConvexOn ℝ S f
hx : x ∈ S
hy : y ∈ S
hxy : x < y
hf' : HasDerivWithinAt f f' (Iio y) y
⊢ ∀ᶠ (c : ℝ) in 𝓝[<] y, slope f x y ≤ slope f y c

tactic: simp_rw [eventually_nhdsWithin_iff, slope_comm f x y, slope_def_field]
state_before: S : Set ℝ
f : ℝ → ℝ
x y f' : ℝ
hfc : ConvexOn ℝ S f
hx : x ∈ S
hy : y ∈ S
hxy : x < y
hf' : HasDerivWithinAt f f' (Iio y) y
⊢ ∀ᶠ (c : ℝ) in 𝓝[<] y, slope f x y ≤ slope f y c
state_after: S : Set ℝ
f : ℝ → ℝ
x y f' : ℝ
hfc : ConvexOn ℝ S f
hx : x ∈ S
hy : y ∈ S
hxy : x < y
hf' : HasDerivWithinAt f f' (Iio y) y
⊢ ∀ᶠ (x_1 : ℝ) in 𝓝 y, x_1 ∈ Iio y → (f x - f y) / (x - y) ≤ (f x_1 - f y) / (x_1 - y)

tactic: filter_upwards [eventually_gt_nhds hxy] with t ht (ht' : t < y)
state_before: S : Set ℝ
f : ℝ → ℝ
x y f' : ℝ
hfc : ConvexOn ℝ S f
hx : x ∈ S
hy : y ∈ S
hxy : x < y
hf' : HasDerivWithinAt f f' (Iio y) y
⊢ ∀ᶠ (x_1 : ℝ) in 𝓝 y, x_1 ∈ Iio y → (f x - f y) / (x - y) ≤ (f x_1 - f y) / (x_1 - y)
state_after: case h
S : Set ℝ
f : ℝ → ℝ
x y f' : ℝ
hfc : ConvexOn ℝ S f
hx : x ∈ S
hy : y ∈ S
hxy : x < y
hf' : HasDerivWithinAt f f' (Iio y) y
t : ℝ
ht : x < t
ht' : t < y
⊢ (f x - f y) / (x - y) ≤ (f t - f y) / (t - y)

tactic: refine hfc.secant_mono hy hx (?_ : t ∈ S) hxy.ne ht'.ne ht.le
state_before: case h
S : Set ℝ
f : ℝ → ℝ
x y f' : ℝ
hfc : ConvexOn ℝ S f
hx : x ∈ S
hy : y ∈ S
hxy : x < y
hf' : HasDerivWithinAt f f' (Iio y) y
t : ℝ
ht : x < t
ht' : t < y
⊢ (f x - f y) / (x - y) ≤ (f t - f y) / (t - y)
state_after: case h
S : Set ℝ
f : ℝ → ℝ
x y f' : ℝ
hfc : ConvexOn ℝ S f
hx : x ∈ S
hy : y ∈ S
hxy : x < y
hf' : HasDerivWithinAt f f' (Iio y) y
t : ℝ
ht : x < t
ht' : t < y
⊢ t ∈ S

tactic: exact hfc.1.ordConnected.out hx hy ⟨ht.le, ht'.le⟩
state_before: case h
S : Set ℝ
f : ℝ → ℝ
x y f' : ℝ
hfc : ConvexOn ℝ S f
hx : x ∈ S
hy : y ∈ S
hxy : x < y
hf' : HasDerivWithinAt f f' (Iio y) y
t : ℝ
ht : x < t
ht' : t < y
⊢ t ∈ S
state_after: no goals
Theorem: Set.sized_singleton
File: Mathlib/Data/Finset/Slice.lean

tactic: simp [Sized]
state_before: α : Type u_1
ι : Sort u_2
κ : ι → Sort u_3
A B : Set (Finset α)
s : Finset α
r : ℕ
⊢ Sized r {s} ↔ s.card = r
state_after: no goals
Theorem: Metric.continuousAt_iff
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

tactic: rw [ContinuousAt, tendsto_nhds_nhds]
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
inst✝ : PseudoMetricSpace β
f : α → β
a : α
⊢ ContinuousAt f a ↔ ∀ ε > 0, ∃ δ > 0, ∀ {x : α}, dist x a < δ → dist (f x) (f a) < ε
state_after: no goals
Theorem: Submodule.rank_sup_add_rank_inf_eq
File: Mathlib/LinearAlgebra/Dimension/RankNullity.lean

tactic: conv_rhs => enter [2]; rw [show t = (s ⊔ t) ⊓ t by simp]
state_before: R : Type u_1
M M₁ M₂ M₃ : Type u
M' : Type v
inst✝¹¹ : Ring R
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : AddCommGroup M₁
inst✝⁸ : AddCommGroup M₂
inst✝⁷ : AddCommGroup M₃
inst✝⁶ : AddCommGroup M'
inst✝⁵ : Module R M
inst✝⁴ : Module R M₁
inst✝³ : Module R M₂
inst✝² : Module R M₃
inst✝¹ : Module R M'
inst✝ : HasRankNullity.{u, u_1} R
s t : Submodule R M
⊢ Module.rank R ↥(s ⊔ t) + Module.rank R ↥(s ⊓ t) = Module.rank R ↥s + Module.rank R ↥t
state_after: R : Type u_1
M M₁ M₂ M₃ : Type u
M' : Type v
inst✝¹¹ : Ring R
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : AddCommGroup M₁
inst✝⁸ : AddCommGroup M₂
inst✝⁷ : AddCommGroup M₃
inst✝⁶ : AddCommGroup M'
inst✝⁵ : Module R M
inst✝⁴ : Module R M₁
inst✝³ : Module R M₂
inst✝² : Module R M₃
inst✝¹ : Module R M'
inst✝ : HasRankNullity.{u, u_1} R
s t : Submodule R M
⊢ Module.rank R ↥(s ⊔ t) + Module.rank R ↥(s ⊓ t) = Module.rank R ↥s + Module.rank R ↥((s ⊔ t) ⊓ t)

tactic: rw [← rank_quotient_add_rank ((s ⊓ t).comap s.subtype),
  ← rank_quotient_add_rank (t.comap (s ⊔ t).subtype),
  (quotientInfEquivSupQuotient s t).rank_eq,
  (equivSubtypeMap s (comap _ (s ⊓ t))).rank_eq, Submodule.map_comap_subtype,
  (equivSubtypeMap (s ⊔ t) (comap _ t)).rank_eq, Submodule.map_comap_subtype,
  ← inf_assoc, inf_idem, add_right_comm]
state_before: R : Type u_1
M M₁ M₂ M₃ : Type u
M' : Type v
inst✝¹¹ : Ring R
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : AddCommGroup M₁
inst✝⁸ : AddCommGroup M₂
inst✝⁷ : AddCommGroup M₃
inst✝⁶ : AddCommGroup M'
inst✝⁵ : Module R M
inst✝⁴ : Module R M₁
inst✝³ : Module R M₂
inst✝² : Module R M₃
inst✝¹ : Module R M'
inst✝ : HasRankNullity.{u, u_1} R
s t : Submodule R M
⊢ Module.rank R ↥(s ⊔ t) + Module.rank R ↥(s ⊓ t) = Module.rank R ↥s + Module.rank R ↥((s ⊔ t) ⊓ t)
state_after: no goals

tactic: simp
state_before: R : Type u_1
M M₁ M₂ M₃ : Type u
M' : Type v
inst✝¹¹ : Ring R
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : AddCommGroup M₁
inst✝⁸ : AddCommGroup M₂
inst✝⁷ : AddCommGroup M₃
inst✝⁶ : AddCommGroup M'
inst✝⁵ : Module R M
inst✝⁴ : Module R M₁
inst✝³ : Module R M₂
inst✝² : Module R M₃
inst✝¹ : Module R M'
inst✝ : HasRankNullity.{u, u_1} R
s t : Submodule R M
⊢ t = (s ⊔ t) ⊓ t
state_after: no goals
Theorem: CliffordAlgebra.contractLeft_contractLeft
File: Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean

tactic: induction' x using CliffordAlgebra.left_induction with r x y hx hy m x hx
state_before: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
x : CliffordAlgebra Q
⊢ (contractLeft d) ((contractLeft d) x) = 0
state_after: case algebraMap
R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
r : R
⊢ (contractLeft d) ((contractLeft d) ((algebraMap R (CliffordAlgebra Q)) r)) = 0

case add
R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
x y : CliffordAlgebra Q
hx : (contractLeft d) ((contractLeft d) x) = 0
hy : (contractLeft d) ((contractLeft d) y) = 0
⊢ (contractLeft d) ((contractLeft d) (x + y)) = 0

case ι_mul
R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
m : CliffordAlgebra Q
x : M
hx : (contractLeft d) ((contractLeft d) m) = 0
⊢ (contractLeft d) ((contractLeft d) ((ι Q) x * m)) = 0

tactic: simp_rw [contractLeft_algebraMap, map_zero]
state_before: case algebraMap
R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
r : R
⊢ (contractLeft d) ((contractLeft d) ((algebraMap R (CliffordAlgebra Q)) r)) = 0
state_after: no goals

tactic: rw [map_add, map_add, hx, hy, add_zero]
state_before: case add
R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
x y : CliffordAlgebra Q
hx : (contractLeft d) ((contractLeft d) x) = 0
hy : (contractLeft d) ((contractLeft d) y) = 0
⊢ (contractLeft d) ((contractLeft d) (x + y)) = 0
state_after: no goals

tactic: rw [contractLeft_ι_mul, map_sub, contractLeft_ι_mul, hx, LinearMap.map_smul,
  mul_zero, sub_zero, sub_self]
state_before: case ι_mul
R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
m : CliffordAlgebra Q
x : M
hx : (contractLeft d) ((contractLeft d) m) = 0
⊢ (contractLeft d) ((contractLeft d) ((ι Q) x * m)) = 0
state_after: no goals
Theorem: Set.antitoneOn_iff_antitone
File: Mathlib/Data/Set/Basic.lean

tactic: simp [Antitone, AntitoneOn]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
⊢ AntitoneOn f s ↔ Antitone fun a => f ↑a
state_after: no goals
Theorem: Set.preimage_const_mul_Iic_of_neg
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simpa only [mul_comm] using preimage_mul_const_Iic_of_neg a h
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a c : α
h : c < 0
⊢ (fun x => c * x) ⁻¹' Iic a = Ici (a / c)
state_after: no goals
Theorem: ENNReal.le_toReal_sub
File: Mathlib/Data/ENNReal/Real.lean

tactic: lift b to ℝ≥0 using hb
state_before: a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a b : ℝ≥0∞
hb : b ≠ ⊤
⊢ a.toReal - b.toReal ≤ (a - b).toReal
state_after: case intro
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
b : ℝ≥0
⊢ a.toReal - (↑b).toReal ≤ (a - ↑b).toReal

tactic: induction a
state_before: case intro
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
b : ℝ≥0
⊢ a.toReal - (↑b).toReal ≤ (a - ↑b).toReal
state_after: case intro.top
a b✝ c d : ℝ≥0∞
r p q b : ℝ≥0
⊢ ⊤.toReal - (↑b).toReal ≤ (⊤ - ↑b).toReal

case intro.coe
a b✝ c d : ℝ≥0∞
r p q b x✝ : ℝ≥0
⊢ (↑x✝).toReal - (↑b).toReal ≤ (↑x✝ - ↑b).toReal

tactic: simp
state_before: case intro.top
a b✝ c d : ℝ≥0∞
r p q b : ℝ≥0
⊢ ⊤.toReal - (↑b).toReal ≤ (⊤ - ↑b).toReal
state_after: no goals

tactic: simp only [← coe_sub, NNReal.sub_def, Real.coe_toNNReal', coe_toReal]
state_before: case intro.coe
a b✝ c d : ℝ≥0∞
r p q b x✝ : ℝ≥0
⊢ (↑x✝).toReal - (↑b).toReal ≤ (↑x✝ - ↑b).toReal
state_after: case intro.coe
a b✝ c d : ℝ≥0∞
r p q b x✝ : ℝ≥0
⊢ ↑x✝ - ↑b ≤ max (↑x✝ - ↑b) 0

tactic: exact le_max_left _ _
state_before: case intro.coe
a b✝ c d : ℝ≥0∞
r p q b x✝ : ℝ≥0
⊢ ↑x✝ - ↑b ≤ max (↑x✝ - ↑b) 0
state_after: no goals
Theorem: Fin.sort_univ
File: Mathlib/Data/Finset/Sort.lean

tactic: simp
state_before: n : ℕ
⊢ (Finset.sort (fun x y => x ≤ y) Finset.univ).toFinset = (List.finRange n).toFinset
state_after: no goals
Theorem: MeasureTheory.Measure.pi_ball
File: Mathlib/MeasureTheory/Constructions/Pi.lean

tactic: rw [ball_pi _ hr, pi_pi]
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝³ : Fintype ι
m : (i : ι) → OuterMeasure (α i)
inst✝² : (i : ι) → MeasurableSpace (α i)
μ : (i : ι) → Measure (α i)
inst✝¹ : ∀ (i : ι), SigmaFinite (μ i)
inst✝ : (i : ι) → MetricSpace (α i)
x : (i : ι) → α i
r : ℝ
hr : 0 < r
⊢ (Measure.pi μ) (Metric.ball x r) = ∏ i : ι, (μ i) (Metric.ball (x i) r)
state_after: no goals