ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ENNReal.toReal_add_le
File: Mathlib/Data/ENNReal/Real.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a = ⊤
⊢ (a + b).toReal ≤ a.toReal + b.toReal
state_after: no goals
tactic: simp only [ha, top_add, top_toReal, zero_add, toReal_nonneg]
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : ¬a = ⊤
hb : b = ⊤
⊢ (a + b).toReal ≤ a.toReal + b.toReal
state_after: no goals
tactic: simp only [hb, add_top, top_toReal, add_zero, toReal_nonneg]
Theorem: Prod.isCompl_iff
File: Mathlib/Order/Disjoint.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
inst✝¹ : BoundedOrder α
inst✝ : BoundedOrder β
x y : α × β
⊢ IsCompl x y ↔ IsCompl x.1 y.1 ∧ IsCompl x.2 y.2
state_after: no goals
tactic: simp_rw [isCompl_iff, Prod.disjoint_iff, Prod.codisjoint_iff, and_and_and_comm]
Theorem: ENNReal.rpow_sum_le_const_mul_sum_rpow
File: Mathlib/Analysis/MeanInequalities.lean

Proof steps:
state_before: ι : Type u
s : Finset ι
f g : ι → ℝ≥0∞
p q : ℝ
hp : 1 ≤ p
⊢ (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p
state_after: case inl
ι : Type u
s : Finset ι
f g : ι → ℝ≥0∞
p q : ℝ
hp✝ : 1 ≤ p
hp : 1 = p
⊢ (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p

case inr
ι : Type u
s : Finset ι
f g : ι → ℝ≥0∞
p q : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
⊢ (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p
tactic: cases' eq_or_lt_of_le hp with hp hp
state_before: case inr
ι : Type u
s : Finset ι
f g : ι → ℝ≥0∞
p q : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
⊢ (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p
state_after: case inr
ι : Type u
s : Finset ι
f g : ι → ℝ≥0∞
p q✝ : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
q : ℝ := p / (p - 1)
⊢ (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p
tactic: let q : ℝ := p / (p - 1)
state_before: case inr
ι : Type u
s : Finset ι
f g : ι → ℝ≥0∞
p q✝ : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
q : ℝ := p / (p - 1)
⊢ (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p
state_after: case inr
ι : Type u
s : Finset ι
f g : ι → ℝ≥0∞
p q✝ : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
q : ℝ := p / (p - 1)
hpq : p.IsConjExponent q
⊢ (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p
tactic: have hpq : p.IsConjExponent q := .conjExponent hp
state_before: case inr
ι : Type u
s : Finset ι
f g : ι → ℝ≥0∞
p q✝ : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
q : ℝ := p / (p - 1)
hpq : p.IsConjExponent q
⊢ (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p
state_after: case inr
ι : Type u
s : Finset ι
f g : ι → ℝ≥0∞
p q✝ : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
q : ℝ := p / (p - 1)
hpq : p.IsConjExponent q
hp₁ : 1 / p * p = 1
⊢ (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p
tactic: have hp₁ : 1 / p * p = 1 := one_div_mul_cancel hpq.ne_zero
state_before: case inr
ι : Type u
s : Finset ι
f g : ι → ℝ≥0∞
p q✝ : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
q : ℝ := p / (p - 1)
hpq : p.IsConjExponent q
hp₁ : 1 / p * p = 1
⊢ (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p
state_after: case inr
ι : Type u
s : Finset ι
f g : ι → ℝ≥0∞
p q✝ : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
q : ℝ := p / (p - 1)
hpq : p.IsConjExponent q
hp₁ : 1 / p * p = 1
hq : 1 / q * p = p - 1
⊢ (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p
tactic: have hq : 1 / q * p = p - 1 := by
    rw [← hpq.div_conj_eq_sub_one]
    ring
state_before: case inr
ι : Type u
s : Finset ι
f g : ι → ℝ≥0∞
p q✝ : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
q : ℝ := p / (p - 1)
hpq : p.IsConjExponent q
hp₁ : 1 / p * p = 1
hq : 1 / q * p = p - 1
⊢ (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p
state_after: no goals
tactic: simpa only [ENNReal.mul_rpow_of_nonneg _ _ hpq.nonneg, ← ENNReal.rpow_mul, hp₁, hq, coe_one,
    one_mul, one_rpow, rpow_one, Pi.one_apply, sum_const, Nat.smul_one_eq_cast] using
    ENNReal.rpow_le_rpow (inner_le_Lp_mul_Lq s 1 f hpq.symm) hpq.nonneg
Theorem: CategoryTheory.Subobject.le_inf
File: Mathlib/CategoryTheory/Subobject/Lattice.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
A : C
h f g : Subobject A
⊢ ∀ (a₁ a₂ a₃ : MonoOver A),
    Quotient.mk'' a₁ ≤ Quotient.mk'' a₂ →
      Quotient.mk'' a₁ ≤ Quotient.mk'' a₃ → Quotient.mk'' a₁ ≤ (inf.obj (Quotient.mk'' a₂)).obj (Quotient.mk'' a₃)
state_after: case intro.intro
C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
A : C
h✝ f✝ g✝ : Subobject A
f g h : MonoOver A
k : f ⟶ g
l : f ⟶ h
⊢ Quotient.mk'' f ≤ (inf.obj (Quotient.mk'' g)).obj (Quotient.mk'' h)
tactic: rintro f g h ⟨k⟩ ⟨l⟩
state_before: case intro.intro
C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
A : C
h✝ f✝ g✝ : Subobject A
f g h : MonoOver A
k : f ⟶ g
l : f ⟶ h
⊢ Quotient.mk'' f ≤ (inf.obj (Quotient.mk'' g)).obj (Quotient.mk'' h)
state_after: no goals
tactic: exact ⟨MonoOver.leInf _ _ _ k l⟩
Theorem: Int.ceil_sub_nat
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
n : ℕ
⊢ ⌈a - ↑n⌉ = ⌈a⌉ - ↑n
state_after: case h.e'_2
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
n : ℕ
⊢ ⌈a - ↑n⌉ = ⌈a - ↑↑n⌉
tactic: convert ceil_sub_int a n using 1
state_before: case h.e'_2
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
n : ℕ
⊢ ⌈a - ↑n⌉ = ⌈a - ↑↑n⌉
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Limits.Sigma.map_id
File: Mathlib/CategoryTheory/Limits/Shapes/Products.lean

Proof steps:
state_before: β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
f : α → C
inst✝ : HasCoproduct f
⊢ (map fun a => 𝟙 (f a)) = 𝟙 (∐ f)
state_after: case h
β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
f : α → C
inst✝ : HasCoproduct f
b✝ : α
⊢ (ι f b✝ ≫ map fun a => 𝟙 (f a)) = ι f b✝ ≫ 𝟙 (∐ f)
tactic: ext
state_before: case h
β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
f : α → C
inst✝ : HasCoproduct f
b✝ : α
⊢ (ι f b✝ ≫ map fun a => 𝟙 (f a)) = ι f b✝ ≫ 𝟙 (∐ f)
state_after: no goals
tactic: simp
Theorem: Primrec.bind_decode_iff
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
f : α → β → Option σ
h : Primrec₂ fun a n => (decode n).bind (f a)
⊢ Primrec₂ f
state_after: no goals
tactic: simpa [encodek] using h.comp fst ((@Primrec.encode β _).comp snd)
Theorem: FractionalIdeal.mul_def
File: Mathlib/RingTheory/FractionalIdeal/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I J : FractionalIdeal S P
⊢ I * J = ⟨↑I * ↑J, ⋯⟩
state_after: no goals
tactic: simp only [← mul_eq_mul, mul]
Theorem: CategoryTheory.cancel_epi_id
File: Mathlib/CategoryTheory/Category/Basic.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
inst✝ : Epi f
h : Y ⟶ Y
⊢ f ≫ h = f ↔ h = 𝟙 Y
state_after: case h.e'_1.h.e'_3.h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
inst✝ : Epi f
h : Y ⟶ Y
⊢ f = f ≫ 𝟙 Y
tactic: convert cancel_epi f
state_before: case h.e'_1.h.e'_3.h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
inst✝ : Epi f
h : Y ⟶ Y
⊢ f = f ≫ 𝟙 Y
state_after: no goals
tactic: simp
Theorem: LinearMap.BilinMap.polar_toQuadraticMap
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

Proof steps:
state_before: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
A : Type u_7
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup N
inst✝¹ : Module R M
inst✝ : Module R N
B : BilinMap R M N
x y : M
⊢ polar (⇑B.toQuadraticMap) x y = (B x) y + (B y) x
state_after: no goals
tactic: simp only [polar, toQuadraticMap_apply, map_add, add_apply, add_assoc, add_comm (B y x) _,
    add_sub_cancel_left, sub_eq_add_neg _ (B y y), add_neg_cancel_left]
Theorem: Ordinal.CNF_sorted
File: Mathlib/SetTheory/Ordinal/CantorNormalForm.lean

Proof steps:
state_before: b o : Ordinal.{u_1}
⊢ Sorted (fun x x_1 => x > x_1) (map Prod.fst (CNF b o))
state_after: case refine_1
b o : Ordinal.{u_1}
⊢ Sorted (fun x x_1 => x > x_1) (map Prod.fst (CNF b 0))

case refine_2
b o✝ o : Ordinal.{u_1}
ho : o ≠ 0
IH : Sorted (fun x x_1 => x > x_1) (map Prod.fst (CNF b (o % b ^ log b o)))
⊢ Sorted (fun x x_1 => x > x_1) (map Prod.fst (CNF b o))
tactic: refine CNFRec b ?_ (fun o ho IH ↦ ?_) o
Theorem: one_nsmul
File: Mathlib/Algebra/Group/Defs.lean

Proof steps:
state_before: G : Type u_1
M : Type u_2
inst✝ : Monoid M
a✝ b c : M
m n : ℕ
a : M
⊢ a ^ 1 = a
state_after: no goals
tactic: rw [pow_succ, pow_zero, one_mul]
Theorem: CategoryTheory.Localization.functor_additive
File: Mathlib/CategoryTheory/Localization/CalculusOfFractions/Preadditive.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{u_4, u_2} D
inst✝² : Preadditive C
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
this : Preadditive D := preadditive L W
⊢ ∀ {X Y : C} {f g : X ⟶ Y}, L.map (f + g) = L.map f + L.map g
state_after: no goals
tactic: apply Preadditive.map_add
Theorem: bihimp_self
File: Mathlib/Order/SymmDiff.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedHeytingAlgebra α
a b c d : α
⊢ a ⇔ a = ⊤
state_after: no goals
tactic: rw [bihimp, inf_idem, himp_self]
Theorem: IsIntegralCurve.comp_add
File: Mathlib/Geometry/Manifold/IntegralCurve.lean

Proof steps:
state_before: E : Type u_1
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
H : Type u_2
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
γ γ' : ℝ → M
v : (x : M) → TangentSpace I x
s s' : Set ℝ
t₀ : ℝ
hγ : IsIntegralCurve γ v
dt : ℝ
⊢ IsIntegralCurve (γ ∘ fun x => x + dt) v
state_after: E : Type u_1
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
H : Type u_2
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
γ γ' : ℝ → M
v : (x : M) → TangentSpace I x
s s' : Set ℝ
t₀ : ℝ
hγ : IsIntegralCurveOn γ v univ
dt : ℝ
⊢ IsIntegralCurveOn (γ ∘ fun x => x + dt) v univ
tactic: rw [isIntegralCurve_iff_isIntegralCurveOn] at *
state_before: E : Type u_1
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
H : Type u_2
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
γ γ' : ℝ → M
v : (x : M) → TangentSpace I x
s s' : Set ℝ
t₀ : ℝ
hγ : IsIntegralCurveOn γ v univ
dt : ℝ
⊢ IsIntegralCurveOn (γ ∘ fun x => x + dt) v univ
state_after: no goals
tactic: exact hγ.comp_add _
Theorem: Rat.toNNRat_le_toNNRat_iff
File: Mathlib/Data/NNRat/Defs.lean

Proof steps:
state_before: p q : ℚ
hp : 0 ≤ p
⊢ q.toNNRat ≤ p.toNNRat ↔ q ≤ p
state_after: no goals
tactic: simp [← coe_le_coe, toNNRat, hp]
Theorem: LocallyConstant.congrRight_symm_apply
File: Mathlib/Topology/LocallyConstant/Basic.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
inst✝ : TopologicalSpace X
e : Y ≃ Z
⊢ Function.LeftInverse (map ⇑e.symm) (map ⇑e)
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
inst✝ : TopologicalSpace X
e : Y ≃ Z
x✝ : LocallyConstant X Y
⊢ map (⇑e.symm) (map (⇑e) x✝) = x✝
tactic: intro
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
inst✝ : TopologicalSpace X
e : Y ≃ Z
x✝ : LocallyConstant X Y
⊢ map (⇑e.symm) (map (⇑e) x✝) = x✝
state_after: case h
X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
inst✝ : TopologicalSpace X
e : Y ≃ Z
x✝¹ : LocallyConstant X Y
x✝ : X
⊢ (map (⇑e.symm) (map (⇑e) x✝¹)) x✝ = x✝¹ x✝
tactic: ext
state_before: case h
X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
inst✝ : TopologicalSpace X
e : Y ≃ Z
x✝¹ : LocallyConstant X Y
x✝ : X
⊢ (map (⇑e.symm) (map (⇑e) x✝¹)) x✝ = x✝¹ x✝
state_after: no goals
tactic: simp
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
inst✝ : TopologicalSpace X
e : Y ≃ Z
⊢ Function.RightInverse (map ⇑e.symm) (map ⇑e)
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
inst✝ : TopologicalSpace X
e : Y ≃ Z
x✝ : LocallyConstant X Z
⊢ map (⇑e) (map (⇑e.symm) x✝) = x✝
tactic: intro
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
inst✝ : TopologicalSpace X
e : Y ≃ Z
x✝ : LocallyConstant X Z
⊢ map (⇑e) (map (⇑e.symm) x✝) = x✝
state_after: case h
X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
inst✝ : TopologicalSpace X
e : Y ≃ Z
x✝¹ : LocallyConstant X Z
x✝ : X
⊢ (map (⇑e) (map (⇑e.symm) x✝¹)) x✝ = x✝¹ x✝
tactic: ext
state_before: case h
X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
inst✝ : TopologicalSpace X
e : Y ≃ Z
x✝¹ : LocallyConstant X Z
x✝ : X
⊢ (map (⇑e) (map (⇑e.symm) x✝¹)) x✝ = x✝¹ x✝
state_after: no goals
tactic: simp
Theorem: ContinuousLinearMap.opNorm_comp_le
File: Mathlib/Analysis/NormedSpace/OperatorNorm/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹⁷ : SeminormedAddCommGroup E
inst✝¹⁶ : SeminormedAddCommGroup Eₗ
inst✝¹⁵ : SeminormedAddCommGroup F
inst✝¹⁴ : SeminormedAddCommGroup Fₗ
inst✝¹³ : SeminormedAddCommGroup G
inst✝¹² : SeminormedAddCommGroup Gₗ
inst✝¹¹ : NontriviallyNormedField 𝕜
inst✝¹⁰ : NontriviallyNormedField 𝕜₂
inst✝⁹ : NontriviallyNormedField 𝕜₃
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : NormedSpace 𝕜 Eₗ
inst✝⁶ : NormedSpace 𝕜₂ F
inst✝⁵ : NormedSpace 𝕜 Fₗ
inst✝⁴ : NormedSpace 𝕜₃ G
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝² : FunLike 𝓕 E F
inst✝¹ : RingHomIsometric σ₁₂
inst✝ : RingHomIsometric σ₂₃
f✝ g : E →SL[σ₁₂] F
h : F →SL[σ₂₃] G
x✝ : E
f : E →SL[σ₁₂] F
x : E
⊢ ‖(h.comp f) x‖ ≤ ‖h‖ * ‖f‖ * ‖x‖
state_after: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹⁷ : SeminormedAddCommGroup E
inst✝¹⁶ : SeminormedAddCommGroup Eₗ
inst✝¹⁵ : SeminormedAddCommGroup F
inst✝¹⁴ : SeminormedAddCommGroup Fₗ
inst✝¹³ : SeminormedAddCommGroup G
inst✝¹² : SeminormedAddCommGroup Gₗ
inst✝¹¹ : NontriviallyNormedField 𝕜
inst✝¹⁰ : NontriviallyNormedField 𝕜₂
inst✝⁹ : NontriviallyNormedField 𝕜₃
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : NormedSpace 𝕜 Eₗ
inst✝⁶ : NormedSpace 𝕜₂ F
inst✝⁵ : NormedSpace 𝕜 Fₗ
inst✝⁴ : NormedSpace 𝕜₃ G
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝² : FunLike 𝓕 E F
inst✝¹ : RingHomIsometric σ₁₂
inst✝ : RingHomIsometric σ₂₃
f✝ g : E →SL[σ₁₂] F
h : F →SL[σ₂₃] G
x✝ : E
f : E →SL[σ₁₂] F
x : E
⊢ ‖(h.comp f) x‖ ≤ ‖h‖ * (‖f‖ * ‖x‖)
tactic: rw [mul_assoc]
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹⁷ : SeminormedAddCommGroup E
inst✝¹⁶ : SeminormedAddCommGroup Eₗ
inst✝¹⁵ : SeminormedAddCommGroup F
inst✝¹⁴ : SeminormedAddCommGroup Fₗ
inst✝¹³ : SeminormedAddCommGroup G
inst✝¹² : SeminormedAddCommGroup Gₗ
inst✝¹¹ : NontriviallyNormedField 𝕜
inst✝¹⁰ : NontriviallyNormedField 𝕜₂
inst✝⁹ : NontriviallyNormedField 𝕜₃
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : NormedSpace 𝕜 Eₗ
inst✝⁶ : NormedSpace 𝕜₂ F
inst✝⁵ : NormedSpace 𝕜 Fₗ
inst✝⁴ : NormedSpace 𝕜₃ G
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝² : FunLike 𝓕 E F
inst✝¹ : RingHomIsometric σ₁₂
inst✝ : RingHomIsometric σ₂₃
f✝ g : E →SL[σ₁₂] F
h : F →SL[σ₂₃] G
x✝ : E
f : E →SL[σ₁₂] F
x : E
⊢ ‖(h.comp f) x‖ ≤ ‖h‖ * (‖f‖ * ‖x‖)
state_after: no goals
tactic: exact h.le_opNorm_of_le (f.le_opNorm x)
Theorem: Ideal.Polynomial.isMaximal_comap_C_of_isJacobson
File: Mathlib/RingTheory/Jacobson.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal R[X]
hP : P.IsMaximal
⊢ (comap C P).IsMaximal
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal R[X]
hP : P.IsMaximal
⊢ (comap ((Quotient.mk P).comp C) ⊥).IsMaximal
tactic: rw [← @mk_ker _ _ P, RingHom.ker_eq_comap_bot, comap_comap]
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal R[X]
hP : P.IsMaximal
⊢ (comap ((Quotient.mk P).comp C) ⊥).IsMaximal
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal R[X]
hP : P.IsMaximal
this : ⊥.IsMaximal
⊢ (comap ((Quotient.mk P).comp C) ⊥).IsMaximal
tactic: have := (bot_quotient_isMaximal_iff _).mpr hP
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P : Ideal R[X]
hP : P.IsMaximal
this : ⊥.IsMaximal
⊢ (comap ((Quotient.mk P).comp C) ⊥).IsMaximal
state_after: no goals
tactic: exact isMaximal_comap_of_isIntegral_of_isMaximal' _ (quotient_mk_comp_C_isIntegral_of_jacobson P)
    ⊥
Theorem: MeasureTheory.ComplexMeasure.absolutelyContinuous_ennreal_iff
File: Mathlib/MeasureTheory/Measure/Complex.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
c : ComplexMeasure α
μ : VectorMeasure α ℝ≥0∞
⊢ c ≪ᵥ μ ↔ re c ≪ᵥ μ ∧ im c ≪ᵥ μ
state_after: case mp
α : Type u_1
β : Type u_2
m : MeasurableSpace α
c : ComplexMeasure α
μ : VectorMeasure α ℝ≥0∞
h : c ≪ᵥ μ
⊢ re c ≪ᵥ μ ∧ im c ≪ᵥ μ

case mpr
α : Type u_1
β : Type u_2
m : MeasurableSpace α
c : ComplexMeasure α
μ : VectorMeasure α ℝ≥0∞
h : re c ≪ᵥ μ ∧ im c ≪ᵥ μ
⊢ c ≪ᵥ μ
tactic: constructor <;> intro h
Theorem: Set.preimage_eq_preimage
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
s t : Set α
f : β → α
hf : Surjective f
eq : f ⁻¹' s = f ⁻¹' t
⊢ s = t
state_after: no goals
tactic: rw [← image_preimage_eq s hf, ← image_preimage_eq t hf, eq]
Theorem: Associates.factors_mono
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
s t : Associates α
d : Associates α
eq : t = s * d
⊢ s.factors ≤ t.factors
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
s t : Associates α
d : Associates α
eq : t = s * d
⊢ s.factors ≤ s.factors + d.factors
tactic: rw [eq, factors_mul]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
s t : Associates α
d : Associates α
eq : t = s * d
⊢ s.factors ≤ s.factors + d.factors
state_after: no goals
tactic: exact le_add_of_nonneg_right bot_le
Theorem: fderivWithin_zero_of_isolated
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 : 𝓝[s \ {x}] x = ⊥
⊢ fderivWithin 𝕜 f s x = 0
state_after: no goals
tactic: rw [fderivWithin, if_pos h]
Theorem: mul_gauge_le_norm
File: Mathlib/Analysis/Convex/Gauge.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x : E
hs : ball 0 r ⊆ s
⊢ r * gauge s x ≤ ‖x‖
state_after: case inl
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x : E
hs : ball 0 r ⊆ s
hr : r ≤ 0
⊢ r * gauge s x ≤ ‖x‖

case inr
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x : E
hs : ball 0 r ⊆ s
hr : 0 < r
⊢ r * gauge s x ≤ ‖x‖
tactic: obtain hr | hr := le_or_lt r 0
state_before: case inr
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x : E
hs : ball 0 r ⊆ s
hr : 0 < r
⊢ r * gauge s x ≤ ‖x‖
state_after: case inr
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x : E
hs : ball 0 r ⊆ s
hr : 0 < r
⊢ gauge s x ≤ gauge (ball 0 r) x
tactic: rw [mul_comm, ← le_div_iff hr, ← gauge_ball hr.le]
state_before: case inr
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x : E
hs : ball 0 r ⊆ s
hr : 0 < r
⊢ gauge s x ≤ gauge (ball 0 r) x
state_after: no goals
tactic: exact gauge_mono (absorbent_ball_zero hr) hs x
Theorem: eq_mp_bijective
File: Mathlib/Logic/Function/Basic.lean

Proof steps:
state_before: α✝ : Sort u_1
β✝ : Sort u_2
α β : Sort u_3
h : α = β
⊢ Bijective h.mp
state_after: case refl
α✝ : Sort u_1
β : Sort u_2
α : Sort u_3
⊢ Bijective ⋯.mp
tactic: cases h
state_before: case refl
α✝ : Sort u_1
β : Sort u_2
α : Sort u_3
⊢ Bijective ⋯.mp
state_after: no goals
tactic: exact ⟨fun _ _ ↦ id, fun x ↦ ⟨x, rfl⟩⟩
Theorem: Polynomial.coeff_iterate_derivative
File: Mathlib/Algebra/Polynomial/Derivative.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
k : ℕ
p : R[X]
m : ℕ
⊢ ((⇑derivative)^[k] p).coeff m = (m + k).descFactorial k • p.coeff (m + k)
state_after: no goals
tactic: induction k generalizing m with
  | zero => simp
  | succ k ih =>
      calc
        (derivative^[k + 1] p).coeff m
        _ = Nat.descFactorial (Nat.succ (m + k)) k • p.coeff (m + k.succ) * (m + 1) := by
          rw [Function.iterate_succ_apply', coeff_derivative, ih m.succ, Nat.succ_add, Nat.add_succ]
        _ = ((m + 1) * Nat.descFactorial (Nat.succ (m + k)) k) • p.coeff (m + k.succ) := by
          rw [← Nat.cast_add_one, ← nsmul_eq_mul', smul_smul]
        _ = Nat.descFactorial (m.succ + k) k.succ • p.coeff (m + k.succ) := by
          rw [← Nat.succ_add, Nat.descFactorial_succ, add_tsub_cancel_right]
        _ = Nat.descFactorial (m + k.succ) k.succ • p.coeff (m + k.succ) := by
          rw [Nat.succ_add_eq_add_succ]
Theorem: Orthonormal.exists_hilbertBasis_extension
File: Mathlib/Analysis/InnerProductSpace/l2Space.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
inst✝⁴ : RCLike 𝕜
E : Type u_3
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type u_4
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
v : ι → E
hv : Orthonormal 𝕜 v
s : Set E
hs : Orthonormal 𝕜 Subtype.val
w : Set E
hws : w ⊇ s
hw_ortho : Orthonormal 𝕜 Subtype.val
hw_max : ∀ u ⊇ w, Orthonormal 𝕜 Subtype.val → u = w
⊢ (span 𝕜 (Set.range Subtype.val))ᗮ = ⊥
state_after: no goals
tactic: simpa only [Subtype.range_coe_subtype, Set.setOf_mem_eq,
      maximal_orthonormal_iff_orthogonalComplement_eq_bot hw_ortho] using hw_max