ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasureTheory.Measure.rnDeriv_pos'
File: Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SFinite ν
hμν : μ ≪ ν
⊢ ∀ᵐ (x : α) ∂μ, 0 < ν.rnDeriv μ x
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SFinite ν
hμν : μ ≪ ν
⊢ {x | (fun x => 0 < ν.rnDeriv μ x) x} ∈ ae (μ.withDensity (ν.rnDeriv μ))
tactic: refine (absolutelyContinuous_withDensity_rnDeriv hμν).ae_le ?_
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SFinite ν
hμν : μ ≪ ν
⊢ {x | (fun x => 0 < ν.rnDeriv μ x) x} ∈ ae (μ.withDensity (ν.rnDeriv μ))
state_after: case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SFinite ν
hμν : μ ≪ ν
x : α
hx : 0 < (μ.withDensity (ν.rnDeriv μ)).rnDeriv μ x
hx2 : (μ.withDensity (ν.rnDeriv μ)).rnDeriv μ x = ν.rnDeriv μ x
⊢ 0 < ν.rnDeriv μ x
tactic: filter_upwards [Measure.rnDeriv_pos (withDensity_absolutelyContinuous μ (ν.rnDeriv μ)),
    (withDensity_absolutelyContinuous μ (ν.rnDeriv μ)).ae_le
    (Measure.rnDeriv_withDensity μ (Measure.measurable_rnDeriv ν μ))] with x hx hx2
state_before: case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SFinite ν
hμν : μ ≪ ν
x : α
hx : 0 < (μ.withDensity (ν.rnDeriv μ)).rnDeriv μ x
hx2 : (μ.withDensity (ν.rnDeriv μ)).rnDeriv μ x = ν.rnDeriv μ x
⊢ 0 < ν.rnDeriv μ x
state_after: no goals
tactic: rwa [← hx2]
Theorem: expNegInvGlue.contDiff_polynomial_eval_inv_mul
File: Mathlib/Analysis/SpecialFunctions/SmoothTransition.lean

Proof steps:
state_before: n : ℕ∞
p : ℝ[X]
⊢ ContDiff ℝ n fun x => Polynomial.eval x⁻¹ p * expNegInvGlue x
state_after: n : ℕ∞
p : ℝ[X]
m : ℕ
⊢ ContDiff ℝ ↑m fun x => Polynomial.eval x⁻¹ p * expNegInvGlue x
tactic: apply contDiff_all_iff_nat.2 (fun m => ?_) n
state_before: n : ℕ∞
p : ℝ[X]
m : ℕ
⊢ ContDiff ℝ ↑m fun x => Polynomial.eval x⁻¹ p * expNegInvGlue x
state_after: no goals
tactic: induction m generalizing p with
  | zero => exact contDiff_zero.2 <| continuous_polynomial_eval_inv_mul _
  | succ m ihm =>
    refine contDiff_succ_iff_deriv.2 ⟨differentiable_polynomial_eval_inv_mul _, ?_⟩
    convert ihm (X ^ 2 * (p - derivative (R := ℝ) p)) using 2
    exact (hasDerivAt_polynomial_eval_inv_mul p _).deriv
Theorem: SameRay.norm_add
File: Mathlib/Analysis/Normed/Module/Ray.lean

Proof steps:
state_before: E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
x y : E
h : SameRay ℝ x y
⊢ ‖x + y‖ = ‖x‖ + ‖y‖
state_after: case intro.intro.intro.intro.intro.intro.intro
E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
u : E
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
h : SameRay ℝ (a • u) (b • u)
⊢ ‖a • u + b • u‖ = ‖a • u‖ + ‖b • u‖
tactic: rcases h.exists_eq_smul with ⟨u, a, b, ha, hb, -, rfl, rfl⟩
state_before: case intro.intro.intro.intro.intro.intro.intro
E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
u : E
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
h : SameRay ℝ (a • u) (b • u)
⊢ ‖a • u + b • u‖ = ‖a • u‖ + ‖b • u‖
state_after: no goals
tactic: rw [← add_smul, norm_smul_of_nonneg (add_nonneg ha hb), norm_smul_of_nonneg ha,
    norm_smul_of_nonneg hb, add_mul]
Theorem: _private.Mathlib.NumberTheory.Rayleigh.0.Beatty.hit_or_miss
File: Mathlib/NumberTheory/Rayleigh.lean

