ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AddMonoid.isTorsionFree_iff_torsion_eq_bot
File: Mathlib/GroupTheory/Torsion.lean

Proof steps:
state_before: G✝ : Type u_1
H : Type u_2
inst✝¹ : Monoid G✝
G : Type u_3
inst✝ : CommGroup G
⊢ IsTorsionFree G ↔ CommGroup.torsion G = ⊥
state_after: G✝ : Type u_1
H : Type u_2
inst✝¹ : Monoid G✝
G : Type u_3
inst✝ : CommGroup G
⊢ (∀ (g : G), g ≠ 1 → ¬IsOfFinOrder g) ↔ ∀ ⦃x : G⦄, x ∈ CommGroup.torsion G → x ∈ ⊥
tactic: rw [IsTorsionFree, eq_bot_iff, SetLike.le_def]
state_before: G✝ : Type u_1
H : Type u_2
inst✝¹ : Monoid G✝
G : Type u_3
inst✝ : CommGroup G
⊢ (∀ (g : G), g ≠ 1 → ¬IsOfFinOrder g) ↔ ∀ ⦃x : G⦄, x ∈ CommGroup.torsion G → x ∈ ⊥
state_after: no goals
tactic: simp [not_imp_not, CommGroup.mem_torsion]
Theorem: bernsteinPolynomial.flip
File: Mathlib/RingTheory/Polynomial/Bernstein.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
n ν : ℕ
h : ν ≤ n
⊢ (bernsteinPolynomial R n ν).comp (1 - X) = bernsteinPolynomial R n (n - ν)
state_after: no goals
tactic: simp [bernsteinPolynomial, h, tsub_tsub_assoc, mul_right_comm]
Theorem: Real.negMulLog_eq_neg
File: Mathlib/Analysis/SpecialFunctions/Log/NegMulLog.lean

Proof steps:
state_before: ⊢ negMulLog = fun x => -(x * log x)
state_after: no goals
tactic: simp [negMulLog_def]
Theorem: Module.End.IsSemisimple.genEigenspace_eq_eigenspace
File: Mathlib/LinearAlgebra/Eigenspace/Semisimple.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f g : End R M
hf : f.IsSemisimple
μ : R
k : ℕ
hk : 0 < k
⊢ (f.genEigenspace μ) k = f.eigenspace μ
state_after: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f g : End R M
hf : f.IsSemisimple
μ : R
k : ℕ
hk : 0 < k
m : M
hm : m ∈ (f.genEigenspace μ) k
⊢ f m = μ • m
tactic: refine le_antisymm (fun m hm ↦ mem_eigenspace_iff.mpr ?_) (eigenspace_le_genEigenspace hk)
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f g : End R M
hf : f.IsSemisimple
μ : R
k : ℕ
hk : 0 < k
m : M
hm : m ∈ (f.genEigenspace μ) k
⊢ f m = μ • m
state_after: no goals
tactic: exact apply_eq_of_mem_genEigenspace_of_comm_of_isSemisimple_of_isNilpotent_sub hm rfl hf (by simp)
Theorem: AlgebraicGeometry.LocallyRingedSpace.iso_hom_val_base_inv_val_base
File: Mathlib/Geometry/RingedSpace/LocallyRingedSpace.lean

Proof steps:
state_before: X✝ X Y : LocallyRingedSpace
e : X ≅ Y
⊢ e.hom.val.base ≫ e.inv.val.base = 𝟙 ↑X.toPresheafedSpace
state_after: X✝ X Y : LocallyRingedSpace
e : X ≅ Y
⊢ (e.hom ≫ e.inv).val.base = 𝟙 ↑X.toPresheafedSpace
tactic: rw [← SheafedSpace.comp_base, ← LocallyRingedSpace.comp_val]
state_before: X✝ X Y : LocallyRingedSpace
e : X ≅ Y
⊢ (e.hom ≫ e.inv).val.base = 𝟙 ↑X.toPresheafedSpace
state_after: no goals
tactic: simp
Theorem: List.pairwise_pair
File: .lake/packages/batteries/Batteries/Data/List/Pairwise.lean

