ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AlgebraicGeometry.ι_sigmaIsoGlued_hom
File: Mathlib/AlgebraicGeometry/Limits.lean

Proof steps:
state_before: ι : Type u
f : ι → Scheme
i : ι
⊢ Sigma.ι f i ≫ (sigmaIsoGlued f).hom = (disjointGlueData f).ι i
state_after: no goals
tactic: rw [← ι_sigmaIsoGlued_inv, Category.assoc, Iso.inv_hom_id, Category.comp_id]
Theorem: List.sublistsLen_succ_cons
File: Mathlib/Data/List/Sublists.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
n : ℕ
a : α
l : List α
⊢ sublistsLen (n + 1) (a :: l) = sublistsLen (n + 1) l ++ map (cons a) (sublistsLen n l)
state_after: α : Type u
β : Type v
γ : Type w
n : ℕ
a : α
l : List α
⊢ sublistsLen (n + 1) l ++ map (id ∘ cons a) (sublistsLen n l) = sublistsLen (n + 1) l ++ map (cons a) (sublistsLen n l)
tactic: rw [sublistsLen, sublistsLenAux, sublistsLenAux_eq, sublistsLenAux_eq, map_id,
      append_nil]
state_before: α : Type u
β : Type v
γ : Type w
n : ℕ
a : α
l : List α
⊢ sublistsLen (n + 1) l ++ map (id ∘ cons a) (sublistsLen n l) = sublistsLen (n + 1) l ++ map (cons a) (sublistsLen n l)
state_after: no goals
tactic: rfl
Theorem: AlgebraicGeometry.Scheme.restrictFunctorΓ_hom_app
File: Mathlib/AlgebraicGeometry/Restrict.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U : X.Opens
⊢ ∀ {X_1 Y : X.Opensᵒᵖ} (f : X_1 ⟶ Y),
    (X.restrictFunctor.op ⋙ (Over.forget X).op ⋙ Γ).map f ≫
        ((fun U => Functor.mapIso X.presheaf (eqToIso ⋯).symm.op) Y).hom =
      ((fun U => Functor.mapIso X.presheaf (eqToIso ⋯).symm.op) X_1).hom ≫ X.presheaf.map f
state_after: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U✝ : X.Opens
U V : X.Opensᵒᵖ
i : U ⟶ V
⊢ (X.restrictFunctor.op ⋙ (Over.forget X).op ⋙ Γ).map i ≫
      ((fun U => Functor.mapIso X.presheaf (eqToIso ⋯).symm.op) V).hom =
    ((fun U => Functor.mapIso X.presheaf (eqToIso ⋯).symm.op) U).hom ≫ X.presheaf.map i
tactic: intro U V i
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U✝ : X.Opens
U V : X.Opensᵒᵖ
i : U ⟶ V
⊢ (X.restrictFunctor.op ⋙ (Over.forget X).op ⋙ Γ).map i ≫
      ((fun U => Functor.mapIso X.presheaf (eqToIso ⋯).symm.op) V).hom =
    ((fun U => Functor.mapIso X.presheaf (eqToIso ⋯).symm.op) U).hom ≫ X.presheaf.map i
state_after: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U✝ : X.Opens
U V : X.Opensᵒᵖ
i : U ⟶ V
⊢ Hom.app (X.restrictFunctor.map i.unop).left ⊤ ≫ X.presheaf.map (eqToHom ⋯).op =
    X.presheaf.map (eqToHom ⋯).op ≫ X.presheaf.map i
tactic: dsimp [-Scheme.restrictFunctor_map_left]
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U✝ : X.Opens
U V : X.Opensᵒᵖ
i : U ⟶ V
⊢ Hom.app (X.restrictFunctor.map i.unop).left ⊤ ≫ X.presheaf.map (eqToHom ⋯).op =
    X.presheaf.map (eqToHom ⋯).op ≫ X.presheaf.map i
