ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: PerfectPairing.toDualLeft_of_toDualRight_symm
File: Mathlib/LinearAlgebra/PerfectPairing.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
p : PerfectPairing R M N
x : M
f : Dual R M
⊢ (p.toDualLeft x) (p.toDualRight.symm f) = f x
state_after: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
p : PerfectPairing R M N
x : M
f : Dual R M
⊢ (p x) (p.toDualRight.symm f) = f x
tactic: rw [@toDualLeft_apply]
state_before: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
p : PerfectPairing R M N
x : M
f : Dual R M
⊢ (p x) (p.toDualRight.symm f) = f x
state_after: no goals
tactic: exact apply_apply_toDualRight_symm p x f
Theorem: Basis.det_reindex_symm
File: Mathlib/LinearAlgebra/Determinant.lean

Proof steps:
state_before: R : Type u_1
inst✝¹⁰ : CommRing R
M : Type u_2
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
M' : Type u_3
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
ι : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Fintype ι
e✝ : Basis ι R M
A : Type u_5
inst✝³ : CommRing A
inst✝² : Module A M
ι' : Type u_6
inst✝¹ : Fintype ι'
inst✝ : DecidableEq ι'
b : Basis ι R M
v : ι → M
e : ι' ≃ ι
⊢ (b.reindex e.symm).det (v ∘ ⇑e) = b.det v
state_after: no goals
tactic: rw [Basis.det_reindex, Function.comp.assoc, e.self_comp_symm, Function.comp_id]
Theorem: Real.pi_gt_314
File: Mathlib/Data/Real/Pi/Bounds.lean

Proof steps:
state_before: ⊢ 3.14 < π
state_after: no goals
tactic: pi_lower_bound [99 / 70, 874 / 473, 1940 / 989, 1447 / 727]
Theorem: Codisjoint.eq_iff
File: Mathlib/Order/Disjoint.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : OrderTop α
a b c d : α
hab : Codisjoint a b
⊢ a = b ↔ a = ⊤ ∧ b = ⊤
state_after: no goals
tactic: aesop
Theorem: List.IsPrefix.ne_nil
File: Mathlib/Data/List/Infix.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
x y : List α
h : x <+: y
hx : x ≠ []
⊢ y ≠ []
state_after: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
x : List α
hx : x ≠ []
h : x <+: []
⊢ False
tactic: rintro rfl
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
x : List α
hx : x ≠ []
h : x <+: []
⊢ False
state_after: no goals
tactic: exact hx <| List.prefix_nil.mp h
Theorem: Set.image_sub_const_Ioc
File: Mathlib/Data/Set/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => x - a) '' Ioc b c = Ioc (b - a) (c - a)
state_after: no goals
tactic: simp [sub_eq_neg_add]
Theorem: Real.hasDerivAt_negMulLog
File: Mathlib/Analysis/SpecialFunctions/Log/NegMulLog.lean

Proof steps:
state_before: x : ℝ
hx : x ≠ 0
⊢ HasDerivAt negMulLog (-log x - 1) x
state_after: x : ℝ
hx : x ≠ 0
⊢ DifferentiableAt ℝ negMulLog x
tactic: rw [← deriv_negMulLog hx, hasDerivAt_deriv_iff]
state_before: x : ℝ
hx : x ≠ 0
⊢ DifferentiableAt ℝ negMulLog x
state_after: x : ℝ
hx : x ≠ 0
⊢ {0}ᶜ ∈ 𝓝 x
tactic: refine DifferentiableOn.differentiableAt differentiableOn_negMulLog ?_
state_before: x : ℝ
hx : x ≠ 0
⊢ {0}ᶜ ∈ 𝓝 x
state_after: no goals
tactic: simp [hx]
Theorem: WeierstrassCurve.baseChange_Ψ₂Sq
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

