ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: descPochhammer_eval_eq_ascPochhammer
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

Proof steps:
state_before: R : Type u
inst✝ : Ring R
r : R
n : ℕ
⊢ eval r (descPochhammer R n) = eval (r - ↑n + 1) (ascPochhammer R n)
state_after: no goals
tactic: induction n with
  | zero => rw [descPochhammer_zero, eval_one, ascPochhammer_zero, eval_one]
  | succ n ih =>
    rw [Nat.cast_succ, sub_add, add_sub_cancel_right, descPochhammer_succ_eval, ih,
      ascPochhammer_succ_left, X_mul, eval_mul_X, show (X + 1 : R[X]) =
      (X + 1 : ℕ[X]).map (algebraMap ℕ R) by simp only [Polynomial.map_add, map_X,
      Polynomial.map_one], ascPochhammer_eval_comp, eval₂_add, eval₂_X, eval₂_one]
Theorem: ProbabilityTheory.Kernel.ext_fun
File: Mathlib/Probability/Kernel/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ η : Kernel α β
h : ∀ (a : α) (f : β → ℝ≥0∞), Measurable f → ∫⁻ (b : β), f b ∂κ a = ∫⁻ (b : β), f b ∂η a
⊢ κ = η
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ η : Kernel α β
h : ∀ (a : α) (f : β → ℝ≥0∞), Measurable f → ∫⁻ (b : β), f b ∂κ a = ∫⁻ (b : β), f b ∂η a
a : α
s : Set β
hs : MeasurableSet s
⊢ (κ a) s = (η a) s
tactic: ext a s hs
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ η : Kernel α β
h : ∀ (a : α) (f : β → ℝ≥0∞), Measurable f → ∫⁻ (b : β), f b ∂κ a = ∫⁻ (b : β), f b ∂η a
a : α
s : Set β
hs : MeasurableSet s
⊢ (κ a) s = (η a) s
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ η : Kernel α β
a : α
s : Set β
hs : MeasurableSet s
h : ∫⁻ (b : β), s.indicator (fun x => 1) b ∂κ a = ∫⁻ (b : β), s.indicator (fun x => 1) b ∂η a
⊢ (κ a) s = (η a) s
tactic: specialize h a (s.indicator fun _ => 1) (Measurable.indicator measurable_const hs)
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ η : Kernel α β
a : α
s : Set β
hs : MeasurableSet s
h : ∫⁻ (b : β), s.indicator (fun x => 1) b ∂κ a = ∫⁻ (b : β), s.indicator (fun x => 1) b ∂η a
⊢ (κ a) s = (η a) s
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ η : Kernel α β
a : α
s : Set β
hs : MeasurableSet s
h : (κ a) s = (η a) s
⊢ (κ a) s = (η a) s
tactic: simp_rw [lintegral_indicator_const hs, one_mul] at h
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ η : Kernel α β
a : α
s : Set β
hs : MeasurableSet s
h : (κ a) s = (η a) s
⊢ (κ a) s = (η a) s
state_after: no goals
tactic: rw [h]
Theorem: hasSum_geometric_two
File: Mathlib/Analysis/SpecificLimits/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
⊢ HasSum (fun n => (1 / 2) ^ n) 2
state_after: no goals
tactic: convert hasSum_geometric_of_lt_one _ _ <;> norm_num
Theorem: Real.arccos_eq_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

Proof steps:
state_before: x✝ y x : ℝ
⊢ arccos x = π / 2 ↔ x = 0
state_after: no goals
tactic: simp [arccos]
Theorem: CliffordAlgebra.reverse_ι
File: Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
m : M
⊢ reverse ((ι Q) m) = (ι Q) m
state_after: no goals
tactic: simp [reverse]
Theorem: Nat.multichoose_succ_succ
File: Mathlib/Data/Nat/Choose/Basic.lean