state_after: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U✝ : X.Opens
U V : X.Opensᵒᵖ
i : U ⟶ V
⊢ X.presheaf.map ((homOfLE ⋯).op ≫ (eqToHom ⋯).op) = X.presheaf.map ((eqToHom ⋯).op ≫ i)
tactic: rw [X.restrictFunctor_map_app, ← Functor.map_comp, ← Functor.map_comp]
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U✝ : X.Opens
U V : X.Opensᵒᵖ
i : U ⟶ V
⊢ X.presheaf.map ((homOfLE ⋯).op ≫ (eqToHom ⋯).op) = X.presheaf.map ((eqToHom ⋯).op ≫ i)
state_after: no goals
tactic: congr 1
Theorem: Filter.prod_pure_pure
File: Mathlib/Order/Filter/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f : Filter α
g : Filter β
a : α
b : β
⊢ pure a ×ˢ pure b = pure (a, b)
state_after: no goals
tactic: simp
Theorem: Ideal.isMaximal_comap_of_isIntegral_of_isMaximal
File: Mathlib/RingTheory/Ideal/Over.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : CommRing R
S : Type u_2
inst✝² : CommRing S
f : R →+* S
I✝ J : Ideal S
inst✝¹ : Algebra R S
inst✝ : Algebra.IsIntegral R S
I : Ideal S
hI : I.IsMaximal
⊢ (comap (algebraMap R S) I).IsMaximal
state_after: R : Type u_1
inst✝³ : CommRing R
S : Type u_2
inst✝² : CommRing S
f : R →+* S
I✝ J : Ideal S
inst✝¹ : Algebra R S
inst✝ : Algebra.IsIntegral R S
I : Ideal S
hI : I.IsMaximal
⊢ IsField (R ⧸ comap (algebraMap R S) I)
tactic: refine Ideal.Quotient.maximal_of_isField _ ?_
state_before: R : Type u_1
inst✝³ : CommRing R
S : Type u_2
inst✝² : CommRing S
f : R →+* S
I✝ J : Ideal S
inst✝¹ : Algebra R S
inst✝ : Algebra.IsIntegral R S
I : Ideal S
hI : I.IsMaximal
⊢ IsField (R ⧸ comap (algebraMap R S) I)
state_after: R : Type u_1
inst✝³ : CommRing R
S : Type u_2
inst✝² : CommRing S
f : R →+* S
I✝ J : Ideal S
inst✝¹ : Algebra R S
inst✝ : Algebra.IsIntegral R S
I : Ideal S
hI : I.IsMaximal
this : (comap (algebraMap R S) I).IsPrime
⊢ IsField (R ⧸ comap (algebraMap R S) I)
tactic: haveI : IsPrime (I.comap (algebraMap R S)) := comap_isPrime _ _
state_before: R : Type u_1
inst✝³ : CommRing R
S : Type u_2
inst✝² : CommRing S
f : R →+* S
I✝ J : Ideal S
inst✝¹ : Algebra R S
inst✝ : Algebra.IsIntegral R S
I : Ideal S
hI : I.IsMaximal
this : (comap (algebraMap R S) I).IsPrime
⊢ IsField (R ⧸ comap (algebraMap R S) I)
state_after: no goals
tactic: exact isField_of_isIntegral_of_isField
    algebraMap_quotient_injective (by rwa [← Quotient.maximal_ideal_iff_isField_quotient])
Theorem: DirectSum.finite_support
File: Mathlib/Algebra/DirectSum/Basic.lean

Proof steps:
state_before: ι : Type v
β : ι → Type w
inst✝³ : (i : ι) → AddCommMonoid (β i)
M : Type u_1
S : Type u_2
inst✝² : AddCommMonoid M
inst✝¹ : SetLike S M
inst✝ : AddSubmonoidClass S M
A : ι → S
x : ⨁ (i : ι), ↥(A i)
⊢ (support fun i => ↑(x i)).Finite
state_after: no goals
tactic: classical
  exact (DFinsupp.support x).finite_toSet.subset (DirectSum.support_subset _ x)
Theorem: RatFunc.eval_one
File: Mathlib/FieldTheory/RatFunc/AsPolynomial.lean