Proof steps:
state_before: R : Type r
S : Type s
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing S
W : WeierstrassCurve R
inst✝⁸ : Algebra R S
A : Type u
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : Algebra S A
inst✝⁴ : IsScalarTower R S A
B : Type v
inst✝³ : CommRing B
inst✝² : Algebra R B
inst✝¹ : Algebra S B
inst✝ : IsScalarTower R S B
f : A →ₐ[S] B
⊢ (W.baseChange B).Ψ₂Sq = Polynomial.map (↑f) (W.baseChange A).Ψ₂Sq
state_after: no goals
tactic: rw [← map_Ψ₂Sq, map_baseChange]
Theorem: MeasureTheory.JordanDecomposition.real_smul_posPart_nonneg
File: Mathlib/MeasureTheory/Decomposition/Jordan.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
j : JordanDecomposition α
r : ℝ
hr : 0 ≤ r
⊢ (r • j).posPart = r.toNNReal • j.posPart
state_after: no goals
tactic: rw [real_smul_def, ← smul_posPart, if_pos hr]
Theorem: CategoryTheory.Limits.spanExt_hom_app_zero
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/Cospan.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ (spanExt iX iY iZ wf wg).hom.app WalkingSpan.zero = iX.hom
state_after: no goals
tactic: dsimp [spanExt]
Theorem: Grp.SurjectiveOfEpiAuxs.τ_symm_apply_fromCoset
File: Mathlib/Algebra/Category/Grp/EpiMono.lean

Proof steps:
state_before: A B : Grp
f : A ⟶ B
⊢ (Equiv.symm τ) (fromCoset ⟨↑(MonoidHom.range f), ⋯⟩) = ∞
state_after: no goals
tactic: rw [tau, Equiv.symm_swap, Equiv.swap_apply_left]
Theorem: Fin.predAbove_last_castSucc
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
i : Fin (n + 1)
⊢ (last n).predAbove i.castSucc = i
state_after: no goals
tactic: rw [predAbove_of_le_castSucc _ _ (castSucc_le_castSucc_iff.mpr (le_last _)), castPred_castSucc]
Theorem: SetTheory.PGame.rightMoves_mul_cases
File: Mathlib/SetTheory/Game/Basic.lean

Proof steps:
state_before: x y : PGame
k : (x * y).RightMoves
P : (x * y).RightMoves → Prop
hl : ∀ (ix : x.LeftMoves) (jy : y.RightMoves), P (toRightMovesMul (Sum.inl (ix, jy)))
hr : ∀ (jx : x.RightMoves) (iy : y.LeftMoves), P (toRightMovesMul (Sum.inr (jx, iy)))
⊢ P k
state_after: x y : PGame
k : (x * y).RightMoves
P : (x * y).RightMoves → Prop
hl : ∀ (ix : x.LeftMoves) (jy : y.RightMoves), P (toRightMovesMul (Sum.inl (ix, jy)))
hr : ∀ (jx : x.RightMoves) (iy : y.LeftMoves), P (toRightMovesMul (Sum.inr (jx, iy)))
⊢ P (toRightMovesMul (toRightMovesMul.symm k))
tactic: rw [← toRightMovesMul.apply_symm_apply k]
state_before: x y : PGame
k : (x * y).RightMoves
P : (x * y).RightMoves → Prop
hl : ∀ (ix : x.LeftMoves) (jy : y.RightMoves), P (toRightMovesMul (Sum.inl (ix, jy)))
hr : ∀ (jx : x.RightMoves) (iy : y.LeftMoves), P (toRightMovesMul (Sum.inr (jx, iy)))
⊢ P (toRightMovesMul (toRightMovesMul.symm k))
state_after: case inl.mk
x y : PGame
k : (x * y).RightMoves
P : (x * y).RightMoves → Prop
hl : ∀ (ix : x.LeftMoves) (jy : y.RightMoves), P (toRightMovesMul (Sum.inl (ix, jy)))
hr : ∀ (jx : x.RightMoves) (iy : y.LeftMoves), P (toRightMovesMul (Sum.inr (jx, iy)))
ix : x.LeftMoves
iy : y.RightMoves
⊢ P (toRightMovesMul (Sum.inl (ix, iy)))

case inr.mk
x y : PGame
k : (x * y).RightMoves
P : (x * y).RightMoves → Prop
hl : ∀ (ix : x.LeftMoves) (jy : y.RightMoves), P (toRightMovesMul (Sum.inl (ix, jy)))
hr : ∀ (jx : x.RightMoves) (iy : y.LeftMoves), P (toRightMovesMul (Sum.inr (jx, iy)))
jx : x.RightMoves
jy : y.LeftMoves
⊢ P (toRightMovesMul (Sum.inr (jx, jy)))
tactic: rcases toRightMovesMul.symm k with (⟨ix, iy⟩ | ⟨jx, jy⟩)
Theorem: IsometryEquiv.completeSpace_iff
File: Mathlib/Topology/MetricSpace/Isometry.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
e : α ≃ᵢ β
⊢ CompleteSpace α ↔ CompleteSpace β
state_after: no goals
tactic: simp only [completeSpace_iff_isComplete_univ, ← e.range_eq_univ, ← image_univ,
    isComplete_image_iff e.isometry.uniformInducing]