Proof steps:
state_before: r s : ℝ
hrs : r.IsConjExponent s
j k : ℤ
h : r > 0
⊢ j ∈ {x | ∃ k, beattySeq r k = x} ∨ ∃ k, ↑k < ↑j / r ∧ (↑j + 1) / r ≤ ↑k + 1
state_after: case inl
r s : ℝ
hrs : r.IsConjExponent s
j k : ℤ
h : r > 0
h✝ : (↑⌈(↑j + 1) / r⌉ - 1) * r < ↑j
⊢ j ∈ {x | ∃ k, beattySeq r k = x} ∨ ∃ k, ↑k < ↑j / r ∧ (↑j + 1) / r ≤ ↑k + 1

case inr
r s : ℝ
hrs : r.IsConjExponent s
j k : ℤ
h : r > 0
h✝ : (↑⌈(↑j + 1) / r⌉ - 1) * r ≥ ↑j
⊢ j ∈ {x | ∃ k, beattySeq r k = x} ∨ ∃ k, ↑k < ↑j / r ∧ (↑j + 1) / r ≤ ↑k + 1
tactic: cases lt_or_ge ((⌈(j + 1) / r⌉ - 1) * r) j
Theorem: uniformConcaveOn_zero
File: Mathlib/Analysis/Convex/Strong.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a b m : ℝ
x y : E
f g : E → ℝ
⊢ UniformConcaveOn s 0 f ↔ ConcaveOn ℝ s f
state_after: no goals
tactic: simp [UniformConcaveOn, ConcaveOn]
Theorem: Submodule.sup_dualAnnihilator_le_inf
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
W U V : Submodule R M
⊢ U.dualAnnihilator ⊔ V.dualAnnihilator ≤ (U ⊓ V).dualAnnihilator
state_after: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
W U V : Submodule R M
⊢ U ⊓ V ≤ U.dualAnnihilator.dualCoannihilator ⊓ V.dualAnnihilator.dualCoannihilator
tactic: rw [le_dualAnnihilator_iff_le_dualCoannihilator, dualCoannihilator_sup_eq]
state_before: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
W U V : Submodule R M
⊢ U ⊓ V ≤ U.dualAnnihilator.dualCoannihilator ⊓ V.dualAnnihilator.dualCoannihilator
state_after: no goals
tactic: apply inf_le_inf <;> exact le_dualAnnihilator_dualCoannihilator _
Theorem: CompleteLattice.Independent.subtype_ne_bot_le_finrank_aux
File: Mathlib/LinearAlgebra/Dimension/Finite.lean

Proof steps:
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁹ : Ring R
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
inst✝² : StrongRankCondition R
inst✝¹ : Module.Finite R M
inst✝ : NoZeroSMulDivisors R M
p : ι → Submodule R M
hp : Independent p
⊢ #{ i // p i ≠ ⊥ } ≤ ↑(finrank R M)
state_after: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁹ : Ring R
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
inst✝² : StrongRankCondition R
inst✝¹ : Module.Finite R M
inst✝ : NoZeroSMulDivisors R M
p : ι → Submodule R M
hp : Independent p
⊢ lift.{v, w} #{ i // p i ≠ ⊥ } ≤ lift.{v, w} ↑(finrank R M)
tactic: suffices Cardinal.lift.{v} #{ i // p i ≠ ⊥ } ≤ Cardinal.lift.{v} (finrank R M : Cardinal.{w}) by
    rwa [Cardinal.lift_le] at this
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁹ : Ring R
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
inst✝² : StrongRankCondition R
inst✝¹ : Module.Finite R M
inst✝ : NoZeroSMulDivisors R M
p : ι → Submodule R M
hp : Independent p
⊢ lift.{v, w} #{ i // p i ≠ ⊥ } ≤ lift.{v, w} ↑(finrank R M)
state_after: no goals
tactic: calc
    Cardinal.lift.{v} #{ i // p i ≠ ⊥ } ≤ Cardinal.lift.{w} (Module.rank R M) :=
      hp.subtype_ne_bot_le_rank
    _ = Cardinal.lift.{w} (finrank R M : Cardinal.{v}) := by rw [finrank_eq_rank]
    _ = Cardinal.lift.{v} (finrank R M : Cardinal.{w}) := by simp