Proof steps:
state_before: K : Type u
inst✝¹ : Field K
L : Type u
inst✝ : Field L
f : K →+* L
a : L
⊢ eval f a 1 = 1
state_after: no goals
tactic: simp [eval]
Theorem: Polynomial.eval_comp
File: Mathlib/Algebra/Polynomial/Eval.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : CommSemiring R
p q : R[X]
x : R
inst✝ : CommSemiring S
f : R →+* S
⊢ eval x (p.comp q) = eval (eval x q) p
state_after: no goals
tactic: induction p using Polynomial.induction_on' with
  | h_add r s hr hs =>
    simp [add_comp, hr, hs]
  | h_monomial n a =>
    simp
Theorem: Part.mul_mem_mul
File: Mathlib/Data/Part.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Mul α
a b : Part α
ma mb : α
ha : ma ∈ a
hb : mb ∈ b
⊢ (a * b).get ⋯ = ma * mb
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Mul α
a b : Part α
ma mb : α
ha : ma ∈ a
hb : mb ∈ b
⊢ (a * b).get ⋯ = a.get ⋯ * b.get ⋯
tactic: simp only [← ha.2, ← hb.2]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Mul α
a b : Part α
ma mb : α
ha : ma ∈ a
hb : mb ∈ b
⊢ (a * b).get ⋯ = a.get ⋯ * b.get ⋯
state_after: no goals
tactic: rfl
Theorem: hasProd_nat_add_iff'
File: Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean

Proof steps:
state_before: M : Type u_1
inst✝⁴ : CommMonoid M
inst✝³ : TopologicalSpace M
m m' : M
G : Type u_2
inst✝² : CommGroup G
g g' : G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
f : ℕ → G
k : ℕ
⊢ HasProd (fun n => f (n + k)) (g / ∏ i ∈ range k, f i) ↔ HasProd f g
state_after: no goals
tactic: simp [hasProd_nat_add_iff]
Theorem: Nat.card_eq_card_units_add_one
File: Mathlib/Data/Fintype/Units.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : GroupWithZero α
inst✝ : Finite α
⊢ Nat.card α = Nat.card αˣ + 1
state_after: α : Type u_1
inst✝¹ : GroupWithZero α
inst✝ : Finite α
this : Fintype α
⊢ Nat.card α = Nat.card αˣ + 1
tactic: have : Fintype α := Fintype.ofFinite α
state_before: α : Type u_1
inst✝¹ : GroupWithZero α
inst✝ : Finite α
this : Fintype α
⊢ Nat.card α = Nat.card αˣ + 1
state_after: no goals
tactic: classical
    rw [Nat.card_eq_fintype_card, Nat.card_eq_fintype_card, Fintype.card_eq_card_units_add_one]
