ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasureTheory.Content.contentRegular_exists_compact
File: Mathlib/MeasureTheory/Measure/Content.lean

Proof steps:
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
H : μ.ContentRegular
K : Compacts G
ε : ℝ≥0
hε : ε ≠ 0
⊢ ∃ K', K.carrier ⊆ interior K'.carrier ∧ (fun s => ↑(μ.toFun s)) K' ≤ (fun s => ↑(μ.toFun s)) K + ↑ε
state_after: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
H : μ.ContentRegular
K : Compacts G
ε : ℝ≥0
hε : ε ≠ 0
hc : ¬∃ K', K.carrier ⊆ interior K'.carrier ∧ (fun s => ↑(μ.toFun s)) K' ≤ (fun s => ↑(μ.toFun s)) K + ↑ε
⊢ False
tactic: by_contra hc
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
H : μ.ContentRegular
K : Compacts G
ε : ℝ≥0
hε : ε ≠ 0
hc : ¬∃ K', K.carrier ⊆ interior K'.carrier ∧ (fun s => ↑(μ.toFun s)) K' ≤ (fun s => ↑(μ.toFun s)) K + ↑ε
⊢ False
state_after: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
H : μ.ContentRegular
K : Compacts G
ε : ℝ≥0
hε : ε ≠ 0
hc : ∀ (x : Compacts G), K.carrier ⊆ interior x.carrier → ↑(μ.toFun K) + ↑ε < ↑(μ.toFun x)
⊢ False
tactic: simp only [not_exists, not_and, not_le] at hc
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
H : μ.ContentRegular
K : Compacts G
ε : ℝ≥0
hε : ε ≠ 0
hc : ∀ (x : Compacts G), K.carrier ⊆ interior x.carrier → ↑(μ.toFun K) + ↑ε < ↑(μ.toFun x)
⊢ False
state_after: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
H : μ.ContentRegular
K : Compacts G
ε : ℝ≥0
hε : ε ≠ 0
hc : ∀ (x : Compacts G), K.carrier ⊆ interior x.carrier → ↑(μ.toFun K) + ↑ε < ↑(μ.toFun x)
lower_bound_iInf : (fun s => ↑(μ.toFun s)) K + ↑ε ≤ ⨅ K', ⨅ (_ : ↑K ⊆ interior ↑K'), (fun s => ↑(μ.toFun s)) K'
⊢ False
tactic: have lower_bound_iInf : μ K + ε ≤
      ⨅ (K' : TopologicalSpace.Compacts G) (_ : (K : Set G) ⊆ interior (K' : Set G)), μ K' :=
    le_iInf fun K' => le_iInf fun K'_hyp => le_of_lt (hc K' K'_hyp)
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
H : μ.ContentRegular
K : Compacts G
ε : ℝ≥0
hε : ε ≠ 0
hc : ∀ (x : Compacts G), K.carrier ⊆ interior x.carrier → ↑(μ.toFun K) + ↑ε < ↑(μ.toFun x)
lower_bound_iInf : (fun s => ↑(μ.toFun s)) K + ↑ε ≤ ⨅ K', ⨅ (_ : ↑K ⊆ interior ↑K'), (fun s => ↑(μ.toFun s)) K'
⊢ False
state_after: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
H : μ.ContentRegular
K : Compacts G
ε : ℝ≥0
hε : ε ≠ 0
hc : ∀ (x : Compacts G), K.carrier ⊆ interior x.carrier → ↑(μ.toFun K) + ↑ε < ↑(μ.toFun x)
lower_bound_iInf : (fun s => ↑(μ.toFun s)) K + ↑ε ≤ (fun s => ↑(μ.toFun s)) K
⊢ False
tactic: rw [← H] at lower_bound_iInf
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
H : μ.ContentRegular
K : Compacts G
ε : ℝ≥0
hε : ε ≠ 0
hc : ∀ (x : Compacts G), K.carrier ⊆ interior x.carrier → ↑(μ.toFun K) + ↑ε < ↑(μ.toFun x)
lower_bound_iInf : (fun s => ↑(μ.toFun s)) K + ↑ε ≤ (fun s => ↑(μ.toFun s)) K
⊢ False
state_after: no goals
tactic: exact (lt_self_iff_false (μ K)).mp (lt_of_le_of_lt' lower_bound_iInf
    (ENNReal.lt_add_right (ne_top_of_lt (μ.lt_top K)) (ENNReal.coe_ne_zero.mpr hε)))
