ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: LocallyLipschitzOn.mono
File: Mathlib/Topology/EMetricSpace/Lipschitz.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
K : ℝ≥0
s t : Set α
f : α → β
hf : LocallyLipschitzOn t f
h : s ⊆ t
x : α
hx : x ∈ s
⊢ ∃ K, ∃ t ∈ 𝓝[s] x, LipschitzOnWith K f t
state_after: case intro.intro.intro
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
K✝ : ℝ≥0
s t : Set α
f : α → β
hf : LocallyLipschitzOn t f
h : s ⊆ t
x : α
hx : x ∈ s
K : ℝ≥0
u : Set α
hu : u ∈ 𝓝[t] x
hfu : LipschitzOnWith K f u
⊢ ∃ K, ∃ t ∈ 𝓝[s] x, LipschitzOnWith K f t
tactic: obtain ⟨K, u, hu, hfu⟩ := hf (h hx)
state_before: case intro.intro.intro
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
K✝ : ℝ≥0
s t : Set α
f : α → β
hf : LocallyLipschitzOn t f
h : s ⊆ t
x : α
hx : x ∈ s
K : ℝ≥0
u : Set α
hu : u ∈ 𝓝[t] x
hfu : LipschitzOnWith K f u
⊢ ∃ K, ∃ t ∈ 𝓝[s] x, LipschitzOnWith K f t
state_after: no goals
tactic: exact ⟨K, u, nhdsWithin_mono _ h hu, hfu⟩
Theorem: CategoryTheory.Functor.Full.of_iso
File: Mathlib/CategoryTheory/Functor/FullyFaithful.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F F' : C ⥤ D
G : D ⥤ E
inst✝ : F.Full
α : F ≅ F'
X Y : C
f : F'.obj X ⟶ F'.obj Y
⊢ F'.map (F.preimage ((α.app X).hom ≫ f ≫ (α.app Y).inv)) = f
state_after: no goals
tactic: simp [← NatIso.naturality_1 α]
Theorem: PMF.binomial_one_eq_bernoulli
File: Mathlib/Probability/ProbabilityMassFunction/Binomial.lean