Theorem: MeasureTheory.lintegral_rpow_nnnorm_lt_top_of_eLpNorm'_lt_top
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
hq0_lt : 0 < q
hfq : eLpNorm' f q μ < ⊤
⊢ ∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ < ⊤
state_after: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
hq0_lt : 0 < q
hfq : eLpNorm' f q μ < ⊤
⊢ eLpNorm' f q μ ^ q < ⊤
tactic: rw [lintegral_rpow_nnnorm_eq_rpow_eLpNorm' hq0_lt]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
hq0_lt : 0 < q
hfq : eLpNorm' f q μ < ⊤
⊢ eLpNorm' f q μ ^ q < ⊤
state_after: no goals
tactic: exact ENNReal.rpow_lt_top_of_nonneg (le_of_lt hq0_lt) (ne_of_lt hfq)
Theorem: Matroid.uniqueBaseOn_restrict'
File: Mathlib/Data/Matroid/Constructions.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
E✝ B I✝ X R✝ J I E R : Set α
⊢ uniqueBaseOn I E ↾ R = uniqueBaseOn (I ∩ R ∩ E) R
state_after: α : Type u_1
M : Matroid α
E✝ B I✝ X R✝ J I E R : Set α
⊢ ∀ I_1 ⊆ R, (I_1 ⊆ I ∧ I_1 ⊆ E) ∧ I_1 ⊆ R ↔ ((I_1 ⊆ I ∧ I_1 ⊆ R) ∧ I_1 ⊆ E) ∧ I_1 ⊆ R
tactic: simp_rw [eq_iff_indep_iff_indep_forall, restrict_ground_eq, uniqueBaseOn_ground, true_and,
    restrict_indep_iff, uniqueBaseOn_indep_iff', subset_inter_iff]
state_before: α : Type u_1
M : Matroid α
E✝ B I✝ X R✝ J I E R : Set α
⊢ ∀ I_1 ⊆ R, (I_1 ⊆ I ∧ I_1 ⊆ E) ∧ I_1 ⊆ R ↔ ((I_1 ⊆ I ∧ I_1 ⊆ R) ∧ I_1 ⊆ E) ∧ I_1 ⊆ R
state_after: no goals
tactic: tauto
Theorem: Real.tan_mul_cos
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x✝ y x : ℝ
hx : cos x ≠ 0
⊢ tan x * cos x = sin x
state_after: no goals
tactic: rw [tan_eq_sin_div_cos, div_mul_cancel₀ _ hx]
Theorem: spectrum.units_smul_resolvent
File: Mathlib/Algebra/Algebra/Spectrum.lean

Proof steps:
state_before: R : Type u
A : Type v
inst✝² : CommSemiring R
inst✝¹ : Ring A
inst✝ : Algebra R A
r : Rˣ
s : R
a : A
⊢ r • resolvent a s = resolvent (r⁻¹ • a) (r⁻¹ • s)
state_after: case pos
R : Type u
A : Type v
inst✝² : CommSemiring R
inst✝¹ : Ring A
inst✝ : Algebra R A
r : Rˣ
s : R
a : A
h : s ∈ σ a
⊢ r • resolvent a s = resolvent (r⁻¹ • a) (r⁻¹ • s)

case neg
R : Type u
A : Type v
inst✝² : CommSemiring R
inst✝¹ : Ring A
inst✝ : Algebra R A
r : Rˣ
s : R
a : A
h : s ∉ σ a
⊢ r • resolvent a s = resolvent (r⁻¹ • a) (r⁻¹ • s)
tactic: by_cases h : s ∈ spectrum R a
Theorem: NONote.cmp_compares
File: Mathlib/SetTheory/Ordinal/Notation.lean

Proof steps:
state_before: a : ONote
ha : a.NF
b : ONote
hb : b.NF
⊢ (cmp ⟨a, ha⟩ ⟨b, hb⟩).Compares ⟨a, ha⟩ ⟨b, hb⟩
state_after: a : ONote
ha : a.NF
b : ONote
hb : b.NF
⊢ (a.cmp b).Compares ⟨a, ha⟩ ⟨b, hb⟩
tactic: dsimp [cmp]
state_before: a : ONote
ha : a.NF
b : ONote
hb : b.NF
⊢ (a.cmp b).Compares ⟨a, ha⟩ ⟨b, hb⟩
state_after: a : ONote
ha : a.NF
b : ONote
hb : b.NF
this : (a.cmp b).Compares a b
⊢ (a.cmp b).Compares ⟨a, ha⟩ ⟨b, hb⟩
tactic: have := ONote.cmp_compares a b
state_before: a : ONote
ha : a.NF
b : ONote
hb : b.NF
this : (a.cmp b).Compares a b
⊢ (a.cmp b).Compares ⟨a, ha⟩ ⟨b, hb⟩
state_after: case eq
a : ONote
ha : a.NF
b : ONote
hb : b.NF
h : a.cmp b = Ordering.eq
this : Ordering.eq.Compares a b
⊢ Ordering.eq.Compares ⟨a, ha⟩ ⟨b, hb⟩
tactic: cases h : ONote.cmp a b <;> simp only [h] at this <;> try exact this
state_before: case eq
a : ONote
ha : a.NF
b : ONote
hb : b.NF
h : a.cmp b = Ordering.eq
this : Ordering.eq.Compares a b
⊢ Ordering.eq.Compares ⟨a, ha⟩ ⟨b, hb⟩
state_after: no goals
tactic: exact Subtype.mk_eq_mk.2 this
Theorem: IsLocalization.lift_spec_mul_add
File: Mathlib/RingTheory/Localization/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
g : R →+* P
hg : ∀ (y : ↥M), IsUnit (g ↑y)
z : S
w w' v : P
⊢ ((toLocalizationWithZeroMap M S).lift g.toMonoidWithZeroHom hg) z * w + w' = v ↔
    g ((toLocalizationMap M S).sec z).1 * w + g ↑((toLocalizationMap M S).sec z).2 * w' =
      g ↑((toLocalizationMap M S).sec z).2 * v
state_after: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
g : R →+* P
hg : ∀ (y : ↥M), IsUnit (g ↑y)
z : S
w w' v : P
⊢ ↑g.toMonoidWithZeroHom ((toLocalizationWithZeroMap M S).sec z).1 * w +
        g ↑((toLocalizationWithZeroMap M S).sec z).2 * w' =
      g ↑((toLocalizationWithZeroMap M S).sec z).2 * v ↔
    g ((toLocalizationMap M S).sec z).1 * w + g ↑((toLocalizationMap M S).sec z).2 * w' =
      g ↑((toLocalizationMap M S).sec z).2 * v
tactic: erw [mul_comm, ← mul_assoc, mul_add_inv_left hg, mul_comm]
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
g : R →+* P
hg : ∀ (y : ↥M), IsUnit (g ↑y)
z : S
w w' v : P
⊢ ↑g.toMonoidWithZeroHom ((toLocalizationWithZeroMap M S).sec z).1 * w +
        g ↑((toLocalizationWithZeroMap M S).sec z).2 * w' =
      g ↑((toLocalizationWithZeroMap M S).sec z).2 * v ↔
    g ((toLocalizationMap M S).sec z).1 * w + g ↑((toLocalizationMap M S).sec z).2 * w' =
      g ↑((toLocalizationMap M S).sec z).2 * v
state_after: no goals
tactic: rfl
Theorem: Real.fourierIntegral_eq'
File: Mathlib/Analysis/Fourier/FourierTransform.lean

Proof steps:
state_before: E : Type u_1
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace ℂ E
V : Type u_2
inst✝⁹ : NormedAddCommGroup V
inst✝⁸ : InnerProductSpace ℝ V
inst✝⁷ : MeasurableSpace V
inst✝⁶ : BorelSpace V
inst✝⁵ : FiniteDimensional ℝ V
W : Type u_3
inst✝⁴ : NormedAddCommGroup W
inst✝³ : InnerProductSpace ℝ W
inst✝² : MeasurableSpace W
inst✝¹ : BorelSpace W
inst✝ : FiniteDimensional ℝ W
f : V → E
w : V
⊢ 𝓕 f w = ∫ (v : V), Complex.exp (↑(-2 * π * ⟪v, w⟫_ℝ) * Complex.I) • f v
state_after: no goals
tactic: simp_rw [fourierIntegral_eq, Submonoid.smul_def, Real.fourierChar_apply, mul_neg, neg_mul]
Theorem: NormedAddGroupHom.mem_ker
File: Mathlib/Analysis/Normed/Group/Hom.lean

Proof steps:
state_before: V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁴ : SeminormedAddCommGroup V
inst✝³ : SeminormedAddCommGroup W
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V₁ V₂
g : NormedAddGroupHom V₂ V₃
v : V₁
⊢ v ∈ f.ker ↔ f v = 0
state_after: no goals
tactic: erw [f.toAddMonoidHom.mem_ker, coe_toAddMonoidHom]
Theorem: Order.pred_le_pred_iff
File: Mathlib/Order/SuccPred/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : PredOrder α
a b : α
inst✝ : NoMinOrder α
⊢ pred a ≤ pred b ↔ a ≤ b
state_after: no goals
tactic: simp
Theorem: MeasureTheory.Integrable.add_measure
File: Mathlib/MeasureTheory/Function/L1Space.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
hμ : Integrable f μ
hν : Integrable f ν
⊢ Integrable f (μ + ν)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
hμ : Memℒp f 1 μ
hν : Memℒp f 1 ν
⊢ Memℒp f 1 (μ + ν)
tactic: simp_rw [← memℒp_one_iff_integrable] at hμ hν ⊢
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
hμ : Memℒp f 1 μ
hν : Memℒp f 1 ν
⊢ Memℒp f 1 (μ + ν)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
hμ : Memℒp f 1 μ
hν : Memℒp f 1 ν
⊢ eLpNorm f 1 (μ + ν) < ⊤
tactic: refine ⟨hμ.aestronglyMeasurable.add_measure hν.aestronglyMeasurable, ?_⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
hμ : Memℒp f 1 μ
hν : Memℒp f 1 ν
⊢ eLpNorm f 1 (μ + ν) < ⊤
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
hμ : Memℒp f 1 μ
hν : Memℒp f 1 ν
⊢ eLpNorm f 1 μ < ⊤ ∧ eLpNorm f 1 ν < ⊤
tactic: rw [eLpNorm_one_add_measure, ENNReal.add_lt_top]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
hμ : Memℒp f 1 μ
hν : Memℒp f 1 ν
⊢ eLpNorm f 1 μ < ⊤ ∧ eLpNorm f 1 ν < ⊤
state_after: no goals
tactic: exact ⟨hμ.eLpNorm_lt_top, hν.eLpNorm_lt_top⟩
Theorem: Relation.flip_comp
File: Mathlib/Logic/Relation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
⊢ flip (r ∘r p) = flip p ∘r flip r
state_after: case h.h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
c : γ
a : α
⊢ flip (r ∘r p) c a = (flip p ∘r flip r) c a
tactic: funext c a
state_before: case h.h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
c : γ
a : α
⊢ flip (r ∘r p) c a = (flip p ∘r flip r) c a
state_after: case h.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
c : γ
a : α
⊢ flip (r ∘r p) c a ↔ (flip p ∘r flip r) c a
tactic: apply propext
state_before: case h.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
c : γ
a : α
⊢ flip (r ∘r p) c a ↔ (flip p ∘r flip r) c a
state_after: case h.h.a.mp
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
c : γ
a : α
⊢ flip (r ∘r p) c a → (flip p ∘r flip r) c a

case h.h.a.mpr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
c : γ
a : α
⊢ (flip p ∘r flip r) c a → flip (r ∘r p) c a
tactic: constructor
Theorem: iteratedDeriv_const_mul
File: Mathlib/Analysis/Calculus/IteratedDeriv/Lemmas.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
R : Type u_3
inst✝³ : Semiring R
inst✝² : Module R F
inst✝¹ : SMulCommClass 𝕜 R F
inst✝ : ContinuousConstSMul R F
n✝ : ℕ
x : 𝕜
s : Set 𝕜
hx : x ∈ s
h✝ : UniqueDiffOn 𝕜 s
f✝ g : 𝕜 → F
n : ℕ
f : 𝕜 → 𝕜
h : ContDiff 𝕜 (↑n) f
c : 𝕜
⊢ (iteratedDeriv n fun x => f (c * x)) = fun x => c ^ n * iteratedDeriv n f (c * x)
state_after: no goals
tactic: simpa only [smul_eq_mul] using iteratedDeriv_const_smul h c
Theorem: cfcₙ_smul_id
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹⁷ : CommSemiring R
inst✝¹⁶ : Nontrivial R
inst✝¹⁵ : StarRing R
inst✝¹⁴ : MetricSpace R
inst✝¹³ : TopologicalSemiring R
inst✝¹² : ContinuousStar R
inst✝¹¹ : NonUnitalRing A
inst✝¹⁰ : StarRing A
inst✝⁹ : TopologicalSpace A
inst✝⁸ : Module R A
inst✝⁷ : IsScalarTower R A A
inst✝⁶ : SMulCommClass R A A
inst✝⁵ : NonUnitalContinuousFunctionalCalculus R p
f g : R → R
a✝ : A
hf : autoParam (ContinuousOn f (σₙ R a✝)) _auto✝
hf0 : autoParam (f 0 = 0) _auto✝
hg : autoParam (ContinuousOn g (σₙ R a✝)) _auto✝
hg0 : autoParam (g 0 = 0) _auto✝
ha✝ : autoParam (p a✝) _auto✝
S : Type u_3
inst✝⁴ : SMulZeroClass S R
inst✝³ : ContinuousConstSMul S R
inst✝² : SMulZeroClass S A
inst✝¹ : IsScalarTower S R A
inst✝ : IsScalarTower S R (R → R)
s : S
a : A
ha : autoParam (p a) _auto✝
⊢ cfcₙ (fun x => s • x) a = s • a
state_after: no goals
tactic: rw [cfcₙ_smul s _ a, cfcₙ_id' R a]
Theorem: CategoryTheory.ShortComplex.homologyMapIso'_inv
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁✝ : S₁.HomologyData
h₂✝ : S₂.HomologyData
e : S₁ ≅ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
⊢ homologyMap' e.hom h₁ h₂ ≫ homologyMap' e.inv h₂ h₁ = 𝟙 h₁.left.H
state_after: no goals
tactic: rw [← homologyMap'_comp, e.hom_inv_id, homologyMap'_id]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁✝ : S₁.HomologyData
h₂✝ : S₂.HomologyData
e : S₁ ≅ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
⊢ homologyMap' e.inv h₂ h₁ ≫ homologyMap' e.hom h₁ h₂ = 𝟙 h₂.left.H
state_after: no goals
tactic: rw [← homologyMap'_comp, e.inv_hom_id, homologyMap'_id]
Theorem: Polynomial.Monic.natSepDegree_eq_one_iff
File: Mathlib/FieldTheory/SeparableDegree.lean

Proof steps:
state_before: F : Type u
E : Type v
inst✝⁵ : Field F
inst✝⁴ : Field E
inst✝³ : Algebra F E
K : Type w
inst✝² : Field K
inst✝¹ : Algebra F K
f : F[X]
q : ℕ
inst✝ : ExpChar F q
hm : f.Monic
⊢ f.natSepDegree = 1 ↔ ∃ m n y, m ≠ 0 ∧ f = (X ^ q ^ n - C y) ^ m
state_after: case refine_1
F : Type u
E : Type v
inst✝⁵ : Field F
inst✝⁴ : Field E
inst✝³ : Algebra F E
K : Type w
inst✝² : Field K
inst✝¹ : Algebra F K
f : F[X]
q : ℕ
inst✝ : ExpChar F q
hm : f.Monic
h : f.natSepDegree = 1
⊢ ∃ m n y, m ≠ 0 ∧ f = (X ^ q ^ n - C y) ^ m

case refine_2
F : Type u
E : Type v
inst✝⁵ : Field F
inst✝⁴ : Field E
inst✝³ : Algebra F E
K : Type w
inst✝² : Field K
inst✝¹ : Algebra F K
f : F[X]
q : ℕ
inst✝ : ExpChar F q
hm✝ : f.Monic
x✝ : ∃ m n y, m ≠ 0 ∧ f = (X ^ q ^ n - C y) ^ m
m n : ℕ
y : F
hm : m ≠ 0
h : f = (X ^ q ^ n - C y) ^ m
⊢ f.natSepDegree = 1
tactic: refine ⟨fun h ↦ ?_, fun ⟨m, n, y, hm, h⟩ ↦ ?_⟩
state_before: case refine_2
F : Type u
E : Type v
inst✝⁵ : Field F
inst✝⁴ : Field E
inst✝³ : Algebra F E
K : Type w
inst✝² : Field K
inst✝¹ : Algebra F K
f : F[X]
q : ℕ
inst✝ : ExpChar F q
hm✝ : f.Monic
x✝ : ∃ m n y, m ≠ 0 ∧ f = (X ^ q ^ n - C y) ^ m
m n : ℕ
y : F
hm : m ≠ 0
h : f = (X ^ q ^ n - C y) ^ m
⊢ f.natSepDegree = 1
state_after: no goals
tactic: simp_rw [h, natSepDegree_pow, hm, ite_false, natSepDegree_X_pow_char_pow_sub_C]
Theorem: Path.truncate_one_one
File: Mathlib/Topology/Connected/PathConnected.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ : Path x y
a b : X
γ : Path a b
⊢ γ.extend (min 1 1) = b
state_after: no goals
tactic: rw [min_self, γ.extend_one]
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ : Path x y
a b : X
γ : Path a b
⊢ γ.truncate 1 1 = (refl b).cast ⋯ ⋯
state_after: no goals
tactic: convert γ.truncate_self 1
Theorem: Fin.predAbove_zero_succ
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
inst✝ : NeZero n
i : Fin n
⊢ predAbove 0 i.succ = i
state_after: no goals
tactic: rw [predAbove_succ_of_le _ _ (Fin.zero_le' _)]