Proof steps:
state_before: n k : ℕ
⊢ (n + 1).multichoose (k + 1) = n.multichoose (k + 1) + (n + 1).multichoose k
state_after: no goals
tactic: simp [multichoose]
Theorem: Nat.add_descFactorial_eq_ascFactorial
File: Mathlib/Data/Nat/Factorial/Basic.lean

Proof steps:
state_before: n : ℕ
⊢ (n + 0).descFactorial 0 = (n + 1).ascFactorial 0
state_after: no goals
tactic: rw [ascFactorial_zero, descFactorial_zero]
state_before: n k : ℕ
⊢ (n + k.succ).descFactorial k.succ = (n + 1).ascFactorial k.succ
state_after: no goals
tactic: rw [Nat.add_succ, succ_descFactorial_succ, ascFactorial_succ,
      add_descFactorial_eq_ascFactorial _ k, Nat.add_right_comm]
Theorem: Matrix.cramer_transpose_apply
File: Mathlib/LinearAlgebra/Matrix/Adjugate.lean

Proof steps:
state_before: m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
b : n → α
i : n
⊢ Aᵀ.cramer b i = (A.updateRow i b).det
state_after: no goals
tactic: rw [cramer_apply, updateColumn_transpose, det_transpose]
Theorem: StrictConvex.add_right
File: Mathlib/Analysis/Convex/Strict.lean

Proof steps:
state_before: 𝕜 : Type u_1
𝕝 : Type u_2
E : Type u_3
F : Type u_4
β : Type u_5
inst✝⁷ : OrderedSemiring 𝕜
inst✝⁶ : TopologicalSpace E
inst✝⁵ : TopologicalSpace F
inst✝⁴ : AddCommGroup E
inst✝³ : AddCommGroup F
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 F
inst✝ : ContinuousAdd E
s t : Set E
hs : StrictConvex 𝕜 s
z : E
⊢ StrictConvex 𝕜 ((fun x => x + z) '' s)
state_after: no goals
tactic: simpa only [add_comm] using hs.add_left z
Theorem: equicontinuous_restrict_iff
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → X → α
S : Set X
⊢ Equicontinuous (S.restrict ∘ F) ↔ EquicontinuousOn F S
state_after: no goals
tactic: simp [Equicontinuous, EquicontinuousOn, equicontinuousAt_restrict_iff]
Theorem: ModuleCat.MonoidalCategory.tensor_comp
File: Mathlib/Algebra/Category/ModuleCat/Monoidal/Basic.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
X₁ Y₁ Z₁ : ModuleCat R
X₂ Y₂ Z₂ : ModuleCat R
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₂
g₁ : Y₁ ⟶ Z₁
g₂ : Y₂ ⟶ Z₂
⊢ tensorHom (f₁ ≫ g₁) (f₂ ≫ g₂) = tensorHom f₁ f₂ ≫ tensorHom g₁ g₂
state_after: case H
R : Type u
inst✝ : CommRing R
X₁ Y₁ Z₁ : ModuleCat R
X₂ Y₂ Z₂ : ModuleCat R
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₂
g₁ : Y₁ ⟶ Z₁
g₂ : Y₂ ⟶ Z₂
⊢ (TensorProduct.mk R ↑X₁ ↑X₂).compr₂ (tensorHom (f₁ ≫ g₁) (f₂ ≫ g₂)) =
    (TensorProduct.mk R ↑X₁ ↑X₂).compr₂ (tensorHom f₁ f₂ ≫ tensorHom g₁ g₂)
tactic: apply TensorProduct.ext
state_before: case H
R : Type u
inst✝ : CommRing R
X₁ Y₁ Z₁ : ModuleCat R
X₂ Y₂ Z₂ : ModuleCat R
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₂
g₁ : Y₁ ⟶ Z₁
g₂ : Y₂ ⟶ Z₂
⊢ (TensorProduct.mk R ↑X₁ ↑X₂).compr₂ (tensorHom (f₁ ≫ g₁) (f₂ ≫ g₂)) =
    (TensorProduct.mk R ↑X₁ ↑X₂).compr₂ (tensorHom f₁ f₂ ≫ tensorHom g₁ g₂)