Proof steps:
state_before: p : ℝ≥0∞
h : p ≤ 1
⊢ binomial p h 1 = map (fun x => bif x then 1 else 0) (bernoulli p h)
state_after: case h
p : ℝ≥0∞
h : p ≤ 1
i : Fin (1 + 1)
⊢ (binomial p h 1) i = (map (fun x => bif x then 1 else 0) (bernoulli p h)) i
tactic: ext i
state_before: case h
p : ℝ≥0∞
h : p ≤ 1
i : Fin (1 + 1)
⊢ (binomial p h 1) i = (map (fun x => bif x then 1 else 0) (bernoulli p h)) i
state_after: no goals
tactic: fin_cases i <;> simp [tsum_bool, binomial_apply]
Theorem: NumberField.mixedEmbedding.exists_ne_zero_mem_ringOfIntegers_of_norm_le
File: Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
I✝ : (FractionalIdeal (𝓞 K)⁰ K)ˣ
f : InfinitePlace K → ℝ≥0
I : (FractionalIdeal (𝓞 K)⁰ K)ˣ
B : ℝ
h : minkowskiBound K 1 ≤ volume (convexBodySum K B)
⊢ ∃ a, a ≠ 0 ∧ ↑|(Algebra.norm ℚ) ↑a| ≤ (B / ↑(finrank ℚ K)) ^ finrank ℚ K
state_after: case intro.intro.intro
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
I✝ : (FractionalIdeal (𝓞 K)⁰ K)ˣ
f : InfinitePlace K → ℝ≥0
I : (FractionalIdeal (𝓞 K)⁰ K)ˣ
B : ℝ
h : minkowskiBound K 1 ≤ volume (convexBodySum K B)
w✝ : K
h_mem : w✝ ∈ ↑1
h_nz : w✝ ≠ 0
h_bd : ↑|(Algebra.norm ℚ) w✝| ≤ (B / ↑(finrank ℚ K)) ^ finrank ℚ K
⊢ ∃ a, a ≠ 0 ∧ ↑|(Algebra.norm ℚ) ↑a| ≤ (B / ↑(finrank ℚ K)) ^ finrank ℚ K
tactic: obtain ⟨_, h_mem, h_nz, h_bd⟩ := exists_ne_zero_mem_ideal_of_norm_le K ↑1 h
state_before: case intro.intro.intro
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
I✝ : (FractionalIdeal (𝓞 K)⁰ K)ˣ
f : InfinitePlace K → ℝ≥0
I : (FractionalIdeal (𝓞 K)⁰ K)ˣ
B : ℝ
h : minkowskiBound K 1 ≤ volume (convexBodySum K B)
w✝ : K
h_mem : w✝ ∈ ↑1
h_nz : w✝ ≠ 0
h_bd : ↑|(Algebra.norm ℚ) w✝| ≤ (B / ↑(finrank ℚ K)) ^ finrank ℚ K
⊢ ∃ a, a ≠ 0 ∧ ↑|(Algebra.norm ℚ) ↑a| ≤ (B / ↑(finrank ℚ K)) ^ finrank ℚ K
state_after: case intro.intro.intro.intro
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
I✝ : (FractionalIdeal (𝓞 K)⁰ K)ˣ
f : InfinitePlace K → ℝ≥0
I : (FractionalIdeal (𝓞 K)⁰ K)ˣ
B : ℝ
h : minkowskiBound K 1 ≤ volume (convexBodySum K B)
a : 𝓞 K
h_mem : (algebraMap (𝓞 K) K) a ∈ ↑1
h_nz : (algebraMap (𝓞 K) K) a ≠ 0
h_bd : ↑|(Algebra.norm ℚ) ((algebraMap (𝓞 K) K) a)| ≤ (B / ↑(finrank ℚ K)) ^ finrank ℚ K
⊢ ∃ a, a ≠ 0 ∧ ↑|(Algebra.norm ℚ) ↑a| ≤ (B / ↑(finrank ℚ K)) ^ finrank ℚ K
tactic: obtain ⟨a, rfl⟩ := (FractionalIdeal.mem_one_iff _).mp h_mem
state_before: case intro.intro.intro.intro
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
I✝ : (FractionalIdeal (𝓞 K)⁰ K)ˣ
f : InfinitePlace K → ℝ≥0
I : (FractionalIdeal (𝓞 K)⁰ K)ˣ
B : ℝ
h : minkowskiBound K 1 ≤ volume (convexBodySum K B)
a : 𝓞 K
h_mem : (algebraMap (𝓞 K) K) a ∈ ↑1
h_nz : (algebraMap (𝓞 K) K) a ≠ 0
h_bd : ↑|(Algebra.norm ℚ) ((algebraMap (𝓞 K) K) a)| ≤ (B / ↑(finrank ℚ K)) ^ finrank ℚ K
⊢ ∃ a, a ≠ 0 ∧ ↑|(Algebra.norm ℚ) ↑a| ≤ (B / ↑(finrank ℚ K)) ^ finrank ℚ K
state_after: no goals
tactic: exact ⟨a, RingOfIntegers.coe_ne_zero_iff.mp h_nz, h_bd⟩
Theorem: WithBot.add_bot
File: Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : Add α
a✝ b c d : WithBot α
x y : α
a : WithBot α
⊢ a + ⊥ = ⊥
state_after: no goals
tactic: cases a <;> rfl
Theorem: Representation.smul_ofModule_asModule
File: Mathlib/RepresentationTheory/Basic.lean