Proof steps:
state_before: α : Type u_1
R : α → α → Prop
a b : α
⊢ Pairwise R [a, b] ↔ R a b
state_after: no goals
tactic: simp
Theorem: Finsupp.mapDomain_comapDomain
File: Mathlib/Data/Finsupp/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddCommMonoid M
f : α → β
hf : Injective f
l : β →₀ M
hl : ↑l.support ⊆ Set.range f
⊢ mapDomain f (comapDomain f l ⋯) = l
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddCommMonoid M
f : α → β
hf : Injective f
l : β →₀ M
hl : ↑l.support ⊆ Set.range f
⊢ mapDomain f (comapDomain f l ⋯) =
    mapDomain (⇑{ toFun := f, inj' := hf }) (comapDomain (⇑{ toFun := f, inj' := hf }) l ⋯)
tactic: conv_rhs => rw [← embDomain_comapDomain (f := ⟨f, hf⟩) hl (M := M), embDomain_eq_mapDomain]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddCommMonoid M
f : α → β
hf : Injective f
l : β →₀ M
hl : ↑l.support ⊆ Set.range f
⊢ mapDomain f (comapDomain f l ⋯) =
    mapDomain (⇑{ toFun := f, inj' := hf }) (comapDomain (⇑{ toFun := f, inj' := hf }) l ⋯)
state_after: no goals
tactic: rfl
Theorem: Finset.ruzsa_triangle_inequality_add_add_sub
File: Mathlib/Combinatorics/Additive/PluenneckeRuzsa.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ (A * C).card * B.card ≤ (A * B).card * (B / C).card
state_after: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ (A / C⁻¹).card * B.card ≤ (A * B).card * (B * C⁻¹).card
tactic: rw [← div_inv_eq_mul, div_eq_mul_inv B]
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ (A / C⁻¹).card * B.card ≤ (A * B).card * (B * C⁻¹).card
state_after: no goals
tactic: exact ruzsa_triangle_inequality_div_mul_mul _ _ _
Theorem: Sym.exists_cons_of_mem
File: Mathlib/Data/Sym/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
n n' m : ℕ
s✝ : Sym α n
a✝ b : α
s : Sym α (n + 1)
a : α
h : a ∈ s
⊢ ∃ t, s = a ::ₛ t
state_after: case intro
α : Type u_1
β : Type u_2
n n' m✝ : ℕ
s✝ : Sym α n
a✝ b : α
s : Sym α (n + 1)
a : α
h✝ : a ∈ s
m : Multiset α
h : ↑s = a ::ₘ m
⊢ ∃ t, s = a ::ₛ t
tactic: obtain ⟨m, h⟩ := Multiset.exists_cons_of_mem h
state_before: case intro
α : Type u_1
β : Type u_2
n n' m✝ : ℕ
s✝ : Sym α n
a✝ b : α
s : Sym α (n + 1)
a : α
h✝ : a ∈ s
m : Multiset α
h : ↑s = a ::ₘ m
⊢ ∃ t, s = a ::ₛ t
state_after: case intro
α : Type u_1
β : Type u_2
n n' m✝ : ℕ
s✝ : Sym α n
a✝ b : α
s : Sym α (n + 1)
a : α
h✝ : a ∈ s
m : Multiset α
h : ↑s = a ::ₘ m
this : Multiset.card m = n
⊢ ∃ t, s = a ::ₛ t
tactic: have : Multiset.card m = n := by
    apply_fun Multiset.card at h
    rw [s.2, Multiset.card_cons, add_left_inj] at h
    exact h.symm