Theorem: Filter.comap_abs_atTop
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : LinearOrderedAddCommGroup α
⊢ comap abs atTop = atBot ⊔ atTop
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : LinearOrderedAddCommGroup α
⊢ ∀ (i' : α × α), True ∧ True → ∃ i, True ∧ abs ⁻¹' Ici i ⊆ Iic i'.1 ∪ Ici i'.2
tactic: refine
    le_antisymm (((atTop_basis.comap _).le_basis_iff (atBot_basis.sup atTop_basis)).2 ?_)
      (sup_le tendsto_abs_atBot_atTop.le_comap tendsto_abs_atTop_atTop.le_comap)
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : LinearOrderedAddCommGroup α
⊢ ∀ (i' : α × α), True ∧ True → ∃ i, True ∧ abs ⁻¹' Ici i ⊆ Iic i'.1 ∪ Ici i'.2
state_after: case mk
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : LinearOrderedAddCommGroup α
a b : α
⊢ ∃ i, True ∧ abs ⁻¹' Ici i ⊆ Iic (a, b).1 ∪ Ici (a, b).2
tactic: rintro ⟨a, b⟩ -
state_before: case mk
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : LinearOrderedAddCommGroup α
a b : α
⊢ ∃ i, True ∧ abs ⁻¹' Ici i ⊆ Iic (a, b).1 ∪ Ici (a, b).2
state_after: case mk
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : LinearOrderedAddCommGroup α
a b x : α
hx : x ∈ abs ⁻¹' Ici (max (-a) b)
⊢ x ∈ Iic (a, b).1 ∪ Ici (a, b).2
tactic: refine ⟨max (-a) b, trivial, fun x hx => ?_⟩
state_before: case mk
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : LinearOrderedAddCommGroup α
a b x : α
hx : x ∈ abs ⁻¹' Ici (max (-a) b)
⊢ x ∈ Iic (a, b).1 ∪ Ici (a, b).2
state_after: case mk
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : LinearOrderedAddCommGroup α
a b x : α
hx : x ≤ a ∧ x ≤ -b ∨ -a ≤ x ∧ b ≤ x
⊢ x ∈ Iic (a, b).1 ∪ Ici (a, b).2
tactic: rw [mem_preimage, mem_Ici, le_abs', max_le_iff, ← min_neg_neg, le_min_iff, neg_neg] at hx
state_before: case mk
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : LinearOrderedAddCommGroup α
a b x : α
hx : x ≤ a ∧ x ≤ -b ∨ -a ≤ x ∧ b ≤ x
⊢ x ∈ Iic (a, b).1 ∪ Ici (a, b).2
state_after: no goals
tactic: exact hx.imp And.left And.right
Theorem: Filter.HasBasis.uniformity_of_nhds_one_inv_mul
File: Mathlib/Topology/Algebra/UniformGroup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : UniformSpace α
inst✝¹ : Group α
inst✝ : UniformGroup α
ι : Sort u_3
p : ι → Prop
U : ι → Set α
h : (𝓝 1).HasBasis p U
⊢ (𝓤 α).HasBasis p fun i => {x | x.1⁻¹ * x.2 ∈ U i}
state_after: α : Type u_1
β : Type u_2
inst✝² : UniformSpace α
inst✝¹ : Group α
inst✝ : UniformGroup α
ι : Sort u_3
p : ι → Prop
U : ι → Set α
h : (𝓝 1).HasBasis p U
⊢ (Filter.comap (fun x => x.1⁻¹ * x.2) (𝓝 1)).HasBasis p fun i => {x | x.1⁻¹ * x.2 ∈ U i}
tactic: rw [uniformity_eq_comap_inv_mul_nhds_one]
state_before: α : Type u_1
β : Type u_2
inst✝² : UniformSpace α
inst✝¹ : Group α
inst✝ : UniformGroup α
ι : Sort u_3
p : ι → Prop
U : ι → Set α
h : (𝓝 1).HasBasis p U
⊢ (Filter.comap (fun x => x.1⁻¹ * x.2) (𝓝 1)).HasBasis p fun i => {x | x.1⁻¹ * x.2 ∈ U i}
state_after: no goals
tactic: exact h.comap _
Theorem: Cubic.prod_X_sub_C_eq
File: Mathlib/Algebra/CubicDiscriminant.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝¹ : Semiring R
inst✝ : CommRing S
x y z : S
⊢ (X - C x) * (X - C y) * (X - C z) =
    { a := 1, b := -(x + y + z), c := x * y + x * z + y * z, d := -(x * y * z) }.toPoly
state_after: no goals
tactic: rw [← one_mul <| X - C x, ← C_1, C_mul_prod_X_sub_C_eq, one_mul, one_mul, one_mul]
Theorem: AkraBazziRecurrence.bi_min_div_two_pos
File: Mathlib/Computability/AkraBazzi/AkraBazzi.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ 0 < 2
state_after: no goals
tactic: norm_num
Theorem: CategoryTheory.rightDualIso_id
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y : C
p : ExactPairing X Y
⊢ rightDualIso p p = Iso.refl Y
state_after: case w
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y : C
p : ExactPairing X Y
⊢ (rightDualIso p p).hom = (Iso.refl Y).hom
tactic: ext
state_before: case w
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y : C
p : ExactPairing X Y
⊢ (rightDualIso p p).hom = (Iso.refl Y).hom
state_after: no goals
tactic: simp only [rightDualIso, Iso.refl_hom, @rightAdjointMate_id _ _ _ _ ⟨Y⟩]
Theorem: Set.toFinset_Ioi
File: Mathlib/Order/Interval/Finset/Defs.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
inst✝⁴ : Preorder α✝
p : α✝ → Prop
inst✝³ : DecidablePred p
y : α✝
α : Type u_3
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrderTop α
a : α
inst✝ : Fintype ↑(Ioi a)
⊢ (Ioi a).toFinset = Finset.Ioi a
state_after: case a
α✝ : Type u_1
β : Type u_2
inst✝⁴ : Preorder α✝
p : α✝ → Prop
inst✝³ : DecidablePred p
y : α✝
α : Type u_3
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrderTop α
a : α
inst✝ : Fintype ↑(Ioi a)
a✝ : α
⊢ a✝ ∈ (Ioi a).toFinset ↔ a✝ ∈ Finset.Ioi a
tactic: ext
state_before: case a
α✝ : Type u_1
β : Type u_2
inst✝⁴ : Preorder α✝
p : α✝ → Prop
inst✝³ : DecidablePred p
y : α✝
α : Type u_3
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrderTop α
a : α
inst✝ : Fintype ↑(Ioi a)
a✝ : α
⊢ a✝ ∈ (Ioi a).toFinset ↔ a✝ ∈ Finset.Ioi a
state_after: no goals
tactic: simp
Theorem: Nat.Prime.not_coprime_iff_dvd
File: Mathlib/Data/Nat/Prime/Basic.lean

Proof steps:
state_before: n✝ m n : ℕ
⊢ ¬m.Coprime n ↔ ∃ p, Prime p ∧ p ∣ m ∧ p ∣ n
state_after: case mp
n✝ m n : ℕ
⊢ ¬m.Coprime n → ∃ p, Prime p ∧ p ∣ m ∧ p ∣ n

case mpr
n✝ m n : ℕ
⊢ (∃ p, Prime p ∧ p ∣ m ∧ p ∣ n) → ¬m.Coprime n
tactic: apply Iff.intro
Theorem: Complex.cosh_add_sinh
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℂ
⊢ cosh x + sinh x = cexp x
state_after: no goals
tactic: rw [← mul_right_inj' (two_ne_zero' ℂ), mul_add, two_cosh, two_sinh, add_add_sub_cancel, two_mul]
Theorem: Complex.one_div_Gamma_eq_self_mul_one_div_Gamma_add_one
File: Mathlib/Analysis/SpecialFunctions/Gamma/Beta.lean

Proof steps:
state_before: s : ℂ
⊢ (Gamma s)⁻¹ = s * (Gamma (s + 1))⁻¹
state_after: case inl
s : ℂ
h : s ≠ 0
⊢ (Gamma s)⁻¹ = s * (Gamma (s + 1))⁻¹

case inr

⊢ (Gamma 0)⁻¹ = 0 * (Gamma (0 + 1))⁻¹
tactic: rcases ne_or_eq s 0 with (h | rfl)
Theorem: val_addUnitsCenterToCenterAddUnits_apply_coe
File: Mathlib/GroupTheory/Submonoid/Center.lean

Proof steps:
state_before: M : Type ?u.3475
inst✝ : Monoid M
u : (↥(Submonoid.center M))ˣ
r : Mˣ
⊢ ↑(r * (Units.map (Submonoid.center M).subtype) u) = ↑((Units.map (Submonoid.center M).subtype) u * r)
state_after: no goals
tactic: rw [Units.val_mul, Units.coe_map, Submonoid.coe_subtype, Units.val_mul, Units.coe_map,
          Submonoid.coe_subtype, u.1.prop.comm r]
Theorem: CategoryTheory.Arrow.hom.congr_right
File: Mathlib/CategoryTheory/Comma/Arrow.lean

Proof steps:
state_before: T : Type u
inst✝ : Category.{v, u} T
f g : Arrow T
φ₁ φ₂ : f ⟶ g
h : φ₁ = φ₂
⊢ φ₁.right = φ₂.right
state_after: no goals
tactic: rw [h]
Theorem: Fin.list_succ_last
File: .lake/packages/batteries/Batteries/Data/Fin/Lemmas.lean

Proof steps:
state_before: n : Nat
⊢ list (n + 1) = List.map castSucc (list n) ++ [last n]
state_after: n : Nat
⊢ 0 :: List.map succ (list n) = List.map castSucc (list n) ++ [last n]
tactic: rw [list_succ]
state_before: n : Nat
⊢ 0 :: List.map succ (list n) = List.map castSucc (list n) ++ [last n]
state_after: no goals
tactic: induction n with
  | zero => rfl
  | succ n ih =>
    rw [list_succ, List.map_cons castSucc, ih]
    simp [Function.comp_def, succ_castSucc]
Theorem: Fin.val_add_eq_ite
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n✝ m n : ℕ
a b : Fin n
⊢ ↑(a + b) = if n ≤ ↑a + ↑b then ↑a + ↑b - n else ↑a + ↑b
state_after: no goals
tactic: rw [Fin.val_add, Nat.add_mod_eq_ite, Nat.mod_eq_of_lt (show ↑a < n from a.2),
    Nat.mod_eq_of_lt (show ↑b < n from b.2)]
Theorem: Cardinal.mk_set_nat
File: Mathlib/SetTheory/Cardinal/Continuum.lean

Proof steps:
state_before: ⊢ #(Set ℕ) = 𝔠
state_after: no goals
tactic: simp
Theorem: QuaternionAlgebra.Basis.lift_smul
File: Mathlib/Algebra/QuaternionBasis.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
c₁ c₂ : R
q : Basis A c₁ c₂
r : R
x : ℍ[R,c₁,c₂]
⊢ q.lift (r • x) = r • q.lift x
state_after: no goals
tactic: simp [lift, mul_smul, ← Algebra.smul_def]
Theorem: cmpUsing_eq_eq
File: Mathlib/Data/Ordering/Lemmas.lean

Proof steps:
state_before: α : Type u
lt : α → α → Prop
inst✝ : DecidableRel lt
a b : α
⊢ cmpUsing lt a b = Ordering.eq ↔ ¬lt a b ∧ ¬lt b a
state_after: no goals
tactic: simp
Theorem: CategoryTheory.MonoidalOpposite.mopBraidedFunctor_map_unmop
File: Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝⁸ : Category.{v₁, u₁} C
inst✝⁷ : MonoidalCategory C
inst✝⁶ : BraidedCategory C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : MonoidalCategory D
inst✝³ : BraidedCategory D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
inst✝¹ : MonoidalCategory E
inst✝ : BraidedCategory E
X Y Z : C
⊢ (fun X Y => (β_ { unmop := X } { unmop := Y }).hom) X Y ▷ __spread✝⁻⁰.obj Z ≫
      (fun X Y => (β_ { unmop := X } { unmop := Y }).hom) (X ⊗ Y) Z ≫ __spread✝⁻⁰.map (α_ X Y Z).hom =
    (α_ (__spread✝⁻⁰.obj X) (__spread✝⁻⁰.obj Y) (__spread✝⁻⁰.obj Z)).hom ≫
      __spread✝⁻⁰.obj X ◁ (fun X Y => (β_ { unmop := X } { unmop := Y }).hom) Y Z ≫
        (fun X Y => (β_ { unmop := X } { unmop := Y }).hom) X (Y ⊗ Z)
state_after: no goals
tactic: simp [← yang_baxter_assoc]
Theorem: div_le_iff_le_mul'
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : CommGroup α
inst✝¹ : LE α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a / b ≤ c ↔ a ≤ b * c
state_after: no goals
tactic: rw [div_le_iff_le_mul, mul_comm]
Theorem: QuotientGroup.map_map
File: Mathlib/GroupTheory/QuotientGroup.lean

Proof steps:
state_before: G : Type u
inst✝⁵ : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝⁴ : Group H
M✝ : Type x
inst✝³ : Monoid M✝
I : Type u_1
inst✝² : Group I
M : Subgroup H
O : Subgroup I
inst✝¹ : M.Normal
inst✝ : O.Normal
f : G →* H
g : H →* I
hf : N ≤ Subgroup.comap f M
hg : M ≤ Subgroup.comap g O
hgf : optParam (N ≤ Subgroup.comap (g.comp f) O) ⋯
x : G ⧸ N
⊢ (map M O g hg) ((map N M f hf) x) = (map N O (g.comp f) hgf) x
state_after: G : Type u
inst✝⁵ : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝⁴ : Group H
M✝ : Type x
inst✝³ : Monoid M✝
I : Type u_1
inst✝² : Group I
M : Subgroup H
O : Subgroup I
inst✝¹ : M.Normal
inst✝ : O.Normal
f : G →* H
g : H →* I
hf : N ≤ Subgroup.comap f M
hg : M ≤ Subgroup.comap g O
hgf : optParam (N ≤ Subgroup.comap (g.comp f) O) ⋯
x✝ : G ⧸ N
x : G
⊢ (map M O g hg) ((map N M f hf) ↑x) = (map N O (g.comp f) hgf) ↑x
tactic: refine induction_on' x fun x => ?_
state_before: G : Type u
inst✝⁵ : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝⁴ : Group H
M✝ : Type x
inst✝³ : Monoid M✝
I : Type u_1
inst✝² : Group I
M : Subgroup H
O : Subgroup I
inst✝¹ : M.Normal
inst✝ : O.Normal
f : G →* H
g : H →* I
hf : N ≤ Subgroup.comap f M
hg : M ≤ Subgroup.comap g O
hgf : optParam (N ≤ Subgroup.comap (g.comp f) O) ⋯
x✝ : G ⧸ N
x : G
⊢ (map M O g hg) ((map N M f hf) ↑x) = (map N O (g.comp f) hgf) ↑x
state_after: no goals
tactic: simp only [map_mk, MonoidHom.comp_apply]
Theorem: Polynomial.cyclotomic'_two
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

Proof steps:
state_before: R✝ : Type u_1
inst✝⁴ : CommRing R✝
inst✝³ : IsDomain R✝
R : Type u_2
inst✝² : CommRing R
inst✝¹ : IsDomain R
p : ℕ
inst✝ : CharP R p
hp : p ≠ 2
⊢ cyclotomic' 2 R = X + 1
state_after: R✝ : Type u_1
inst✝⁴ : CommRing R✝
inst✝³ : IsDomain R✝
R : Type u_2
inst✝² : CommRing R
inst✝¹ : IsDomain R
p : ℕ
inst✝ : CharP R p
hp : p ≠ 2
⊢ ∏ μ ∈ primitiveRoots 2 R, (X - C μ) = X + 1
tactic: rw [cyclotomic']
state_before: R✝ : Type u_1
inst✝⁴ : CommRing R✝
inst✝³ : IsDomain R✝
R : Type u_2
inst✝² : CommRing R
inst✝¹ : IsDomain R
p : ℕ
inst✝ : CharP R p
hp : p ≠ 2
⊢ ∏ μ ∈ primitiveRoots 2 R, (X - C μ) = X + 1
state_after: R✝ : Type u_1
inst✝⁴ : CommRing R✝
inst✝³ : IsDomain R✝
R : Type u_2
inst✝² : CommRing R
inst✝¹ : IsDomain R
p : ℕ
inst✝ : CharP R p
hp : p ≠ 2
prim_root_two : primitiveRoots 2 R = {-1}
⊢ ∏ μ ∈ primitiveRoots 2 R, (X - C μ) = X + 1
tactic: have prim_root_two : primitiveRoots 2 R = {(-1 : R)} := by
    simp only [Finset.eq_singleton_iff_unique_mem, mem_primitiveRoots two_pos]
    exact ⟨IsPrimitiveRoot.neg_one p hp, fun x => IsPrimitiveRoot.eq_neg_one_of_two_right⟩
state_before: R✝ : Type u_1
inst✝⁴ : CommRing R✝
inst✝³ : IsDomain R✝
R : Type u_2
inst✝² : CommRing R
inst✝¹ : IsDomain R
p : ℕ
inst✝ : CharP R p
hp : p ≠ 2
prim_root_two : primitiveRoots 2 R = {-1}
⊢ ∏ μ ∈ primitiveRoots 2 R, (X - C μ) = X + 1
state_after: no goals
tactic: simp only [prim_root_two, Finset.prod_singleton, RingHom.map_neg, RingHom.map_one, sub_neg_eq_add]
Theorem: Commute.isNilpotent_mul_right_iff
File: Mathlib/RingTheory/Nilpotent/Basic.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
x y : R
inst✝ : Semiring R
h_comm : Commute x y
hx : x ∈ nonZeroDivisorsRight R
⊢ IsNilpotent (x * y) ↔ IsNilpotent y
state_after: R : Type u_1
S : Type u_2
x y : R
inst✝ : Semiring R
h_comm : Commute x y
hx : x ∈ nonZeroDivisorsRight R
⊢ IsNilpotent (x * y) → IsNilpotent y
tactic: refine ⟨?_, h_comm.isNilpotent_mul_right⟩
state_before: R : Type u_1
S : Type u_2
x y : R
inst✝ : Semiring R
h_comm : Commute x y
hx : x ∈ nonZeroDivisorsRight R
⊢ IsNilpotent (x * y) → IsNilpotent y
state_after: case intro
R : Type u_1
S : Type u_2
x y : R
inst✝ : Semiring R
h_comm : Commute x y
hx : x ∈ nonZeroDivisorsRight R
k : ℕ
hk : (x * y) ^ k = 0
⊢ IsNilpotent y
tactic: rintro ⟨k, hk⟩
state_before: case intro
R : Type u_1
S : Type u_2
x y : R
inst✝ : Semiring R
h_comm : Commute x y
hx : x ∈ nonZeroDivisorsRight R
k : ℕ
hk : (x * y) ^ k = 0
⊢ IsNilpotent y
state_after: case intro
R : Type u_1
S : Type u_2
x y : R
inst✝ : Semiring R
h_comm : Commute x y
hx : x ∈ nonZeroDivisorsRight R
k : ℕ
hk : x ^ k * y ^ k = 0
⊢ IsNilpotent y
tactic: rw [mul_pow h_comm] at hk
state_before: case intro
R : Type u_1
S : Type u_2
x y : R
inst✝ : Semiring R
h_comm : Commute x y
hx : x ∈ nonZeroDivisorsRight R
k : ℕ
hk : x ^ k * y ^ k = 0
⊢ IsNilpotent y
state_after: no goals
tactic: exact ⟨k, (nonZeroDivisorsRight R).pow_mem hx k _ hk⟩
Theorem: WeierstrassCurve.coeff_Ψ₃_ne_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
h : 3 ≠ 0
⊢ W.Ψ₃.coeff 4 ≠ 0
state_after: no goals
tactic: rwa [coeff_Ψ₃]
Theorem: Filter.HasBasis.filter_eq
File: Mathlib/Order/Filter/Bases.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
h : l.HasBasis p s
⊢ ⋯.filter = l
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
h : l.HasBasis p s
U : Set α
⊢ U ∈ ⋯.filter ↔ U ∈ l
tactic: ext U
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
h : l.HasBasis p s
U : Set α
⊢ U ∈ ⋯.filter ↔ U ∈ l
state_after: no goals
tactic: simp [h.mem_iff, IsBasis.mem_filter_iff]
Theorem: CategoryTheory.Limits.pullbackSymmetry_hom_comp_snd
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/HasPullback.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : HasPullback f g
⊢ (pullbackSymmetry f g).hom ≫ pullback.snd g f = pullback.fst f g
state_after: no goals
tactic: simp [pullbackSymmetry]
Theorem: Mathlib.Vector.get_ofFn
File: Mathlib/Data/Vector/Basic.lean

Proof steps:
state_before: n✝ : ℕ
α : Type u_1
n : ℕ
f : Fin n → α
i : Fin n
⊢ (ofFn f).get i = f i
state_after: n✝ : ℕ
α : Type u_1
n : ℕ
f : Fin n → α
i : Fin n
⊢ (ofFn f).get i = (List.ofFn f).get ⟨↑i, ⋯⟩
tactic: conv_rhs => erw [← List.get_ofFn f ⟨i, by simp⟩]
state_before: n✝ : ℕ
α : Type u_1
n : ℕ
f : Fin n → α
i : Fin n
⊢ (ofFn f).get i = (List.ofFn f).get ⟨↑i, ⋯⟩
state_after: n✝ : ℕ
α : Type u_1
n : ℕ
f : Fin n → α
i : Fin n
⊢ (ofFn f).toList.get (Fin.cast ⋯ i) = (List.ofFn f).get ⟨↑i, ⋯⟩
tactic: simp only [get_eq_get]
state_before: n✝ : ℕ
α : Type u_1
n : ℕ
f : Fin n → α
i : Fin n
⊢ (ofFn f).toList.get (Fin.cast ⋯ i) = (List.ofFn f).get ⟨↑i, ⋯⟩
state_after: no goals
tactic: congr <;> simp [Fin.heq_ext_iff]
Theorem: smul_nonneg
File: Mathlib/Algebra/Order/Module/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
a a₁ a₂ : α
b b₁ b₂ : β
inst✝⁵ : Zero α
inst✝⁴ : Zero β
inst✝³ : SMulZeroClass α β
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : PosSMulMono α β
ha : 0 ≤ a
hb : 0 ≤ b₁
⊢ 0 ≤ a • b₁
state_after: no goals
tactic: simpa only [smul_zero] using smul_le_smul_of_nonneg_left hb ha
Theorem: Submodule.torsionBySet_eq_torsionBySet_span
File: Mathlib/Algebra/Module/Torsion.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a : R
⊢ torsionBySet R M s = torsionBySet R M ↑(Ideal.span s)
state_after: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a : R
x : M
hx : x ∈ torsionBySet R M s
⊢ x ∈ torsionBySet R M ↑(Ideal.span s)
tactic: refine le_antisymm (fun x hx => ?_) (torsionBySet_le_torsionBySet_of_subset subset_span)
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a : R
x : M
hx : x ∈ torsionBySet R M s
⊢ x ∈ torsionBySet R M ↑(Ideal.span s)
state_after: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a : R
x : M
hx : ∀ (a : ↑s), ↑a • x = 0
⊢ ∀ (a : ↑↑(Ideal.span s)), ↑a • x = 0
tactic: rw [mem_torsionBySet_iff] at hx ⊢
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a : R
x : M
hx : ∀ (a : ↑s), ↑a • x = 0
⊢ ∀ (a : ↑↑(Ideal.span s)), ↑a • x = 0
state_after: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a : R
x : M
hx : ∀ (a : ↑s), ↑a • x = 0
⊢ Ideal.span s ≤ Ideal.torsionOf R M x
tactic: suffices Ideal.span s ≤ Ideal.torsionOf R M x by
    rintro ⟨a, ha⟩
    exact this ha
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a : R
x : M
hx : ∀ (a : ↑s), ↑a • x = 0
⊢ Ideal.span s ≤ Ideal.torsionOf R M x
state_after: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a : R
x : M
hx : ∀ (a : ↑s), ↑a • x = 0
⊢ s ⊆ ↑(Ideal.torsionOf R M x)
tactic: rw [Ideal.span_le]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a : R
x : M
hx : ∀ (a : ↑s), ↑a • x = 0
⊢ s ⊆ ↑(Ideal.torsionOf R M x)
state_after: no goals
tactic: exact fun a ha => hx ⟨a, ha⟩
Theorem: Finset.nsmul_subset_nsmul
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : Monoid α
s t : Finset α
a : α
m n : ℕ
hst : s ⊆ t
⊢ s ^ 0 ⊆ t ^ 0
state_after: no goals
tactic: simp [pow_zero]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : Monoid α
s t : Finset α
a : α
m n✝ : ℕ
hst : s ⊆ t
n : ℕ
⊢ s ^ (n + 1) ⊆ t ^ (n + 1)
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : Monoid α
s t : Finset α
a : α
m n✝ : ℕ
hst : s ⊆ t
n : ℕ
⊢ s ^ n * s ⊆ t ^ (n + 1)
tactic: rw [pow_succ]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : Monoid α
s t : Finset α
a : α
m n✝ : ℕ
hst : s ⊆ t
n : ℕ
⊢ s ^ n * s ⊆ t ^ (n + 1)
state_after: no goals
tactic: exact mul_subset_mul (pow_subset_pow hst n) hst