Theorem: mem_vectorSpan_pair_rev
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
p₁ p₂ : P
v : V
⊢ v ∈ vectorSpan k {p₁, p₂} ↔ ∃ r, r • (p₂ -ᵥ p₁) = v
state_after: no goals
tactic: rw [vectorSpan_pair_rev, Submodule.mem_span_singleton]
Theorem: CategoryTheory.CosimplicialObject.Augmented.toArrow_obj_hom
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ (𝟭 C).map (point.map η) ≫
      ((fun X => { left := point.obj X, right := (drop.obj X).obj [0], hom := X.hom.app [0] }) Y✝).hom =
    ((fun X => { left := point.obj X, right := (drop.obj X).obj [0], hom := X.hom.app [0] }) X✝).hom ≫
      (𝟭 C).map ((drop.map η).app [0])
state_after: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left ≫ Y✝.hom.app [0] = X✝.hom.app [0] ≫ η.right.app [0]
tactic: dsimp
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left ≫ Y✝.hom.app [0] = X✝.hom.app [0] ≫ η.right.app [0]
state_after: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left ≫ Y✝.hom.app [0] = (X✝.hom ≫ η.right).app [0]
tactic: rw [← NatTrans.comp_app]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left ≫ Y✝.hom.app [0] = (X✝.hom ≫ η.right).app [0]
state_after: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left ≫ Y✝.hom.app [0] = ((const C).map η.left ≫ Y✝.hom).app [0]
tactic: erw [← η.w]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left ≫ Y✝.hom.app [0] = ((const C).map η.left ≫ Y✝.hom).app [0]
state_after: no goals
tactic: rfl
Theorem: pos_of_lt_add_right
File: Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : MulOneClass α
inst✝¹ : LT α
inst✝ : ContravariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b : α
h : a < a * b
⊢ a * 1 < a * b
state_after: no goals
tactic: simpa only [mul_one]
Theorem: Nat.forall_lt_succ
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ (∀ (m : ℕ), m < n + 1 → p m) ↔ (∀ (m : ℕ), m < n → p m) ∧ p n
state_after: no goals
tactic: simp only [Nat.lt_succ_iff, Nat.le_iff_lt_or_eq, or_comm, forall_eq_or_imp, and_comm]
Theorem: Linarith.eq_of_eq_of_eq
File: Mathlib/Tactic/Linarith/Lemmas.lean