state_before: case intro
α : Type u_1
β : Type u_2
n n' m✝ : ℕ
s✝ : Sym α n
a✝ b : α
s : Sym α (n + 1)
a : α
h✝ : a ∈ s
m : Multiset α
h : ↑s = a ::ₘ m
this : Multiset.card m = n
⊢ ∃ t, s = a ::ₛ t
state_after: case h
α : Type u_1
β : Type u_2
n n' m✝ : ℕ
s✝ : Sym α n
a✝ b : α
s : Sym α (n + 1)
a : α
h✝ : a ∈ s
m : Multiset α
h : ↑s = a ::ₘ m
this : Multiset.card m = n
⊢ s = a ::ₛ ⟨m, this⟩
tactic: use ⟨m, this⟩
state_before: case h
α : Type u_1
β : Type u_2
n n' m✝ : ℕ
s✝ : Sym α n
a✝ b : α
s : Sym α (n + 1)
a : α
h✝ : a ∈ s
m : Multiset α
h : ↑s = a ::ₘ m
this : Multiset.card m = n
⊢ s = a ::ₛ ⟨m, this⟩
state_after: case h.a
α : Type u_1
β : Type u_2
n n' m✝ : ℕ
s✝ : Sym α n
a✝ b : α
s : Sym α (n + 1)
a : α
h✝ : a ∈ s
m : Multiset α
h : ↑s = a ::ₘ m
this : Multiset.card m = n
⊢ ↑s = ↑(a ::ₛ ⟨m, this⟩)
tactic: apply Subtype.ext
state_before: case h.a
α : Type u_1
β : Type u_2
n n' m✝ : ℕ
s✝ : Sym α n
a✝ b : α
s : Sym α (n + 1)
a : α
h✝ : a ∈ s
m : Multiset α
h : ↑s = a ::ₘ m
this : Multiset.card m = n
⊢ ↑s = ↑(a ::ₛ ⟨m, this⟩)
state_after: no goals
tactic: exact h
Theorem: abs_circleMap_zero
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

Proof steps:
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
R θ : ℝ
⊢ Complex.abs (circleMap 0 R θ) = |R|
state_after: no goals
tactic: simp [circleMap]
Theorem: Set.ne_univ_iff_exists_not_mem
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α✝ : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α✝
s✝ s₁ s₂ t t₁ t₂ u : Set α✝
α : Type u_1
s : Set α
⊢ s ≠ univ ↔ ∃ a, a ∉ s
state_after: no goals
tactic: rw [← not_forall, ← eq_univ_iff_forall]
Theorem: DilationEquiv.mulLeft_symm_apply
File: Mathlib/Analysis/Normed/Field/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝ : NormedDivisionRing α
a✝ a : α
ha : a ≠ 0
x y : α
⊢ edist ((Equiv.mulLeft₀ a ha).toFun x) ((Equiv.mulLeft₀ a ha).toFun y) = ↑‖a‖₊ * edist x y
state_after: no goals
tactic: simp [edist_nndist, nndist_eq_nnnorm, ← mul_sub]
Theorem: Part.bind_some_eq_map
File: Mathlib/Data/Part.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β
x : Part α
⊢ ∀ (a : β), a ∈ x.bind (some ∘ f) ↔ a ∈ map f x
state_after: no goals
tactic: simp [eq_comm]
Theorem: seminormFromBounded_one_le
File: Mathlib/Analysis/Normed/Ring/SeminormFromBounded.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
⊢ seminormFromBounded' f 1 ≤ 1
state_after: case pos
R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
f_ne_zero : f ≠ 0
⊢ seminormFromBounded' f 1 ≤ 1