Proof steps:
state_before: k : Type u_1
G : Type u_2
V : Type u_3
inst✝⁵ : CommSemiring k
inst✝⁴ : Monoid G
inst✝³ : AddCommMonoid V
inst✝² : Module k V
ρ : Representation k G V
M : Type u_4
inst✝¹ : AddCommMonoid M
inst✝ : Module (MonoidAlgebra k G) M
r : MonoidAlgebra k G
m : (ofModule M).asModule
⊢ (RestrictScalars.addEquiv k (MonoidAlgebra k G) M) ((ofModule M).asModuleEquiv (r • m)) =
    r • (RestrictScalars.addEquiv k (MonoidAlgebra k G) M) ((ofModule M).asModuleEquiv m)
state_after: k : Type u_1
G : Type u_2
V : Type u_3
inst✝⁵ : CommSemiring k
inst✝⁴ : Monoid G
inst✝³ : AddCommMonoid V
inst✝² : Module k V
ρ : Representation k G V
M : Type u_4
inst✝¹ : AddCommMonoid M
inst✝ : Module (MonoidAlgebra k G) M
r : MonoidAlgebra k G
m : (ofModule M).asModule
⊢ (RestrictScalars.addEquiv k (MonoidAlgebra k G) M) (((ofModule M).asAlgebraHom r) ((ofModule M).asModuleEquiv m)) =
    r • (RestrictScalars.addEquiv k (MonoidAlgebra k G) M) ((ofModule M).asModuleEquiv m)
tactic: dsimp
state_before: k : Type u_1
G : Type u_2
V : Type u_3
inst✝⁵ : CommSemiring k
inst✝⁴ : Monoid G
inst✝³ : AddCommMonoid V
inst✝² : Module k V
ρ : Representation k G V
M : Type u_4
inst✝¹ : AddCommMonoid M
inst✝ : Module (MonoidAlgebra k G) M
r : MonoidAlgebra k G
m : (ofModule M).asModule
⊢ (RestrictScalars.addEquiv k (MonoidAlgebra k G) M) (((ofModule M).asAlgebraHom r) ((ofModule M).asModuleEquiv m)) =
    r • (RestrictScalars.addEquiv k (MonoidAlgebra k G) M) ((ofModule M).asModuleEquiv m)