state_after: no goals
tactic: rfl
Theorem: Finsupp.single_eq_single_iff
File: Mathlib/Data/Finsupp/Defs.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✝ : Zero M
a a' : α
b : M
a₁ a₂ : α
b₁ b₂ : M
⊢ single a₁ b₁ = single a₂ b₂ ↔ a₁ = a₂ ∧ b₁ = b₂ ∨ b₁ = 0 ∧ b₂ = 0
state_after: case mp
α : 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✝ : Zero M
a a' : α
b : M
a₁ a₂ : α
b₁ b₂ : M
⊢ single a₁ b₁ = single a₂ b₂ → a₁ = a₂ ∧ b₁ = b₂ ∨ b₁ = 0 ∧ b₂ = 0

case mpr
α : 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✝ : Zero M
a a' : α
b : M
a₁ a₂ : α
b₁ b₂ : M
⊢ a₁ = a₂ ∧ b₁ = b₂ ∨ b₁ = 0 ∧ b₂ = 0 → single a₁ b₁ = single a₂ b₂
tactic: constructor
Theorem: ModuleCat.CoextendScalars.map'_apply
File: Mathlib/Algebra/Category/ModuleCat/ChangeOfRings.lean

Proof steps:
state_before: R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
M✝ : ModuleCat R
M M' : ModuleCat R
g : M ⟶ M'
s : S
h : ↑(obj' f M)
t : S
⊢ ({ toFun := fun h => g ∘ₗ h, map_add' := ⋯ }.toFun (s • h)) t =
    ((RingHom.id S) s • { toFun := fun h => g ∘ₗ h, map_add' := ⋯ }.toFun h) t
state_after: R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
M✝ : ModuleCat R
M M' : ModuleCat R
g : M ⟶ M'
s : S
h : ↑(obj' f M)
t : S
⊢ g ((s • h) t) = (s • g ∘ₗ h) t
tactic: dsimp
state_before: R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
M✝ : ModuleCat R
M M' : ModuleCat R
g : M ⟶ M'
s : S
h : ↑(obj' f M)
t : S
⊢ g ((s • h) t) = (s • g ∘ₗ h) t
state_after: R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
M✝ : ModuleCat R
M M' : ModuleCat R
g : M ⟶ M'
s : S
h : ↑(obj' f M)
t : S
⊢ g (h (t * s)) = (g ∘ₗ h) (t * s)
tactic: rw [smul_apply',smul_apply']
state_before: R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
M✝ : ModuleCat R
M M' : ModuleCat R
g : M ⟶ M'
s : S
h : ↑(obj' f M)
t : S
⊢ g (h (t * s)) = (g ∘ₗ h) (t * s)
state_after: no goals
tactic: simp
Theorem: sup_eq_mul_oneLePart_div
File: Mathlib/Algebra/Order/Group/PosPart.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ a ⊔ b = b * (a / b)⁺ᵐ
state_after: no goals
tactic: simp [oneLePart, mul_sup]
Theorem: Nat.count_nth
File: Mathlib/Data/Nat/Nth.lean

Proof steps:
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
n : ℕ
hn : ∀ (hf : (setOf p).Finite), n < hf.toFinset.card
⊢ count p (nth p n) = n
state_after: case zero
p : ℕ → Prop
inst✝ : DecidablePred p
hn : ∀ (hf : (setOf p).Finite), 0 < hf.toFinset.card
⊢ count p (nth p 0) = 0

case succ
p : ℕ → Prop
inst✝ : DecidablePred p
k : ℕ
ihk : (∀ (hf : (setOf p).Finite), k < hf.toFinset.card) → count p (nth p k) = k
hn : ∀ (hf : (setOf p).Finite), k + 1 < hf.toFinset.card
⊢ count p (nth p (k + 1)) = k + 1
tactic: induction' n with k ihk
Theorem: HurwitzZeta.evenKernel_eq_cosKernel_of_zero
File: Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean

Proof steps:
state_before: ⊢ evenKernel 0 = cosKernel 0
state_after: case h
x : ℝ
⊢ evenKernel 0 x = cosKernel 0 x
tactic: ext1 x
state_before: case h
x : ℝ
⊢ evenKernel 0 x = cosKernel 0 x
state_after: no goals
tactic: simp only [← QuotientAddGroup.mk_zero, ← ofReal_inj, evenKernel_def, ofReal_zero, sq, mul_zero,
    zero_mul, Complex.exp_zero, one_mul, cosKernel_def]
Theorem: lowerClosure_add_distrib
File: Mathlib/Algebra/Order/UpperLower.lean

Proof steps:
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
⊢ ↑(lowerClosure (s * t)) = ↑(lowerClosure s * lowerClosure t)
state_after: no goals
tactic: rw [LowerSet.coe_mul, mul_lowerClosure, lowerClosure_mul, LowerSet.lowerClosure]
Theorem: isLeast_union_iff
File: Mathlib/Order/Bounds/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
s✝ t✝ : Set α
a✝ b a : α
s t : Set α
⊢ IsLeast (s ∪ t) a ↔ IsLeast s a ∧ a ∈ lowerBounds t ∨ a ∈ lowerBounds s ∧ IsLeast t a
state_after: no goals
tactic: simp [IsLeast, lowerBounds_union, or_and_right, and_comm (a := a ∈ t), and_assoc]
Theorem: CategoryTheory.SimplicialObject.Augmented.whiskering_map_app_left
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X : SimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
A : Augmented C
⊢ (𝟭 (SimplicialObject D)).map (whiskerLeft (drop.obj A) η) ≫ ((whiskeringObj C D Y✝).obj A).hom =
    ((whiskeringObj C D X✝).obj A).hom ≫ (const D).map (η.app (point.obj A))
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
X : SimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
A : Augmented C
n : SimplexCategoryᵒᵖ
⊢ ((𝟭 (SimplicialObject D)).map (whiskerLeft (drop.obj A) η) ≫ ((whiskeringObj C D Y✝).obj A).hom).app n =
    (((whiskeringObj C D X✝).obj A).hom ≫ (const D).map (η.app (point.obj A))).app n
tactic: ext n
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
X : SimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
A : Augmented C
n : SimplexCategoryᵒᵖ
⊢ ((𝟭 (SimplicialObject D)).map (whiskerLeft (drop.obj A) η) ≫ ((whiskeringObj C D Y✝).obj A).hom).app n =
    (((whiskeringObj C D X✝).obj A).hom ≫ (const D).map (η.app (point.obj A))).app n
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
X : SimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
A : Augmented C
n : SimplexCategoryᵒᵖ
⊢ η.app (A.left.obj n) ≫ Y✝.map (A.hom.app n) ≫ 𝟙 (Y✝.obj A.right) =
    (X✝.map (A.hom.app n) ≫ 𝟙 (X✝.obj A.right)) ≫ η.app A.right
tactic: dsimp
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
X : SimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
A : Augmented C
n : SimplexCategoryᵒᵖ
⊢ η.app (A.left.obj n) ≫ Y✝.map (A.hom.app n) ≫ 𝟙 (Y✝.obj A.right) =
    (X✝.map (A.hom.app n) ≫ 𝟙 (X✝.obj A.right)) ≫ η.app A.right
state_after: no goals
tactic: rw [Category.comp_id, Category.comp_id, η.naturality]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X : SimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ Z✝ : C ⥤ D
x✝¹ : X✝ ⟶ Y✝
x✝ : Y✝ ⟶ Z✝
⊢ { obj := whiskeringObj C D,
          map := fun {X Y} η =>
            { app := fun A => { left := whiskerLeft (drop.obj A) η, right := η.app (point.obj A), w := ⋯ },
              naturality := ⋯ } }.map
      (x✝¹ ≫ x✝) =
    { obj := whiskeringObj C D,
            map := fun {X Y} η =>
              { app := fun A => { left := whiskerLeft (drop.obj A) η, right := η.app (point.obj A), w := ⋯ },
                naturality := ⋯ } }.map
        x✝¹ ≫
      { obj := whiskeringObj C D,
            map := fun {X Y} η =>
              { app := fun A => { left := whiskerLeft (drop.obj A) η, right := η.app (point.obj A), w := ⋯ },
                naturality := ⋯ } }.map
        x✝
state_after: no goals
tactic: ext <;> rfl
Theorem: Polynomial.separable_X_pow_sub_C_unit
File: Mathlib/FieldTheory/Separable.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
n : ℕ
u : Rˣ
hn : IsUnit ↑n
⊢ (X ^ n - C ↑u).Separable
state_after: R : Type u
inst✝ : CommRing R
n : ℕ
u : Rˣ
hn : IsUnit ↑n
a✝ : Nontrivial R
⊢ (X ^ n - C ↑u).Separable
tactic: nontriviality R
state_before: R : Type u
inst✝ : CommRing R
n : ℕ
u : Rˣ
hn : IsUnit ↑n
a✝ : Nontrivial R
⊢ (X ^ n - C ↑u).Separable
state_after: case inl
R : Type u
inst✝ : CommRing R
u : Rˣ
a✝ : Nontrivial R
hn : IsUnit ↑0
⊢ (X ^ 0 - C ↑u).Separable

case inr
R : Type u
inst✝ : CommRing R
n : ℕ
u : Rˣ
hn : IsUnit ↑n
a✝ : Nontrivial R
hpos : n > 0
⊢ (X ^ n - C ↑u).Separable
tactic: rcases n.eq_zero_or_pos with (rfl | hpos)
state_before: case inr
R : Type u
inst✝ : CommRing R
n : ℕ
u : Rˣ
hn : IsUnit ↑n
a✝ : Nontrivial R
hpos : n > 0
⊢ (X ^ n - C ↑u).Separable
state_after: case inr
R : Type u
inst✝ : CommRing R
n : ℕ
u : Rˣ
hn : IsUnit ↑n
a✝ : Nontrivial R
hpos : n > 0
⊢ ∃ a b, a * (X ^ n - C ↑u) + b * derivative (X ^ n - C ↑u) = 1
tactic: apply (separable_def' (X ^ n - C (u : R))).2
state_before: case inr
R : Type u
inst✝ : CommRing R
n : ℕ
u : Rˣ
hn : IsUnit ↑n
a✝ : Nontrivial R
hpos : n > 0
⊢ ∃ a b, a * (X ^ n - C ↑u) + b * derivative (X ^ n - C ↑u) = 1
state_after: case inr.intro
R : Type u
inst✝ : CommRing R
n : ℕ
u : Rˣ
hn : IsUnit ↑n
a✝ : Nontrivial R
hpos : n > 0
n' : R
hn' : n' * ↑n = 1
⊢ ∃ a b, a * (X ^ n - C ↑u) + b * derivative (X ^ n - C ↑u) = 1
tactic: obtain ⟨n', hn'⟩ := hn.exists_left_inv
state_before: case inr.intro
R : Type u
inst✝ : CommRing R
n : ℕ
u : Rˣ
hn : IsUnit ↑n
a✝ : Nontrivial R
hpos : n > 0
n' : R
hn' : n' * ↑n = 1
⊢ ∃ a b, a * (X ^ n - C ↑u) + b * derivative (X ^ n - C ↑u) = 1
state_after: case inr.intro
R : Type u
inst✝ : CommRing R
n : ℕ
u : Rˣ
hn : IsUnit ↑n
a✝ : Nontrivial R
hpos : n > 0
n' : R
hn' : n' * ↑n = 1
⊢ -C ↑u⁻¹ * (X ^ n - C ↑u) + C ↑u⁻¹ * C n' * X * derivative (X ^ n - C ↑u) = 1
tactic: refine ⟨-C ↑u⁻¹, C (↑u⁻¹ : R) * C n' * X, ?_⟩
state_before: case inr.intro
R : Type u
inst✝ : CommRing R
n : ℕ
u : Rˣ
hn : IsUnit ↑n
a✝ : Nontrivial R
hpos : n > 0
n' : R
hn' : n' * ↑n = 1
⊢ -C ↑u⁻¹ * (X ^ n - C ↑u) + C ↑u⁻¹ * C n' * X * derivative (X ^ n - C ↑u) = 1
state_after: case inr.intro
R : Type u
inst✝ : CommRing R
n : ℕ
u : Rˣ
hn : IsUnit ↑n
a✝ : Nontrivial R
hpos : n > 0
n' : R
hn' : n' * ↑n = 1
⊢ -C ↑u⁻¹ * (X ^ n - C ↑u) + C ↑u⁻¹ * C n' * X * (C ↑n * X ^ (n - 1)) = 1
tactic: rw [derivative_sub, derivative_C, sub_zero, derivative_pow X n, derivative_X, mul_one]
state_before: case inr.intro
R : Type u
inst✝ : CommRing R
n : ℕ
u : Rˣ
hn : IsUnit ↑n
a✝ : Nontrivial R
hpos : n > 0
n' : R
hn' : n' * ↑n = 1
⊢ -C ↑u⁻¹ * (X ^ n - C ↑u) + C ↑u⁻¹ * C n' * X * (C ↑n * X ^ (n - 1)) = 1
state_after: no goals
tactic: calc
    -C ↑u⁻¹ * (X ^ n - C ↑u) + C ↑u⁻¹ * C n' * X * (↑n * X ^ (n - 1)) =
        C (↑u⁻¹ * ↑u) - C ↑u⁻¹ * X ^ n + C ↑u⁻¹ * C (n' * ↑n) * (X * X ^ (n - 1)) := by
      simp only [C.map_mul, C_eq_natCast]
      ring
    _ = 1 := by
      simp only [Units.inv_mul, hn', C.map_one, mul_one, ← pow_succ',
        Nat.sub_add_cancel (show 1 ≤ n from hpos), sub_add_cancel]
Theorem: IntermediateField.algHomEquivAlgHomOfSplits_apply
File: Mathlib/FieldTheory/IsAlgClosed/Basic.lean

Proof steps:
state_before: k : Type u
inst✝⁶ : Field k
F : Type u_1
K : Type u_2
A : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K
inst✝³ : Field A
inst✝² : Algebra F K
inst✝¹ : Algebra F A
inst✝ : Algebra.IsAlgebraic F K
L : IntermediateField F A
hL : ∀ (x : K), Splits (algebraMap F ↥L) (minpoly F x)
f : K →ₐ[F] A
x : K
⊢ Splits (algebraMap F ↥L) (minpoly F (f x))
state_after: k : Type u
inst✝⁶ : Field k
F : Type u_1
K : Type u_2
A : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K
inst✝³ : Field A
inst✝² : Algebra F K
inst✝¹ : Algebra F A
inst✝ : Algebra.IsAlgebraic F K
L : IntermediateField F A
hL : ∀ (x : K), Splits (algebraMap F ↥L) (minpoly F x)
f : K →ₐ[F] A
x : K
⊢ Splits (algebraMap F ↥L) (minpoly F x)
tactic: rw [minpoly.algHom_eq f f.injective]
state_before: k : Type u
inst✝⁶ : Field k
F : Type u_1
K : Type u_2
A : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K
inst✝³ : Field A
inst✝² : Algebra F K
inst✝¹ : Algebra F A
inst✝ : Algebra.IsAlgebraic F K
L : IntermediateField F A
hL : ∀ (x : K), Splits (algebraMap F ↥L) (minpoly F x)
f : K →ₐ[F] A
x : K
⊢ Splits (algebraMap F ↥L) (minpoly F x)
state_after: no goals
tactic: exact hL x
state_before: k : Type u
inst✝⁶ : Field k
F : Type u_1
K : Type u_2
A : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K
inst✝³ : Field A
inst✝² : Algebra F K
inst✝¹ : Algebra F A
inst✝ : Algebra.IsAlgebraic F K
L : IntermediateField F A
hL : ∀ (x : K), Splits (algebraMap F ↥L) (minpoly F x)
x✝ : K →ₐ[F] A
⊢ L.val.comp ((fun f => f.codRestrict L.toSubalgebra ⋯) x✝) = x✝
state_after: no goals
tactic: rfl
Theorem: LaurentPolynomial.degree_eq_bot_iff
File: Mathlib/Algebra/Polynomial/Laurent.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
f : R[T;T⁻¹]
⊢ f.degree = ⊥ ↔ f = 0
state_after: R : Type u_1
inst✝ : Semiring R
f : R[T;T⁻¹]
h : f.degree = ⊥
⊢ f = 0
tactic: refine ⟨fun h => ?_, fun h => by rw [h, degree_zero]⟩
state_before: R : Type u_1
inst✝ : Semiring R
f : R[T;T⁻¹]
h : f.degree = ⊥
⊢ f = 0
state_after: R : Type u_1
inst✝ : Semiring R
f : R[T;T⁻¹]
h : f.support.sup WithBot.some = ⊥
⊢ f = 0
tactic: rw [degree, Finset.max_eq_sup_withBot] at h
state_before: R : Type u_1
inst✝ : Semiring R
f : R[T;T⁻¹]
h : f.support.sup WithBot.some = ⊥
⊢ f = 0
state_after: case h
R : Type u_1
inst✝ : Semiring R
f : R[T;T⁻¹]
h : f.support.sup WithBot.some = ⊥
n : ℤ
⊢ f n = 0 n
tactic: ext n
state_before: case h
R : Type u_1
inst✝ : Semiring R
f : R[T;T⁻¹]
h : f.support.sup WithBot.some = ⊥
n : ℤ
⊢ f n = 0 n
state_after: case h
R : Type u_1
inst✝ : Semiring R
f : R[T;T⁻¹]
h : f.support.sup WithBot.some = ⊥
n : ℤ
f0 : ¬f n = 0 n
⊢ False
tactic: refine not_not.mp fun f0 => ?_
state_before: case h
R : Type u_1
inst✝ : Semiring R
f : R[T;T⁻¹]
h : f.support.sup WithBot.some = ⊥
n : ℤ
f0 : ¬f n = 0 n
⊢ False
state_after: case h
R : Type u_1
inst✝ : Semiring R
f : R[T;T⁻¹]
n : ℤ
f0 : ¬f n = 0 n
h : ∀ (s : ℤ), ¬f s = 0 → False
⊢ False
tactic: simp_rw [Finset.sup_eq_bot_iff, Finsupp.mem_support_iff, Ne, WithBot.coe_ne_bot] at h
state_before: case h
R : Type u_1
inst✝ : Semiring R
f : R[T;T⁻¹]
n : ℤ
f0 : ¬f n = 0 n
h : ∀ (s : ℤ), ¬f s = 0 → False
⊢ False
state_after: no goals
tactic: exact h n f0
Theorem: Asymptotics.isEquivalent_iff_exists_eq_mul
File: Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
⊢ u ~[l] v ↔ ∃ φ, ∃ (_ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v
state_after: α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
⊢ (∃ φ, Tendsto φ l (𝓝 0) ∧ u - v =ᶠ[l] φ * v) ↔ ∃ φ, ∃ (_ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v
tactic: rw [IsEquivalent, isLittleO_iff_exists_eq_mul]
state_before: α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
⊢ (∃ φ, Tendsto φ l (𝓝 0) ∧ u - v =ᶠ[l] φ * v) ↔ ∃ φ, ∃ (_ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v
state_after: case mp.intro.intro.refine_1
α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
φ : α → β
hφ : Tendsto φ l (𝓝 0)
h : u - v =ᶠ[l] φ * v
⊢ Tendsto (φ + 1) l (𝓝 1)

case mp.intro.intro.refine_2
α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
φ : α → β
hφ : Tendsto φ l (𝓝 0)
h : u - v =ᶠ[l] φ * v
⊢ u =ᶠ[l] (φ + 1) * v

case mpr.intro.intro.refine_1
α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
φ : α → β
hφ : Tendsto φ l (𝓝 1)
h : u =ᶠ[l] φ * v
⊢ Tendsto (φ - 1) l (𝓝 0)

case mpr.intro.intro.refine_2
α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
φ : α → β
hφ : Tendsto φ l (𝓝 1)
h : u =ᶠ[l] φ * v
⊢ u - v =ᶠ[l] (φ - 1) * v
tactic: constructor <;> rintro ⟨φ, hφ, h⟩ <;> [refine ⟨φ + 1, ?_, ?_⟩; refine ⟨φ - 1, ?_, ?_⟩]
Theorem: isLocalizedModule_iff_isLocalization'
File: Mathlib/Algebra/Module/LocalizedModule.lean

Proof steps:
state_before: R : Type u_1
inst✝¹³ : CommSemiring R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝¹² : AddCommMonoid M
inst✝¹¹ : AddCommMonoid M'
inst✝¹⁰ : AddCommMonoid M''
A : Type u_5
inst✝⁹ : CommSemiring A
inst✝⁸ : Algebra R A
inst✝⁷ : Module A M'
inst✝⁶ : IsLocalization S A
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M''
inst✝² : IsScalarTower R A M'
f : M →ₗ[R] M'
g : M →ₗ[R] M''
R' : Type u_6
inst✝¹ : CommSemiring R'
inst✝ : Algebra R R'
⊢ IsLocalizedModule S (Algebra.ofId R R').toLinearMap ↔ IsLocalization S R'
state_after: case h.e'_2.h.e'_3
R : Type u_1
inst✝¹³ : CommSemiring R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝¹² : AddCommMonoid M
inst✝¹¹ : AddCommMonoid M'
inst✝¹⁰ : AddCommMonoid M''
A : Type u_5
inst✝⁹ : CommSemiring A
inst✝⁸ : Algebra R A
inst✝⁷ : Module A M'
inst✝⁶ : IsLocalization S A
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M''
inst✝² : IsScalarTower R A M'
f : M →ₗ[R] M'
g : M →ₗ[R] M''
R' : Type u_6
inst✝¹ : CommSemiring R'
inst✝ : Algebra R R'
⊢ S = Algebra.algebraMapSubmonoid R S
tactic: convert isLocalizedModule_iff_isLocalization (S := S) (A := R) (Aₛ := R')
state_before: case h.e'_2.h.e'_3
R : Type u_1
inst✝¹³ : CommSemiring R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝¹² : AddCommMonoid M
inst✝¹¹ : AddCommMonoid M'
inst✝¹⁰ : AddCommMonoid M''
A : Type u_5
inst✝⁹ : CommSemiring A
inst✝⁸ : Algebra R A
inst✝⁷ : Module A M'
inst✝⁶ : IsLocalization S A
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M''
inst✝² : IsScalarTower R A M'
f : M →ₗ[R] M'
g : M →ₗ[R] M''
R' : Type u_6
inst✝¹ : CommSemiring R'
inst✝ : Algebra R R'
⊢ S = Algebra.algebraMapSubmonoid R S
state_after: no goals
tactic: exact (Submonoid.map_id S).symm