case neg
R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
f_ne_zero : ¬f ≠ 0
⊢ seminormFromBounded' f 1 ≤ 1
tactic: by_cases f_ne_zero : f ≠ 0
Theorem: Matrix.det_one_sub_mul_comm
File: Mathlib/LinearAlgebra/Matrix/SchurComplement.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
inst✝⁶ : Fintype l
inst✝⁵ : Fintype m
inst✝⁴ : Fintype n
inst✝³ : DecidableEq l
inst✝² : DecidableEq m
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A : Matrix m n α
B : Matrix n m α
⊢ (1 - A * B).det = (1 - B * A).det
state_after: no goals
tactic: rw [sub_eq_add_neg, ← Matrix.neg_mul, det_one_add_mul_comm, Matrix.mul_neg, ← sub_eq_add_neg]
Theorem: Convex.mem_Ioc
File: Mathlib/Analysis/Convex/Segment.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝ : LinearOrderedField 𝕜
x y z : 𝕜
h : x < y
⊢ z ∈ Ioc x y ↔ ∃ a b, 0 ≤ a ∧ 0 < b ∧ a + b = 1 ∧ a * x + b * y = z
state_after: case refine_1
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝ : LinearOrderedField 𝕜
x y z : 𝕜
h : x < y
hz : z ∈ Ioc x y
⊢ ∃ a b, 0 ≤ a ∧ 0 < b ∧ a + b = 1 ∧ a * x + b * y = z

case refine_2
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝ : LinearOrderedField 𝕜
x y z : 𝕜
h : x < y
⊢ (∃ a b, 0 ≤ a ∧ 0 < b ∧ a + b = 1 ∧ a * x + b * y = z) → z ∈ Ioc x y
tactic: refine ⟨fun hz => ?_, ?_⟩
Theorem: Finset.mulEnergy_eq_card_filter
File: Mathlib/Combinatorics/Additive/Energy.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ s t : Finset α
⊢ ∀ (i : (α × α) × α × α),
    i ∈ filter (fun x => x.1.1 * x.2.1 = x.1.2 * x.2.2) ((s ×ˢ s) ×ˢ t ×ˢ t) ↔
      (Equiv.prodProdProdComm α α α α) i ∈
        filter
          (fun x =>
            match x with
            | ((a, b), c, d) => a * b = c * d)
          ((s ×ˢ t) ×ˢ s ×ˢ t)
state_after: no goals
tactic: simp [and_and_and_comm]
Theorem: HomologicalComplex.xPrevIsoSelf_comp_dTo
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

Proof steps:
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
j : ι
h : ¬c.Rel (c.prev j) j
⊢ (C.xPrevIsoSelf h).inv ≫ C.dTo j = 0
state_after: no goals
tactic: simp [h]
Theorem: UniformOnFun.hasBasis_uniformity_of_basis_aux₁
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s✝ s' : Set α
x : α
p✝ : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
p : ι → Prop
s : ι → Set (β × β)
hb : (𝓤 β).HasBasis p s
S : Set α
⊢ (𝓤 (α →ᵤ[𝔖] β)).HasBasis p fun i => UniformOnFun.gen 𝔖 S (s i)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s✝ s' : Set α
x : α
p✝ : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
p : ι → Prop
s : ι → Set (β × β)
hb : (𝓤 β).HasBasis p s
S : Set α
⊢ (comap (Prod.map S.restrict S.restrict) (𝓤 (↑S → β))).HasBasis p fun i =>
    Prod.map (S.restrict ∘ ⇑UniformFun.toFun) (S.restrict ∘ ⇑UniformFun.toFun) ⁻¹' UniformFun.gen (↑S) β (s i)
tactic: simp_rw [UniformOnFun.gen_eq_preimage_restrict, uniformity_comap]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s✝ s' : Set α
x : α
p✝ : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
p : ι → Prop
s : ι → Set (β × β)
hb : (𝓤 β).HasBasis p s
S : Set α
⊢ (comap (Prod.map S.restrict S.restrict) (𝓤 (↑S → β))).HasBasis p fun i =>
    Prod.map (S.restrict ∘ ⇑UniformFun.toFun) (S.restrict ∘ ⇑UniformFun.toFun) ⁻¹' UniformFun.gen (↑S) β (s i)