Theorem: CategoryTheory.Limits.Concrete.widePushout_exists_rep'
File: Mathlib/CategoryTheory/Limits/Shapes/ConcreteCategory.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
B : C
α : Type v
inst✝² : Nonempty α
X : α → C
f : (j : α) → B ⟶ X j
inst✝¹ : HasWidePushout B X f
inst✝ : PreservesColimit (wideSpan B X f) (forget C)
x : (forget C).obj (widePushout B X f)
⊢ ∃ i y, (ι f i) y = x
state_after: case inl.intro
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
B : C
α : Type v
inst✝² : Nonempty α
X : α → C
f : (j : α) → B ⟶ X j
inst✝¹ : HasWidePushout B X f
inst✝ : PreservesColimit (wideSpan B X f) (forget C)
y : (forget C).obj B
⊢ ∃ i y_1, (ι f i) y_1 = (head f) y

case inr.intro.intro
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
B : C
α : Type v
inst✝² : Nonempty α
X : α → C
f : (j : α) → B ⟶ X j
inst✝¹ : HasWidePushout B X f
inst✝ : PreservesColimit (wideSpan B X f) (forget C)
i : α
y : (forget C).obj (X i)
⊢ ∃ i_1 y_1, (ι f i_1) y_1 = (ι f i) y
tactic: rcases Concrete.widePushout_exists_rep f x with (⟨y, rfl⟩ | ⟨i, y, rfl⟩)
Theorem: AddCommGrp.kernelIsoKer_hom_comp_subtype
File: Mathlib/Algebra/Category/Grp/Limits.lean

Proof steps:
state_before: J : Type v
inst✝ : Category.{w, v} J
G H : AddCommGrp
f : G ⟶ H
⊢ (kernelIsoKer f).hom ≫ (AddMonoidHom.ker f).subtype = kernel.ι f
state_after: case w
J : Type v
inst✝ : Category.{w, v} J
G H : AddCommGrp
f : G ⟶ H
x✝ : ↑(kernel f)
⊢ ((kernelIsoKer f).hom ≫ (AddMonoidHom.ker f).subtype) x✝ = (kernel.ι f) x✝
tactic: ext
state_before: case w
J : Type v
inst✝ : Category.{w, v} J
G H : AddCommGrp
f : G ⟶ H
x✝ : ↑(kernel f)
⊢ ((kernelIsoKer f).hom ≫ (AddMonoidHom.ker f).subtype) x✝ = (kernel.ι f) x✝
state_after: no goals
tactic: rfl
Theorem: AddGrp.uliftFunctor_map
File: Mathlib/Algebra/Category/Grp/Basic.lean