state_after: no goals
tactic: simp only [AddEquiv.apply_symm_apply, ofModule_asAlgebraHom_apply_apply]
Theorem: LinearMap.toMatrixAlgEquiv'_apply
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommSemiring R
k : Type u_2
l : Type u_3
m : Type u_4
n : Type u_5
inst✝¹ : DecidableEq n
inst✝ : Fintype n
f : (n → R) →ₗ[R] n → R
i j : n
⊢ toMatrixAlgEquiv' f i j = f (fun j' => if j' = j then 1 else 0) i
state_after: no goals
tactic: simp [LinearMap.toMatrixAlgEquiv']
Theorem: CategoryTheory.Idempotents.FunctorExtension₁.obj_obj_p
File: Mathlib/CategoryTheory/Idempotents/FunctorExtension.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{?u.1617, u_1} C
inst✝¹ : Category.{?u.1621, u_2} D
inst✝ : Category.{?u.1625, u_3} E
F : C ⥤ Karoubi D
P : Karoubi C
⊢ (F.map P.p).f ≫ (F.map P.p).f = (F.map P.p).f
state_after: no goals
tactic: simpa only [F.map_comp, hom_ext_iff] using F.congr_map P.idem
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{?u.1617, u_1} C
inst✝¹ : Category.{?u.1621, u_2} D
inst✝ : Category.{?u.1625, u_3} E
F : C ⥤ Karoubi D
X✝ Y✝ : Karoubi C
f : X✝ ⟶ Y✝
⊢ (F.map f.f).f =
    ((fun P => { X := (F.obj P.X).X, p := (F.map P.p).f, idem := ⋯ }) X✝).p ≫
      (F.map f.f).f ≫ ((fun P => { X := (F.obj P.X).X, p := (F.map P.p).f, idem := ⋯ }) Y✝).p
state_after: no goals
tactic: simpa only [F.map_comp, hom_ext_iff] using F.congr_map f.comm
Theorem: Order.Ideal.IsPrime.mem_or_mem
File: Mathlib/Order/PrimeIdeal.lean

Proof steps:
state_before: P : Type u_1
inst✝ : SemilatticeInf P
x✝ y✝ : P
I : Ideal P
hI : I.IsPrime
x y : P
⊢ x ⊓ y ∈ I → x ∈ I ∨ y ∈ I
state_after: P : Type u_1
inst✝ : SemilatticeInf P
x✝ y✝ : P
I : Ideal P
hI : I.IsPrime
x y : P
⊢ x ∉ I ∧ y ∉ I → x ⊓ y ∉ I
tactic: contrapose!
state_before: P : Type u_1
inst✝ : SemilatticeInf P
x✝ y✝ : P
I : Ideal P
hI : I.IsPrime
x y : P
⊢ x ∉ I ∧ y ∉ I → x ⊓ y ∉ I
state_after: P : Type u_1
inst✝ : SemilatticeInf P
x✝ y✝ : P
I : Ideal P
hI : I.IsPrime
x y : P
F : PFilter P := ⋯.toPFilter
⊢ x ∉ I ∧ y ∉ I → x ⊓ y ∉ I
tactic: let F := hI.compl_filter.toPFilter
state_before: P : Type u_1
inst✝ : SemilatticeInf P
x✝ y✝ : P
I : Ideal P
hI : I.IsPrime
x y : P
F : PFilter P := ⋯.toPFilter
⊢ x ∉ I ∧ y ∉ I → x ⊓ y ∉ I
state_after: P : Type u_1
inst✝ : SemilatticeInf P
x✝ y✝ : P
I : Ideal P
hI : I.IsPrime
x y : P
F : PFilter P := ⋯.toPFilter
⊢ x ∈ F ∧ y ∈ F → x ⊓ y ∈ F
tactic: show x ∈ F ∧ y ∈ F → x ⊓ y ∈ F
state_before: P : Type u_1
inst✝ : SemilatticeInf P
x✝ y✝ : P
I : Ideal P
hI : I.IsPrime
x y : P
F : PFilter P := ⋯.toPFilter
⊢ x ∈ F ∧ y ∈ F → x ⊓ y ∈ F
state_after: no goals
tactic: exact fun h => inf_mem h.1 h.2
Theorem: Representation.dualTensorHom_comm
File: Mathlib/RepresentationTheory/Basic.lean

Proof steps:
state_before: k : Type u_1
G : Type u_2
V : Type u_3
W : Type u_4
inst✝⁵ : CommSemiring k
inst✝⁴ : Group G
inst✝³ : AddCommMonoid V
inst✝² : Module k V
inst✝¹ : AddCommMonoid W
inst✝ : Module k W
ρV : Representation k G V
ρW : Representation k G W
g : G
⊢ dualTensorHom k V W ∘ₗ TensorProduct.map (ρV.dual g) (ρW g) = (ρV.linHom ρW) g ∘ₗ dualTensorHom k V W
state_after: case a.h.h.h
k : Type u_1
G : Type u_2
V : Type u_3
W : Type u_4
inst✝⁵ : CommSemiring k
inst✝⁴ : Group G
inst✝³ : AddCommMonoid V
inst✝² : Module k V
inst✝¹ : AddCommMonoid W
inst✝ : Module k W
ρV : Representation k G V
ρW : Representation k G W
g : G
x✝² : Module.Dual k V
x✝¹ : W
x✝ : V
⊢ (((TensorProduct.AlgebraTensorModule.curry (dualTensorHom k V W ∘ₗ TensorProduct.map (ρV.dual g) (ρW g))) x✝²) x✝¹)
      x✝ =
    (((TensorProduct.AlgebraTensorModule.curry ((ρV.linHom ρW) g ∘ₗ dualTensorHom k V W)) x✝²) x✝¹) x✝
tactic: ext
state_before: case a.h.h.h
k : Type u_1
G : Type u_2
V : Type u_3
W : Type u_4
inst✝⁵ : CommSemiring k
inst✝⁴ : Group G
inst✝³ : AddCommMonoid V
inst✝² : Module k V
inst✝¹ : AddCommMonoid W
inst✝ : Module k W
ρV : Representation k G V
ρW : Representation k G W
g : G
x✝² : Module.Dual k V
x✝¹ : W
x✝ : V
⊢ (((TensorProduct.AlgebraTensorModule.curry (dualTensorHom k V W ∘ₗ TensorProduct.map (ρV.dual g) (ρW g))) x✝²) x✝¹)
      x✝ =
    (((TensorProduct.AlgebraTensorModule.curry ((ρV.linHom ρW) g ∘ₗ dualTensorHom k V W)) x✝²) x✝¹) x✝
state_after: no goals
tactic: simp [Module.Dual.transpose_apply]
Theorem: toIcoMod_zero_one
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
p : α
hp : 0 < p
b : α
⊢ toIcoMod ⋯ 0 b = Int.fract b
state_after: no goals
tactic: simp [toIcoMod_eq_add_fract_mul]
Theorem: midpoint_eq_midpoint_iff_vsub_eq_vsub
File: Mathlib/LinearAlgebra/AffineSpace/Midpoint.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✝⁷ : Ring R
inst✝⁶ : Invertible 2
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x✝ y✝ z x x' y y' : P
⊢ midpoint R x y = midpoint R x' y' ↔ x -ᵥ x' = y' -ᵥ y
state_after: no goals
tactic: rw [← @vsub_eq_zero_iff_eq V, midpoint_vsub_midpoint, midpoint_eq_iff, pointReflection_apply,
    vsub_eq_sub, zero_sub, vadd_eq_add, add_zero, neg_eq_iff_eq_neg, neg_vsub_eq_vsub_rev]
Theorem: symmDiff_eq_top
File: Mathlib/Order/SymmDiff.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : BooleanAlgebra α
a b c d : α
⊢ a ∆ b = ⊤ ↔ IsCompl a b
state_after: no goals
tactic: rw [symmDiff_eq', ← compl_inf, inf_eq_top_iff, compl_eq_top, isCompl_iff, disjoint_iff,
    codisjoint_iff, and_comm]
Theorem: QuaternionAlgebra.Basis.self_i
File: Mathlib/Algebra/QuaternionBasis.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
c₁ c₂ : R
⊢ { re := 0, imI := 1, imJ := 0, imK := 0 } * { re := 0, imI := 1, imJ := 0, imK := 0 } = c₁ • 1
state_after: no goals
tactic: ext <;> simp
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
c₁ c₂ : R
⊢ { re := 0, imI := 0, imJ := 1, imK := 0 } * { re := 0, imI := 0, imJ := 1, imK := 0 } = c₂ • 1
state_after: no goals
tactic: ext <;> simp
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
c₁ c₂ : R
⊢ { re := 0, imI := 1, imJ := 0, imK := 0 } * { re := 0, imI := 0, imJ := 1, imK := 0 } =
    { re := 0, imI := 0, imJ := 0, imK := 1 }
state_after: no goals
tactic: ext <;> simp
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
c₁ c₂ : R
⊢ { re := 0, imI := 0, imJ := 1, imK := 0 } * { re := 0, imI := 1, imJ := 0, imK := 0 } =
    -{ re := 0, imI := 0, imJ := 0, imK := 1 }
state_after: no goals
tactic: ext <;> simp
Theorem: SimpleGraph.Walk.nil_iff_support_eq
File: Mathlib/Combinatorics/SimpleGraph/Walk.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
p : G.Walk v w
⊢ p.Nil ↔ p.support = [v]
state_after: no goals
tactic: cases p <;> simp
Theorem: Subgroup.Normal.mem_comm
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
nH : H.Normal
a b : G
h : a * b ∈ H
⊢ b * a ∈ H
state_after: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
nH : H.Normal
a b : G
h : a * b ∈ H
this : a⁻¹ * (a * b) * a⁻¹⁻¹ ∈ H
⊢ b * a ∈ H
tactic: have : a⁻¹ * (a * b) * a⁻¹⁻¹ ∈ H := nH.conj_mem (a * b) h a⁻¹
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
nH : H.Normal
a b : G
h : a * b ∈ H
this : a⁻¹ * (a * b) * a⁻¹⁻¹ ∈ H
⊢ b * a ∈ H
state_after: no goals
tactic: simp_all only [inv_mul_cancel_left, inv_inv]
Theorem: PartialHomeomorph.IsImage.iff_symm_preimage_eq'
File: Mathlib/Topology/PartialHomeomorph.lean

Proof steps:
state_before: X : Type u_1
X' : Type u_2
Y : Type u_3
Y' : Type u_4
Z : Type u_5
Z' : Type u_6
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace X'
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Y'
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
e : PartialHomeomorph X Y
s : Set X
t : Set Y
x : X
y : Y
⊢ e.IsImage s t ↔ e.target ∩ ↑e.symm ⁻¹' (e.source ∩ s) = e.target ∩ t
state_after: no goals
tactic: rw [iff_symm_preimage_eq, ← image_source_inter_eq, ← image_source_inter_eq']
Theorem: Nat.smoothNumbers_eq_factoredNumbers
File: Mathlib/NumberTheory/SmoothNumbers.lean

Proof steps:
state_before: n : ℕ
⊢ n.smoothNumbers = factoredNumbers (Finset.range n)
state_after: no goals
tactic: simp only [smoothNumbers, ne_eq, mem_primeFactorsList', and_imp, factoredNumbers,
    Finset.mem_range]
Theorem: CategoryTheory.Limits.HasLimitOfHasProductsOfHasEqualizers.buildLimit_π_app
File: Mathlib/CategoryTheory/Limits/Constructions/LimitsOfProductsAndEqualizers.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
J : Type w
inst✝ : SmallCategory J
F : J ⥤ C
c₁ : Fan F.obj
c₂ : Fan fun f => F.obj f.fst.2
s t : c₁.pt ⟶ c₂.pt
hs : ∀ (f : (p : J × J) × (p.1 ⟶ p.2)), s ≫ c₂.π.app { as := f } = c₁.π.app { as := f.fst.1 } ≫ F.map f.snd
ht : ∀ (f : (p : J × J) × (p.1 ⟶ p.2)), t ≫ c₂.π.app { as := f } = c₁.π.app { as := f.fst.2 }
i : Fork s t
j₁ j₂ : J
f : j₁ ⟶ j₂
⊢ ((Functor.const J).obj i.pt).map f ≫ (fun j => i.ι ≫ c₁.π.app { as := j }) j₂ =
    (fun j => i.ι ≫ c₁.π.app { as := j }) j₁ ≫ F.map f
state_after: C : Type u
inst✝¹ : Category.{v, u} C
J : Type w
inst✝ : SmallCategory J
F : J ⥤ C
c₁ : Fan F.obj
c₂ : Fan fun f => F.obj f.fst.2
s t : c₁.pt ⟶ c₂.pt
hs : ∀ (f : (p : J × J) × (p.1 ⟶ p.2)), s ≫ c₂.π.app { as := f } = c₁.π.app { as := f.fst.1 } ≫ F.map f.snd
ht : ∀ (f : (p : J × J) × (p.1 ⟶ p.2)), t ≫ c₂.π.app { as := f } = c₁.π.app { as := f.fst.2 }
i : Fork s t
j₁ j₂ : J
f : j₁ ⟶ j₂
⊢ 𝟙 i.pt ≫ i.ι ≫ c₁.π.app { as := j₂ } = (i.ι ≫ c₁.π.app { as := j₁ }) ≫ F.map f
tactic: dsimp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
J : Type w
inst✝ : SmallCategory J
F : J ⥤ C
c₁ : Fan F.obj
c₂ : Fan fun f => F.obj f.fst.2
s t : c₁.pt ⟶ c₂.pt
hs : ∀ (f : (p : J × J) × (p.1 ⟶ p.2)), s ≫ c₂.π.app { as := f } = c₁.π.app { as := f.fst.1 } ≫ F.map f.snd
ht : ∀ (f : (p : J × J) × (p.1 ⟶ p.2)), t ≫ c₂.π.app { as := f } = c₁.π.app { as := f.fst.2 }
i : Fork s t
j₁ j₂ : J
f : j₁ ⟶ j₂
⊢ 𝟙 i.pt ≫ i.ι ≫ c₁.π.app { as := j₂ } = (i.ι ≫ c₁.π.app { as := j₁ }) ≫ F.map f
state_after: no goals
tactic: rw [Category.id_comp, Category.assoc, ← hs ⟨⟨_, _⟩, f⟩, i.condition_assoc, ht]
Theorem: Function.extend_le_one
File: Mathlib/Algebra/Order/Pi.lean

Proof steps:
state_before: ι : Type u_1
I : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : I → Type u_6
x y : (i : I) → f✝ i
i : I
inst✝¹ : One γ
inst✝ : LE γ
f : α → β
g : α → γ
e : β → γ
hg : g ≤ 1
he : e ≤ 1
_b : β
⊢ extend f g e _b ≤ 1 _b
state_after: no goals
tactic: classical exact dite_le_one (fun _ ↦ hg _) (fun _ ↦ he _)
Theorem: Finset.map_cons
File: Mathlib/Data/Finset/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : α ↪ β
s✝ : Finset α
f : α ↪ β
a : α
s : Finset α
ha : a ∉ s
⊢ f a ∉ map f s
state_after: no goals
tactic: simpa using ha
Theorem: Real.rpow_logb
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

Proof steps:
state_before: b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
hx : 0 < x
⊢ b ^ logb b x = x
state_after: b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
hx : 0 < x
⊢ |x| = x
tactic: rw [rpow_logb_eq_abs b_pos b_ne_one hx.ne']
state_before: b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
hx : 0 < x
⊢ |x| = x
state_after: no goals
tactic: exact abs_of_pos hx
Theorem: List.rtake_zero
File: Mathlib/Data/List/DropRight.lean

Proof steps:
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ l.rtake 0 = []
state_after: no goals
tactic: simp [rtake]
Theorem: differentiable_const_add_iff
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
c : F
h : Differentiable 𝕜 fun y => c + f y
⊢ Differentiable 𝕜 f
state_after: no goals
tactic: simpa using h.const_add (-c)
Theorem: Complex.hasDerivAt_log_sub_logTaylor
File: Mathlib/Analysis/SpecialFunctions/Complex/LogBounds.lean

Proof steps:
state_before: n : ℕ
z : ℂ
hz : 1 + z ∈ slitPlane
⊢ HasDerivAt (fun z => log (1 + z) - logTaylor (n + 1) z) ((-z) ^ n * (1 + z)⁻¹) z
state_after: case h.e'_7
n : ℕ
z : ℂ
hz : 1 + z ∈ slitPlane
⊢ (-z) ^ n * (1 + z)⁻¹ = (1 + z)⁻¹ - ∑ j ∈ Finset.range n, (-1) ^ j * z ^ j
tactic: convert ((hasDerivAt_log hz).comp_const_add 1 z).sub (hasDerivAt_logTaylor n z) using 1
state_before: case h.e'_7
n : ℕ
z : ℂ
hz : 1 + z ∈ slitPlane
⊢ (-z) ^ n * (1 + z)⁻¹ = (1 + z)⁻¹ - ∑ j ∈ Finset.range n, (-1) ^ j * z ^ j
state_after: case h.e'_7
n : ℕ
z : ℂ
hz : 1 + z ∈ slitPlane
hz' : -z ≠ 1
⊢ (-z) ^ n * (1 + z)⁻¹ = (1 + z)⁻¹ - ∑ j ∈ Finset.range n, (-1) ^ j * z ^ j
tactic: have hz' : -z ≠ 1 := by
    intro H
    rw [neg_eq_iff_eq_neg] at H
    simp only [H, add_right_neg] at hz
    exact slitPlane_ne_zero hz rfl
state_before: case h.e'_7
n : ℕ
z : ℂ
hz : 1 + z ∈ slitPlane
hz' : -z ≠ 1
⊢ (-z) ^ n * (1 + z)⁻¹ = (1 + z)⁻¹ - ∑ j ∈ Finset.range n, (-1) ^ j * z ^ j
state_after: case h.e'_7
n : ℕ
z : ℂ
hz : 1 + z ∈ slitPlane
hz' : -z ≠ 1
⊢ (-z) ^ n * (1 + z)⁻¹ = (1 + z)⁻¹ - -(((-z) ^ n - 1) / (1 + z))
tactic: simp_rw [← mul_pow, neg_one_mul, geom_sum_eq hz', ← neg_add', div_neg, add_comm z]
state_before: case h.e'_7
n : ℕ
z : ℂ
hz : 1 + z ∈ slitPlane
hz' : -z ≠ 1
⊢ (-z) ^ n * (1 + z)⁻¹ = (1 + z)⁻¹ - -(((-z) ^ n - 1) / (1 + z))
state_after: no goals
tactic: field_simp [slitPlane_ne_zero hz]
Theorem: Finset.Ico_diff_Ioo_self
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
a b c : α
inst✝ : DecidableEq α
h : a < b
⊢ Ico a b \ Ioo a b = {a}
state_after: no goals
tactic: simp [← coe_inj, h]
Theorem: Stirling.log_stirlingSeq'_antitone
File: Mathlib/Analysis/SpecialFunctions/Stirling.lean

Proof steps:
state_before: n m : ℕ
⊢ 0 ≤ 1 / (2 * ↑(m + 1) + 1) * ((1 / (2 * ↑(n + 1) + 1)) ^ 2) ^ (m + 1)
state_after: no goals
tactic: positivity
Theorem: Measurable.lintegral_kernel_prod_right'
File: Mathlib/Probability/Kernel/MeasurableIntegral.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : Kernel α β
η : Kernel (α × β) γ
a : α
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
f : α × β → ℝ≥0∞
hf : Measurable f
⊢ Measurable fun a => ∫⁻ (b : β), f (a, b) ∂κ a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : Kernel α β
η : Kernel (α × β) γ
a : α
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
f : α × β → ℝ≥0∞
hf : Measurable f
⊢ Measurable (uncurry fun a b => f (a, b))
tactic: refine Measurable.lintegral_kernel_prod_right ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : Kernel α β
η : Kernel (α × β) γ
a : α
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
f : α × β → ℝ≥0∞
hf : Measurable f
⊢ Measurable (uncurry fun a b => f (a, b))
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : Kernel α β
η : Kernel (α × β) γ
a : α
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
f : α × β → ℝ≥0∞
hf : Measurable f
this : (uncurry fun a b => f (a, b)) = f
⊢ Measurable (uncurry fun a b => f (a, b))
tactic: have : (uncurry fun (a : α) (b : β) => f (a, b)) = f := by
    ext x; rw [uncurry_apply_pair]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : Kernel α β
η : Kernel (α × β) γ
a : α
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
f : α × β → ℝ≥0∞
hf : Measurable f
this : (uncurry fun a b => f (a, b)) = f
⊢ Measurable (uncurry fun a b => f (a, b))
state_after: no goals
tactic: rwa [this]