state_after: no goals
tactic: exact (UniformFun.hasBasis_uniformity_of_basis S β hb).comap _
Theorem: Matrix.dotProduct_add
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
x y : n → α
⊢ u ⬝ᵥ (v + w) = u ⬝ᵥ v + u ⬝ᵥ w
state_after: no goals
tactic: simp [dotProduct, mul_add, Finset.sum_add_distrib]
Theorem: writtenInExtChartAt_extChartAt_symm
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
M : Type u_3
H : Type u_4
E' : Type u_5
M' : Type u_6
H' : Type u_7
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : TopologicalSpace H
inst✝⁶ : TopologicalSpace M
f f' : PartialHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝⁵ : NormedAddCommGroup E'
inst✝⁴ : NormedSpace 𝕜 E'
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
s t : Set M
inst✝¹ : ChartedSpace H M
inst✝ : ChartedSpace H' M'
x : M
y : E
h : y ∈ (extChartAt I x).target
⊢ writtenInExtChartAt 𝓘(𝕜, E) I (↑(extChartAt I x) x) (↑(extChartAt I x).symm) y = y
state_after: no goals
tactic: simp_all only [mfld_simps]
Theorem: Polynomial.coeff_mul_X_pow
File: Mathlib/Algebra/Polynomial/Coeff.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n d : ℕ
⊢ (p * X ^ n).coeff (d + n) = p.coeff d
state_after: case h₀
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n d : ℕ
⊢ ∀ b ∈ antidiagonal (d + n), b ≠ (d, n) → p.coeff b.1 * (X ^ n).coeff b.2 = 0

case h₁
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n d : ℕ
⊢ (d, n) ∉ antidiagonal (d + n) → p.coeff (d, n).1 * (X ^ n).coeff (d, n).2 = 0
tactic: rw [coeff_mul, Finset.sum_eq_single (d, n), coeff_X_pow, if_pos rfl, mul_one]
Theorem: Polynomial.Gal.restrictDvd_def
File: Mathlib/FieldTheory/PolynomialGaloisGroup.lean

Proof steps:
state_before: F : Type u_1
inst✝³ : Field F
p q : F[X]
E : Type u_2
inst✝² : Field E
inst✝¹ : Algebra F E
inst✝ : Decidable (q = 0)
hpq : p ∣ q
⊢ restrictDvd hpq = if hq : q = 0 then 1 else restrict p q.SplittingField
state_after: F : Type u_1
inst✝³ : Field F
p q : F[X]
E : Type u_2
inst✝² : Field E
inst✝¹ : Algebra F E
inst✝ : Decidable (q = 0)
hpq : p ∣ q
⊢ (if hq : q = 0 then 1 else restrict p q.SplittingField) = if hq : q = 0 then 1 else restrict p q.SplittingField
tactic: unfold restrictDvd
state_before: F : Type u_1
inst✝³ : Field F
p q : F[X]
E : Type u_2
inst✝² : Field E
inst✝¹ : Algebra F E
inst✝ : Decidable (q = 0)
hpq : p ∣ q
⊢ (if hq : q = 0 then 1 else restrict p q.SplittingField) = if hq : q = 0 then 1 else restrict p q.SplittingField
state_after: no goals
tactic: convert rfl
Theorem: Denumerable.list_ofNat_zero
File: Mathlib/Logic/Equiv/List.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Denumerable α
inst✝ : Denumerable β
⊢ ofNat (List α) 0 = []
state_after: no goals
tactic: rw [← @encode_list_nil α, ofNat_encode]
Theorem: ENNReal.toReal_max
File: Mathlib/Data/ENNReal/Real.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
hr : a ≠ ⊤
hp : b ≠ ⊤
h : a ≤ b
⊢ (max a b).toReal = max a.toReal b.toReal
state_after: no goals
tactic: simp only [h, (ENNReal.toReal_le_toReal hr hp).2 h, max_eq_right]
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
hr : a ≠ ⊤
hp : b ≠ ⊤
h : b ≤ a
⊢ (max a b).toReal = max a.toReal b.toReal
state_after: no goals
tactic: simp only [h, (ENNReal.toReal_le_toReal hp hr).2 h, max_eq_left]
Theorem: Polynomial.Chebyshev.map_U
File: Mathlib/RingTheory/Polynomial/Chebyshev.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
n : ℤ
⊢ map f (U R n) = U S n
state_after: no goals
tactic: induction n using Polynomial.Chebyshev.induct with
  | zero => simp
  | one => simp
  | add_two n ih1 ih2 =>
    simp_rw [U_add_two, Polynomial.map_sub, Polynomial.map_mul, Polynomial.map_ofNat, map_X, ih1,
      ih2]
  | neg_add_one n ih1 ih2 =>
    simp_rw [U_sub_one, Polynomial.map_sub, Polynomial.map_mul, Polynomial.map_ofNat, map_X, ih1,
      ih2]