Proof steps:
state_before: X : Grp
⊢ { obj := fun X => of (ULift.{v, u} ↑X),
          map := fun {X Y} f =>
            ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.map
      (𝟙 X) =
    𝟙
      ({ obj := fun X => of (ULift.{v, u} ↑X),
            map := fun {X Y} f =>
              ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.obj
        X)
state_after: no goals
tactic: rfl
state_before: X Y Z : Grp
f : X ⟶ Y
g : Y ⟶ Z
⊢ { obj := fun X => of (ULift.{v, u} ↑X),
          map := fun {X Y} f =>
            ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.map
      (f ≫ g) =
    { obj := fun X => of (ULift.{v, u} ↑X),
            map := fun {X Y} f =>
              ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.map
        f ≫
      { obj := fun X => of (ULift.{v, u} ↑X),
            map := fun {X Y} f =>
              ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.map
        g
state_after: no goals
tactic: rfl
Theorem: MvQPF.Fix.dest_mk
File: Mathlib/Data/QPF/Multivariate/Constructions/Fix.lean

Proof steps:
state_before: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
x : F (α ::: Fix F α)
⊢ (mk x).dest = x
state_after: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
x : F (α ::: Fix F α)
⊢ rec (MvFunctor.map (TypeVec.id ::: mk)) (mk x) = x
tactic: unfold Fix.dest
state_before: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
x : F (α ::: Fix F α)
⊢ rec (MvFunctor.map (TypeVec.id ::: mk)) (mk x) = x
state_after: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
x : F (α ::: Fix F α)
⊢ ((TypeVec.id ::: mk) ⊚ (TypeVec.id ::: dest)) <$$> x = x
tactic: rw [Fix.rec_eq, ← Fix.dest, ← comp_map]
state_before: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
x : F (α ::: Fix F α)
⊢ ((TypeVec.id ::: mk) ⊚ (TypeVec.id ::: dest)) <$$> x = x
state_after: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
x : F (α ::: Fix F α)
⊢ ((TypeVec.id ::: mk) ⊚ (TypeVec.id ::: dest)) <$$> x = TypeVec.id <$$> x
tactic: conv =>
    rhs
    rw [← MvFunctor.id_map x]
state_before: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
x : F (α ::: Fix F α)
⊢ ((TypeVec.id ::: mk) ⊚ (TypeVec.id ::: dest)) <$$> x = TypeVec.id <$$> x
state_after: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
x : F (α ::: Fix F α)
⊢ (TypeVec.id ::: mk ∘ dest) <$$> x = TypeVec.id <$$> x
tactic: rw [← appendFun_comp, id_comp]
state_before: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
x : F (α ::: Fix F α)
⊢ (TypeVec.id ::: mk ∘ dest) <$$> x = TypeVec.id <$$> x
state_after: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
x : F (α ::: Fix F α)
this : mk ∘ dest = _root_.id
⊢ (TypeVec.id ::: mk ∘ dest) <$$> x = TypeVec.id <$$> x
tactic: have : Fix.mk ∘ Fix.dest (F := F) (α := α) = _root_.id := by
    ext (x : Fix F α)
    apply Fix.mk_dest
state_before: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
x : F (α ::: Fix F α)
this : mk ∘ dest = _root_.id
⊢ (TypeVec.id ::: mk ∘ dest) <$$> x = TypeVec.id <$$> x
state_after: no goals
tactic: rw [this, appendFun_id_id]
Theorem: CategoryTheory.Limits.Pi.map'_comp_map'
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
g : β → C
h : γ → C
inst✝² : HasProduct f
inst✝¹ : HasProduct g
inst✝ : HasProduct h
p : β → α
p' : γ → β
q : (b : β) → f (p b) ⟶ g b
q' : (c : γ) → g (p' c) ⟶ h c
⊢ map' p q ≫ map' p' q' = map' (p ∘ p') fun c => q (p' c) ≫ q' c
state_after: case h
β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝³ : Category.{v, u} C
f : α → C
g : β → C
h : γ → C
inst✝² : HasProduct f
inst✝¹ : HasProduct g
inst✝ : HasProduct h
p : β → α
p' : γ → β
q : (b : β) → f (p b) ⟶ g b
q' : (c : γ) → g (p' c) ⟶ h c
b✝ : γ
⊢ (map' p q ≫ map' p' q') ≫ π h b✝ = (map' (p ∘ p') fun c => q (p' c) ≫ q' c) ≫ π h b✝
tactic: ext
state_before: case h
β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝³ : Category.{v, u} C
f : α → C
g : β → C
h : γ → C
inst✝² : HasProduct f
inst✝¹ : HasProduct g
inst✝ : HasProduct h
p : β → α
p' : γ → β
q : (b : β) → f (p b) ⟶ g b
q' : (c : γ) → g (p' c) ⟶ h c
b✝ : γ
⊢ (map' p q ≫ map' p' q') ≫ π h b✝ = (map' (p ∘ p') fun c => q (p' c) ≫ q' c) ≫ π h b✝
state_after: no goals
tactic: simp
Theorem: WeierstrassCurve.Affine.CoordinateRing.basis_one
File: Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
⊢ (CoordinateRing.basis W) 1 = (mk W) Y
state_after: no goals
tactic: simpa only [basis_apply] using pow_one _
Theorem: IsCoercive.bounded_below
File: Mathlib/Analysis/InnerProductSpace/LaxMilgram.lean

Proof steps:
state_before: V : Type u
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : CompleteSpace V
B : V →L[ℝ] V →L[ℝ] ℝ
coercive : IsCoercive B
⊢ ∃ C, 0 < C ∧ ∀ (v : V), C * ‖v‖ ≤ ‖(continuousLinearMapOfBilin B) v‖
state_after: case intro.intro
V : Type u
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : CompleteSpace V
B : V →L[ℝ] V →L[ℝ] ℝ
C : ℝ
C_ge_0 : 0 < C
coercivity : ∀ (u : V), C * ‖u‖ * ‖u‖ ≤ (B u) u
⊢ ∃ C, 0 < C ∧ ∀ (v : V), C * ‖v‖ ≤ ‖(continuousLinearMapOfBilin B) v‖
tactic: rcases coercive with ⟨C, C_ge_0, coercivity⟩
state_before: case intro.intro
V : Type u
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : CompleteSpace V
B : V →L[ℝ] V →L[ℝ] ℝ
C : ℝ
C_ge_0 : 0 < C
coercivity : ∀ (u : V), C * ‖u‖ * ‖u‖ ≤ (B u) u
⊢ ∃ C, 0 < C ∧ ∀ (v : V), C * ‖v‖ ≤ ‖(continuousLinearMapOfBilin B) v‖
state_after: case intro.intro
V : Type u
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : CompleteSpace V
B : V →L[ℝ] V →L[ℝ] ℝ
C : ℝ
C_ge_0 : 0 < C
coercivity : ∀ (u : V), C * ‖u‖ * ‖u‖ ≤ (B u) u
⊢ ∀ (v : V), C * ‖v‖ ≤ ‖(continuousLinearMapOfBilin B) v‖
tactic: refine ⟨C, C_ge_0, ?_⟩
state_before: case intro.intro
V : Type u
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : CompleteSpace V
B : V →L[ℝ] V →L[ℝ] ℝ
C : ℝ
C_ge_0 : 0 < C
coercivity : ∀ (u : V), C * ‖u‖ * ‖u‖ ≤ (B u) u
⊢ ∀ (v : V), C * ‖v‖ ≤ ‖(continuousLinearMapOfBilin B) v‖
state_after: case intro.intro
V : Type u
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : CompleteSpace V
B : V →L[ℝ] V →L[ℝ] ℝ
C : ℝ
C_ge_0 : 0 < C
coercivity : ∀ (u : V), C * ‖u‖ * ‖u‖ ≤ (B u) u
v : V
⊢ C * ‖v‖ ≤ ‖(continuousLinearMapOfBilin B) v‖
tactic: intro v
state_before: case intro.intro
V : Type u
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : CompleteSpace V
B : V →L[ℝ] V →L[ℝ] ℝ
C : ℝ
C_ge_0 : 0 < C
coercivity : ∀ (u : V), C * ‖u‖ * ‖u‖ ≤ (B u) u
v : V
⊢ C * ‖v‖ ≤ ‖(continuousLinearMapOfBilin B) v‖
state_after: case pos
V : Type u
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : CompleteSpace V
B : V →L[ℝ] V →L[ℝ] ℝ
C : ℝ
C_ge_0 : 0 < C
coercivity : ∀ (u : V), C * ‖u‖ * ‖u‖ ≤ (B u) u
v : V
h : 0 < ‖v‖
⊢ C * ‖v‖ ≤ ‖(continuousLinearMapOfBilin B) v‖

case neg
V : Type u
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : CompleteSpace V
B : V →L[ℝ] V →L[ℝ] ℝ
C : ℝ
C_ge_0 : 0 < C
coercivity : ∀ (u : V), C * ‖u‖ * ‖u‖ ≤ (B u) u
v : V
h : ¬0 < ‖v‖
⊢ C * ‖v‖ ≤ ‖(continuousLinearMapOfBilin B) v‖
tactic: by_cases h : 0 < ‖v‖
Theorem: HasSum.unique
File: Mathlib/Topology/Algebra/InfiniteSum/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : CommMonoid α
inst✝¹ : TopologicalSpace α
f g : β → α
a b : α
s : Finset β
a₁ a₂ : α
inst✝ : T2Space α
⊢ HasProd f a₁ → HasProd f a₂ → a₁ = a₂
state_after: no goals
tactic: classical exact tendsto_nhds_unique
Theorem: AddSubgroup.exists_ne_zero_of_nontrivial
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 H : Subgroup G
inst✝ : Nontrivial ↥H
⊢ ∃ x ∈ H, x ≠ 1
state_after: no goals
tactic: rwa [← Subgroup.nontrivial_iff_exists_ne_one]
Theorem: Polynomial.degree_C_mul_X_le
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a✝ b c d : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
a : R
⊢ (C a * X).degree ≤ 1
state_after: no goals
tactic: simpa only [pow_one] using degree_C_mul_X_pow_le 1 a
Theorem: CochainComplex.HomComplex.Cochain.comp_assoc_of_first_is_zero_cochain
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m n₂ n₃ n₂₃ : ℤ
z₁ : Cochain F G 0
z₂ : Cochain G K n₂
z₃ : Cochain K L n₃
h₂₃ : n₂ + n₃ = n₂₃
⊢ 0 + n₂ + n₃ = n₂₃
state_after: no goals
tactic: omega
Theorem: Nat.Partrec.ppred
File: Mathlib/Computability/Partrec.lean

Proof steps:
state_before: this : Primrec₂ fun n m => if n = m.succ then 0 else 1
n : ℕ
⊢ (Nat.rfind fun n_1 =>
      (fun m => decide (m = 0)) <$> ↑(unpaired fun n m => if n = m.succ then 0 else 1) (Nat.pair n n_1)) =
    ↑n.ppred
state_after: case zero
this : Primrec₂ fun n m => if n = m.succ then 0 else 1
⊢ (Nat.rfind fun n => Part.some false) = Part.none

case succ
this : Primrec₂ fun n m => if n = m.succ then 0 else 1
n✝ : ℕ
⊢ (Nat.rfind fun n => Part.some (decide (n✝ = n))) = Part.some n✝
tactic: cases n <;> simp
Theorem: hasSum_mellin_pi_mul
File: Mathlib/NumberTheory/LSeries/MellinEqDirichlet.lean

Proof steps:
state_before: ι : Type u_1
inst✝ : Countable ι
a : ι → ℂ
q : ι → ℝ
F : ℝ → ℂ
s : ℂ
hq : ∀ (i : ι), a i = 0 ∨ 0 < q i
hs : 0 < s.re
hF : ∀ t ∈ Ioi 0, HasSum (fun i => a i * ↑(rexp (-π * q i * t))) (F t)
h_sum : Summable fun i => ‖a i‖ / q i ^ s.re
⊢ HasSum (fun i => ↑π ^ (-s) * Complex.Gamma s * a i / ↑(q i) ^ s) (mellin F s)
state_after: ι : Type u_1
inst✝ : Countable ι
a : ι → ℂ
q : ι → ℝ
F : ℝ → ℂ
s : ℂ
hq : ∀ (i : ι), a i = 0 ∨ 0 < q i
hs : 0 < s.re
hF : ∀ t ∈ Ioi 0, HasSum (fun i => a i * ↑(rexp (-π * q i * t))) (F t)
h_sum : Summable fun i => ‖a i‖ / q i ^ s.re
hp : ∀ (i : ι), a i = 0 ∨ 0 < π * q i
⊢ HasSum (fun i => ↑π ^ (-s) * Complex.Gamma s * a i / ↑(q i) ^ s) (mellin F s)
tactic: have hp i : a i = 0 ∨ 0 < π * q i := by rcases hq i with h | h <;> simp [h, pi_pos]
state_before: ι : Type u_1
inst✝ : Countable ι
a : ι → ℂ
q : ι → ℝ
F : ℝ → ℂ
s : ℂ
hq : ∀ (i : ι), a i = 0 ∨ 0 < q i
hs : 0 < s.re
hF : ∀ t ∈ Ioi 0, HasSum (fun i => a i * ↑(rexp (-π * q i * t))) (F t)
h_sum : Summable fun i => ‖a i‖ / q i ^ s.re
hp : ∀ (i : ι), a i = 0 ∨ 0 < π * q i
⊢ HasSum (fun i => ↑π ^ (-s) * Complex.Gamma s * a i / ↑(q i) ^ s) (mellin F s)
state_after: case h.e'_5.h
ι : Type u_1
inst✝ : Countable ι
a : ι → ℂ
q : ι → ℝ
F : ℝ → ℂ
s : ℂ
hq : ∀ (i : ι), a i = 0 ∨ 0 < q i
hs : 0 < s.re
hF : ∀ t ∈ Ioi 0, HasSum (fun i => a i * ↑(rexp (-π * q i * t))) (F t)
h_sum : Summable fun i => ‖a i‖ / q i ^ s.re
hp : ∀ (i : ι), a i = 0 ∨ 0 < π * q i
i : ι
⊢ ↑π ^ (-s) * Complex.Gamma s * a i / ↑(q i) ^ s = Complex.Gamma s * a i / ↑(π * q i) ^ s

ι : Type u_1
inst✝ : Countable ι
a : ι → ℂ
q : ι → ℝ
F : ℝ → ℂ
s : ℂ
hq : ∀ (i : ι), a i = 0 ∨ 0 < q i
hs : 0 < s.re
hF : ∀ t ∈ Ioi 0, HasSum (fun i => a i * ↑(rexp (-π * q i * t))) (F t)
h_sum : Summable fun i => ‖a i‖ / q i ^ s.re
hp : ∀ (i : ι), a i = 0 ∨ 0 < π * q i
⊢ Summable fun i => ‖a i‖ / (π * q i) ^ s.re
tactic: convert hasSum_mellin hp hs (by simpa using hF) ?_ using 2 with i
Theorem: TensorProduct.tensorTensorTensorComm_symm
File: Mathlib/LinearAlgebra/TensorProduct/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹⁶ : CommSemiring R
R' : Type u_2
inst✝¹⁵ : Monoid R'
R'' : Type u_3
inst✝¹⁴ : Semiring R''
M : Type u_4
N : Type u_5
P : Type u_6
Q : Type u_7
S : Type u_8
T : Type u_9
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid N
inst✝¹¹ : AddCommMonoid P
inst✝¹⁰ : AddCommMonoid Q
inst✝⁹ : AddCommMonoid S
inst✝⁸ : AddCommMonoid T
inst✝⁷ : Module R M
inst✝⁶ : Module R N
inst✝⁵ : Module R P
inst✝⁴ : Module R Q
inst✝³ : Module R S
inst✝² : Module R T
inst✝¹ : DistribMulAction R' M
inst✝ : Module R'' M
⊢ (tensorTensorTensorComm R M N P Q).symm = tensorTensorTensorComm R M P N Q
state_after: case h
R : Type u_1
inst✝¹⁶ : CommSemiring R
R' : Type u_2
inst✝¹⁵ : Monoid R'
R'' : Type u_3
inst✝¹⁴ : Semiring R''
M : Type u_4
N : Type u_5
P : Type u_6
Q : Type u_7
S : Type u_8
T : Type u_9
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid N
inst✝¹¹ : AddCommMonoid P
inst✝¹⁰ : AddCommMonoid Q
inst✝⁹ : AddCommMonoid S
inst✝⁸ : AddCommMonoid T
inst✝⁷ : Module R M
inst✝⁶ : Module R N
inst✝⁵ : Module R P
inst✝⁴ : Module R Q
inst✝³ : Module R S
inst✝² : Module R T
inst✝¹ : DistribMulAction R' M
inst✝ : Module R'' M
x✝ : (M ⊗[R] P) ⊗[R] N ⊗[R] Q
⊢ (tensorTensorTensorComm R M N P Q).symm x✝ = (tensorTensorTensorComm R M P N Q) x✝
tactic: ext
state_before: case h
R : Type u_1
inst✝¹⁶ : CommSemiring R
R' : Type u_2
inst✝¹⁵ : Monoid R'
R'' : Type u_3
inst✝¹⁴ : Semiring R''
M : Type u_4
N : Type u_5
P : Type u_6
Q : Type u_7
S : Type u_8
T : Type u_9
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid N
inst✝¹¹ : AddCommMonoid P
inst✝¹⁰ : AddCommMonoid Q
inst✝⁹ : AddCommMonoid S
inst✝⁸ : AddCommMonoid T
inst✝⁷ : Module R M
inst✝⁶ : Module R N
inst✝⁵ : Module R P
inst✝⁴ : Module R Q
inst✝³ : Module R S
inst✝² : Module R T
inst✝¹ : DistribMulAction R' M
inst✝ : Module R'' M
x✝ : (M ⊗[R] P) ⊗[R] N ⊗[R] Q
⊢ (tensorTensorTensorComm R M N P Q).symm x✝ = (tensorTensorTensorComm R M P N Q) x✝
state_after: no goals
tactic: rfl