Proof steps:
state_before: α : Type u_1
inst✝ : OrderedSemiring α
a b : α
ha : a = 0
hb : b = 0
⊢ a + b = 0
state_after: no goals
tactic: simp [*]
Theorem: Subgroup.relindex_bot_right
File: Mathlib/GroupTheory/Index.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
⊢ H.relindex ⊥ = 1
state_after: no goals
tactic: rw [relindex, subgroupOf_bot_eq_top, index_top]
Theorem: limsup_finset_sup'
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : ConditionallyCompleteLinearOrder β
f : Filter α
F : ι → α → β
s : Finset ι
hs : s.Nonempty
h₁ : autoParam (∀ i ∈ s, IsCoboundedUnder (fun x x_1 => x ≤ x_1) f (F i)) _auto✝
h₂ : autoParam (∀ i ∈ s, IsBoundedUnder (fun x x_1 => x ≤ x_1) f (F i)) _auto✝
⊢ limsup (fun a => s.sup' hs fun i => F i a) f = s.sup' hs fun i => limsup (F i) f
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : ConditionallyCompleteLinearOrder β
f : Filter α
F : ι → α → β
s : Finset ι
hs : s.Nonempty
h₁ : autoParam (∀ i ∈ s, IsCoboundedUnder (fun x x_1 => x ≤ x_1) f (F i)) _auto✝
h₂ : autoParam (∀ i ∈ s, IsBoundedUnder (fun x x_1 => x ≤ x_1) f (F i)) _auto✝
bddsup : IsBoundedUnder (fun x x_1 => x ≤ x_1) f fun a => s.sup' hs fun i => F i a
⊢ limsup (fun a => s.sup' hs fun i => F i a) f = s.sup' hs fun i => limsup (F i) f
tactic: have bddsup := isBoundedUnder_le_finset_sup' hs h₂
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : ConditionallyCompleteLinearOrder β
f : Filter α
F : ι → α → β
s : Finset ι
hs : s.Nonempty
h₁ : autoParam (∀ i ∈ s, IsCoboundedUnder (fun x x_1 => x ≤ x_1) f (F i)) _auto✝
h₂ : autoParam (∀ i ∈ s, IsBoundedUnder (fun x x_1 => x ≤ x_1) f (F i)) _auto✝
bddsup : IsBoundedUnder (fun x x_1 => x ≤ x_1) f fun a => s.sup' hs fun i => F i a
⊢ limsup (fun a => s.sup' hs fun i => F i a) f = s.sup' hs fun i => limsup (F i) f
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : ConditionallyCompleteLinearOrder β
f : Filter α
F : ι → α → β
s : Finset ι
hs : s.Nonempty
h₁ : autoParam (∀ i ∈ s, IsCoboundedUnder (fun x x_1 => x ≤ x_1) f (F i)) _auto✝
h₂ : autoParam (∀ i ∈ s, IsBoundedUnder (fun x x_1 => x ≤ x_1) f (F i)) _auto✝
bddsup : IsBoundedUnder (fun x x_1 => x ≤ x_1) f fun a => s.sup' hs fun i => F i a
⊢ limsup (fun a => s.sup' hs fun i => F i a) f ≤ s.sup' hs fun i => limsup (F i) f

case a
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : ConditionallyCompleteLinearOrder β
f : Filter α
F : ι → α → β
s : Finset ι
hs : s.Nonempty
h₁ : autoParam (∀ i ∈ s, IsCoboundedUnder (fun x x_1 => x ≤ x_1) f (F i)) _auto✝
h₂ : autoParam (∀ i ∈ s, IsBoundedUnder (fun x x_1 => x ≤ x_1) f (F i)) _auto✝
bddsup : IsBoundedUnder (fun x x_1 => x ≤ x_1) f fun a => s.sup' hs fun i => F i a
⊢ (s.sup' hs fun i => limsup (F i) f) ≤ limsup (fun a => s.sup' hs fun i => F i a) f
tactic: apply le_antisymm
Theorem: ProbabilityTheory.geometricPMFReal_nonneg
File: Mathlib/Probability/Distributions/Geometric.lean

Proof steps:
state_before: p : ℝ
n : ℕ
hp_pos : 0 < p
hp_le_one : p ≤ 1
⊢ 0 ≤ geometricPMFReal p n
state_after: p : ℝ
n : ℕ
hp_pos : 0 < p
hp_le_one : p ≤ 1
⊢ 0 ≤ (1 - p) ^ n * p
tactic: rw [geometricPMFReal]
state_before: p : ℝ
n : ℕ
hp_pos : 0 < p
hp_le_one : p ≤ 1
⊢ 0 ≤ (1 - p) ^ n * p
state_after: p : ℝ
n : ℕ
hp_pos : 0 < p
hp_le_one : p ≤ 1
this : 0 ≤ 1 - p
⊢ 0 ≤ (1 - p) ^ n * p
tactic: have : 0 ≤ 1 - p := sub_nonneg.mpr hp_le_one
state_before: p : ℝ
n : ℕ
hp_pos : 0 < p
hp_le_one : p ≤ 1
this : 0 ≤ 1 - p
⊢ 0 ≤ (1 - p) ^ n * p
state_after: no goals
tactic: positivity
Theorem: SeparationQuotient.map_mk_nhdsWithin_preimage
File: Mathlib/Topology/Inseparable.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x✝ y z : X
s✝ : Set X
f g : X → Y
t s : Set (SeparationQuotient X)
x : X
⊢ Filter.map mk (𝓝[mk ⁻¹' s] x) = 𝓝[s] mk x
state_after: no goals
tactic: rw [nhdsWithin, ← comap_principal, Filter.push_pull, nhdsWithin, map_mk_nhds]
Theorem: Int.sq_ne_two_mod_four
File: Mathlib/NumberTheory/PythagoreanTriples.lean

Proof steps:
state_before: z : ℤ
⊢ z * z % 4 ≠ 2
state_after: z : ℤ
⊢ ¬z * z % ↑4 = 2 % ↑4
tactic: suffices ¬z * z % (4 : ℕ) = 2 % (4 : ℕ) by exact this
state_before: z : ℤ
⊢ ¬z * z % ↑4 = 2 % ↑4
state_after: z : ℤ
⊢ ¬↑(z * z) = ↑2
tactic: rw [← ZMod.intCast_eq_intCast_iff']
state_before: z : ℤ
⊢ ¬↑(z * z) = ↑2
state_after: no goals
tactic: simpa using sq_ne_two_fin_zmod_four _
Theorem: X_pow_sub_C_irreducible_of_odd
File: Mathlib/FieldTheory/KummerExtension.lean

Proof steps:
state_before: K : Type u
inst✝ : Field K
n : ℕ
hn : Odd n
a : K
ha : ∀ (p : ℕ), Nat.Prime p → p ∣ n → ∀ (b : K), b ^ p ≠ a
⊢ Irreducible (X ^ n - C a)
state_after: no goals
tactic: induction n using induction_on_primes generalizing K a with
  | h₀ => simp at hn
  | h₁ => simpa using irreducible_X_sub_C a
  | h p n hp IH =>
    rw [mul_comm]
    apply X_pow_mul_sub_C_irreducible
      (X_pow_sub_C_irreducible_of_prime hp (ha p hp (dvd_mul_right _ _)))
    intro E _ _ x hx
    have : IsIntegral K x := not_not.mp fun h ↦ by
      simpa only [degree_zero, degree_X_pow_sub_C hp.pos,
        WithBot.natCast_ne_bot] using congr_arg degree (hx.symm.trans (dif_neg h))
    apply IH (Nat.odd_mul.mp hn).2
    intros q hq hqn b hb
    apply ha q hq (dvd_mul_of_dvd_right hqn p) (Algebra.norm _ b)
    rw [← map_pow, hb, ← adjoin.powerBasis_gen this,
      Algebra.PowerBasis.norm_gen_eq_coeff_zero_minpoly]
    simp [minpoly_gen, hx, hp.ne_zero.symm, (Nat.odd_mul.mp hn).1.neg_pow]
Theorem: CategoryTheory.SplitMono.map_retraction
File: Mathlib/CategoryTheory/EpiMono.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y : C
f : X ⟶ Y
sm : SplitMono f
F : C ⥤ D
⊢ F.map f ≫ F.map sm.retraction = 𝟙 (F.obj X)
state_after: no goals
tactic: rw [← Functor.map_comp, SplitMono.id, Functor.map_id]
Theorem: IsCompact.elim_directed_family_closed
File: Mathlib/Topology/Compactness/Compact.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι✝ : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t✝ : Set X
ι : Type v
hι : Nonempty ι
hs : IsCompact s
t : ι → Set X
htc : ∀ (i : ι), IsClosed (t i)
hst : s ∩ ⋂ i, t i = ∅
hdt : Directed (fun x x_1 => x ⊇ x_1) t
⊢ s ⊆ ⋃ i, (compl ∘ t) i
state_after: no goals
tactic: simpa only [subset_def, not_forall, eq_empty_iff_forall_not_mem, mem_iUnion, exists_prop,
          mem_inter_iff, not_and, iff_self_iff, mem_iInter, mem_compl_iff] using hst
state_before: X : Type u
Y : Type v
ι✝ : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t✝¹ : Set X
ι : Type v
hι : Nonempty ι
hs : IsCompact s
t✝ : ι → Set X
htc : ∀ (i : ι), IsClosed (t✝ i)
hst : s ∩ ⋂ i, t✝ i = ∅
hdt : Directed (fun x x_1 => x ⊇ x_1) t✝
t : ι
ht : s ⊆ (compl ∘ t✝) t
⊢ s ∩ t✝ t = ∅
state_after: no goals
tactic: simpa only [subset_def, not_forall, eq_empty_iff_forall_not_mem, mem_iUnion, exists_prop,
      mem_inter_iff, not_and, iff_self_iff, mem_iInter, mem_compl_iff] using ht
Theorem: Filter.iInf_le_liminf
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteLattice α
f : Filter β
u : β → α
⊢ IsCoboundedUnder (fun x x_1 => x ≥ x_1) f u
state_after: no goals
tactic: isBoundedDefault
Theorem: Filter.isBoundedUnder_le_sum
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
α : Type u_6
f : Filter α
inst✝⁴ : f.NeBot
R : Type u_7
inst✝³ : Preorder R
κ : Type u_8
inst✝² : AddCommMonoid R
inst✝¹ : CovariantClass R R (fun a b => a + b) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass R R (fun a b => b + a) fun x x_1 => x ≤ x_1
u : κ → α → R
s : Finset κ
⊢ (∀ k ∈ s, IsBoundedUnder (fun x x_1 => x ≤ x_1) f (u k)) → IsBoundedUnder (fun x x_1 => x ≤ x_1) f (∑ k ∈ s, u k)
state_after: no goals
tactic: apply isBoundedUnder_sum (fun _ _ ↦ isBoundedUnder_le_add) le_rfl
Theorem: AdicCompletion.map_ext'
File: Mathlib/RingTheory/AdicCompletion/Functoriality.lean

Proof steps:
state_before: R : Type u_1
inst✝⁸ : CommRing R
I : Ideal R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
N : Type u_3
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
P : Type u_4
inst✝³ : AddCommGroup P
inst✝² : Module R P
T : Type u_5
inst✝¹ : AddCommGroup T
inst✝ : Module (AdicCompletion I R) T
f g : AdicCompletion I M →ₗ[AdicCompletion I R] T
h : ∀ (a : AdicCauchySequence I M), f ((mk I M) a) = g ((mk I M) a)
⊢ f = g
state_after: case h
R : Type u_1
inst✝⁸ : CommRing R
I : Ideal R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
N : Type u_3
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
P : Type u_4
inst✝³ : AddCommGroup P
inst✝² : Module R P
T : Type u_5
inst✝¹ : AddCommGroup T
inst✝ : Module (AdicCompletion I R) T
f g : AdicCompletion I M →ₗ[AdicCompletion I R] T
h : ∀ (a : AdicCauchySequence I M), f ((mk I M) a) = g ((mk I M) a)
x : AdicCompletion I M
⊢ f x = g x
tactic: ext x
state_before: case h
R : Type u_1
inst✝⁸ : CommRing R
I : Ideal R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
N : Type u_3
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
P : Type u_4
inst✝³ : AddCommGroup P
inst✝² : Module R P
T : Type u_5
inst✝¹ : AddCommGroup T
inst✝ : Module (AdicCompletion I R) T
f g : AdicCompletion I M →ₗ[AdicCompletion I R] T
h : ∀ (a : AdicCauchySequence I M), f ((mk I M) a) = g ((mk I M) a)
x : AdicCompletion I M
⊢ f x = g x
state_after: no goals
tactic: apply induction_on I M x (fun a ↦ h a)
Theorem: Nat.primeCounting'_add_le
File: Mathlib/NumberTheory/PrimeCounting.lean

Proof steps:
state_before: a k : ℕ
h0 : 0 < a
h1 : a < k
n : ℕ
⊢ π' (k + n) ≤ (filter Prime (range k)).card + (filter Prime (Ico k (k + n))).card
state_after: a k : ℕ
h0 : 0 < a
h1 : a < k
n : ℕ
⊢ (filter Prime (Ico 0 k) ∪ filter Prime (Ico k (k + n))).card ≤
    (filter Prime (Ico 0 k)).card + (filter Prime (Ico k (k + n))).card
tactic: rw [primeCounting', count_eq_card_filter_range, range_eq_Ico, ←
        Ico_union_Ico_eq_Ico (zero_le k) le_self_add, filter_union]
state_before: a k : ℕ
h0 : 0 < a
h1 : a < k
n : ℕ
⊢ (filter Prime (Ico 0 k) ∪ filter Prime (Ico k (k + n))).card ≤
    (filter Prime (Ico 0 k)).card + (filter Prime (Ico k (k + n))).card
state_after: no goals
tactic: apply card_union_le
state_before: a k : ℕ
h0 : 0 < a
h1 : a < k
n : ℕ
⊢ (filter Prime (range k)).card + (filter Prime (Ico k (k + n))).card ≤ π' k + (filter Prime (Ico k (k + n))).card
state_after: no goals
tactic: rw [primeCounting', count_eq_card_filter_range]
state_before: a k : ℕ
h0 : 0 < a
h1 : a < k
n : ℕ
⊢ π' k + (filter Prime (Ico k (k + n))).card ≤ π' k + (filter a.Coprime (Ico k (k + n))).card
state_after: a k : ℕ
h0 : 0 < a
h1 : a < k
n : ℕ
⊢ filter Prime (Ico k (k + n)) ⊆ filter a.Coprime (Ico k (k + n))
tactic: refine add_le_add_left (card_le_card ?_) k.primeCounting'
state_before: a k : ℕ
h0 : 0 < a
h1 : a < k
n : ℕ
⊢ filter Prime (Ico k (k + n)) ⊆ filter a.Coprime (Ico k (k + n))
state_after: a k : ℕ
h0 : 0 < a
h1 : a < k
n : ℕ
⊢ ∀ ⦃x : ℕ⦄, k ≤ x → x < k + n → Prime x → (k ≤ x ∧ x < k + n) ∧ a.Coprime x
tactic: simp only [subset_iff, and_imp, mem_filter, mem_Ico]
state_before: a k : ℕ
h0 : 0 < a
h1 : a < k
n : ℕ
⊢ ∀ ⦃x : ℕ⦄, k ≤ x → x < k + n → Prime x → (k ≤ x ∧ x < k + n) ∧ a.Coprime x
state_after: a k : ℕ
h0 : 0 < a
h1 : a < k
n p : ℕ
succ_k_le_p : k ≤ p
p_lt_n : p < k + n
p_prime : Prime p
⊢ (k ≤ p ∧ p < k + n) ∧ a.Coprime p
tactic: intro p succ_k_le_p p_lt_n p_prime
state_before: a k : ℕ
h0 : 0 < a
h1 : a < k
n p : ℕ
succ_k_le_p : k ≤ p
p_lt_n : p < k + n
p_prime : Prime p
⊢ (k ≤ p ∧ p < k + n) ∧ a.Coprime p
state_after: case left
a k : ℕ
h0 : 0 < a
h1 : a < k
n p : ℕ
succ_k_le_p : k ≤ p
p_lt_n : p < k + n
p_prime : Prime p
⊢ k ≤ p ∧ p < k + n

case right
a k : ℕ
h0 : 0 < a
h1 : a < k
n p : ℕ
succ_k_le_p : k ≤ p
p_lt_n : p < k + n
p_prime : Prime p
⊢ a.Coprime p
tactic: constructor
state_before: a k : ℕ
h0 : 0 < a
h1 : a < k
n : ℕ
⊢ π' k + (filter a.Coprime (Ico k (k + n))).card ≤ π' k + φ a * (n / a + 1)
state_after: a k : ℕ
h0 : 0 < a
h1 : a < k
n : ℕ
⊢ (filter a.Coprime (Ico k (k + n))).card ≤ φ a * (n / a + 1)
tactic: rw [add_le_add_iff_left]
state_before: a k : ℕ
h0 : 0 < a
h1 : a < k
n : ℕ
⊢ (filter a.Coprime (Ico k (k + n))).card ≤ φ a * (n / a + 1)
state_after: no goals
tactic: exact Ico_filter_coprime_le k n h0
Theorem: AddSubgroup.rank_congr
File: Mathlib/GroupTheory/Finiteness.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
inst✝⁵ : Monoid M
inst✝⁴ : AddMonoid N
G : Type u_3
H✝ : Type u_4
inst✝³ : Group G
inst✝² : AddGroup H✝
H K : Subgroup G
inst✝¹ : Group.FG ↥H
inst✝ : Group.FG ↥K
h : H = K
⊢ Group.rank ↥H = Group.rank ↥K
state_after: M : Type u_1
N : Type u_2
inst✝⁵ : Monoid M
inst✝⁴ : AddMonoid N
G : Type u_3
H✝ : Type u_4
inst✝³ : Group G
inst✝² : AddGroup H✝
H : Subgroup G
inst✝¹ inst✝ : Group.FG ↥H
⊢ Group.rank ↥H = Group.rank ↥H
tactic: subst h
state_before: M : Type u_1
N : Type u_2
inst✝⁵ : Monoid M
inst✝⁴ : AddMonoid N
G : Type u_3
H✝ : Type u_4
inst✝³ : Group G
inst✝² : AddGroup H✝
H : Subgroup G
inst✝¹ inst✝ : Group.FG ↥H
⊢ Group.rank ↥H = Group.rank ↥H
state_after: no goals
tactic: rfl
Theorem: AlgebraicGeometry.disjointGlueData'_t
File: Mathlib/AlgebraicGeometry/Limits.lean

Proof steps:
state_before: ι : Type u
f : ι → Scheme
x✝¹ x✝ : ι
⊢ ∀ (h : x✝¹ ≠ x✝), Mono ((fun x x_1 x_2 => (f x).emptyTo) x✝¹ x✝ h)
state_after: ι : Type u
f : ι → Scheme
x✝¹ x✝ : ι
⊢ x✝¹ ≠ x✝ → Mono (f x✝¹).emptyTo
tactic: dsimp only
state_before: ι : Type u
f : ι → Scheme
x✝¹ x✝ : ι
⊢ x✝¹ ≠ x✝ → Mono (f x✝¹).emptyTo
state_after: no goals
tactic: infer_instance