Theorem: neg_thickening
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

Proof steps:
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ (thickening δ s)⁻¹ = thickening δ s⁻¹
state_after: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ {x | EMetric.infEdist x s < ENNReal.ofReal δ}⁻¹ = {x | EMetric.infEdist x⁻¹ s < ENNReal.ofReal δ}
tactic: simp_rw [thickening, ← infEdist_inv]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ {x | EMetric.infEdist x s < ENNReal.ofReal δ}⁻¹ = {x | EMetric.infEdist x⁻¹ s < ENNReal.ofReal δ}
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.integral_indicator
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
hs : MeasurableSet s
⊢ ∫ (x : X), s.indicator f x ∂μ = ∫ (x : X) in s, f x ∂μ
state_after: case pos
X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
hs : MeasurableSet s
hfi : IntegrableOn f s μ
⊢ ∫ (x : X), s.indicator f x ∂μ = ∫ (x : X) in s, f x ∂μ

case neg
X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
hs : MeasurableSet s
hfi : ¬IntegrableOn f s μ
⊢ ∫ (x : X), s.indicator f x ∂μ = ∫ (x : X) in s, f x ∂μ
tactic: by_cases hfi : IntegrableOn f s μ
state_before: case pos
X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
hs : MeasurableSet s
hfi : IntegrableOn f s μ
⊢ ∫ (x : X), s.indicator f x ∂μ = ∫ (x : X) in s, f x ∂μ

case neg
X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
hs : MeasurableSet s
hfi : ¬IntegrableOn f s μ
⊢ ∫ (x : X), s.indicator f x ∂μ = ∫ (x : X) in s, f x ∂μ
state_after: case neg
X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
hs : MeasurableSet s
hfi : ¬IntegrableOn f s μ
⊢ ∫ (x : X), s.indicator f x ∂μ = ∫ (x : X) in s, f x ∂μ

case pos
X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
hs : MeasurableSet s
hfi : IntegrableOn f s μ
⊢ ∫ (x : X), s.indicator f x ∂μ = ∫ (x : X) in s, f x ∂μ
tactic: swap
Theorem: Matrix.det_one_add_mul_comm
File: Mathlib/LinearAlgebra/Matrix/SchurComplement.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
inst✝⁶ : Fintype l
inst✝⁵ : Fintype m
inst✝⁴ : Fintype n
inst✝³ : DecidableEq l
inst✝² : DecidableEq m
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A : Matrix m n α
B : Matrix n m α
⊢ (1 + A * B).det = (fromBlocks 1 (-A) B 1).det
state_after: no goals
tactic: rw [det_fromBlocks_one₂₂, Matrix.neg_mul, sub_neg_eq_add]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
inst✝⁶ : Fintype l
inst✝⁵ : Fintype m
inst✝⁴ : Fintype n
inst✝³ : DecidableEq l
inst✝² : DecidableEq m
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A : Matrix m n α
B : Matrix n m α
⊢ (fromBlocks 1 (-A) B 1).det = (1 + B * A).det
state_after: no goals
tactic: rw [det_fromBlocks_one₁₁, Matrix.mul_neg, sub_neg_eq_add]
Theorem: Trivialization.symmL_apply
File: Mathlib/Topology/VectorBundle/Basic.lean

Proof steps:
state_before: R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁹ : NontriviallyNormedField R
inst✝⁸ : (x : B) → AddCommMonoid (E x)
inst✝⁷ : (x : B) → Module R (E x)
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace R F
inst✝⁴ : TopologicalSpace B
inst✝³ : TopologicalSpace (TotalSpace F E)
inst✝² : (x : B) → TopologicalSpace (E x)
inst✝¹ : FiberBundle F E
e : Trivialization F TotalSpace.proj
inst✝ : Trivialization.IsLinear R e
b : B
⊢ Continuous { toFun := e.symm b, map_add' := ⋯, map_smul' := ⋯ }.toFun
state_after: case pos
R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁹ : NontriviallyNormedField R
inst✝⁸ : (x : B) → AddCommMonoid (E x)
inst✝⁷ : (x : B) → Module R (E x)
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace R F
inst✝⁴ : TopologicalSpace B
inst✝³ : TopologicalSpace (TotalSpace F E)
inst✝² : (x : B) → TopologicalSpace (E x)
inst✝¹ : FiberBundle F E
e : Trivialization F TotalSpace.proj
inst✝ : Trivialization.IsLinear R e
b : B
hb : b ∈ e.baseSet
⊢ Continuous { toFun := e.symm b, map_add' := ⋯, map_smul' := ⋯ }.toFun

case neg
R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁹ : NontriviallyNormedField R
inst✝⁸ : (x : B) → AddCommMonoid (E x)
inst✝⁷ : (x : B) → Module R (E x)
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace R F
inst✝⁴ : TopologicalSpace B
inst✝³ : TopologicalSpace (TotalSpace F E)
inst✝² : (x : B) → TopologicalSpace (E x)
inst✝¹ : FiberBundle F E
e : Trivialization F TotalSpace.proj
inst✝ : Trivialization.IsLinear R e
b : B
hb : b ∉ e.baseSet
⊢ Continuous { toFun := e.symm b, map_add' := ⋯, map_smul' := ⋯ }.toFun
tactic: by_cases hb : b ∈ e.baseSet
Theorem: Filter.EventuallyEq.hasFDerivAtFilter_iff
File: Mathlib/Analysis/Calculus/FDeriv/Basic.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
h₀ : f₀ =ᶠ[L] f₁
hx : f₀ x = f₁ x
h₁ : ∀ (x : E), f₀' x = f₁' x
⊢ HasFDerivAtFilter f₀ f₀' x L ↔ HasFDerivAtFilter f₁ f₁' x L
state_after: 𝕜 : 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
h₀ : f₀ =ᶠ[L] f₁
hx : f₀ x = f₁ x
h₁ : ∀ (x : E), f₀' x = f₁' x
⊢ ((fun x' => f₀ x' - f₀ x - f₀' (x' - x)) =o[L] fun x' => x' - x) ↔
    (fun x' => f₁ x' - f₁ x - f₁' (x' - x)) =o[L] fun x' => x' - x
tactic: simp only [hasFDerivAtFilter_iff_isLittleO]
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
h₀ : f₀ =ᶠ[L] f₁
hx : f₀ x = f₁ x
h₁ : ∀ (x : E), f₀' x = f₁' x
⊢ ((fun x' => f₀ x' - f₀ x - f₀' (x' - x)) =o[L] fun x' => x' - x) ↔
    (fun x' => f₁ x' - f₁ x - f₁' (x' - x)) =o[L] fun x' => x' - x
state_after: no goals
tactic: exact isLittleO_congr (h₀.mono fun y hy => by simp only [hy, h₁, hx]) .rfl