ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: StructureGroupoid.LocalInvariantProp.liftPropAt_of_liftPropWithinAt
File: Mathlib/Geometry/Manifold/LocalInvariantProperties.lean

Proof steps:
state_before: H : Type u_1
M : Type u_2
H' : Type u_3
M' : Type u_4
X : Type u_5
inst✝⁶ : TopologicalSpace H
inst✝⁵ : TopologicalSpace M
inst✝⁴ : ChartedSpace H M
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
inst✝¹ : ChartedSpace H' M'
inst✝ : TopologicalSpace X
G : StructureGroupoid H
G' : StructureGroupoid H'
e e' : PartialHomeomorph M H
f f' : PartialHomeomorph M' H'
P : (H → H') → Set H → H → Prop
g g' : M → M'
s t : Set M
x : M
Q : (H → H) → Set H → H → Prop
hG : G.LocalInvariantProp G' P
h : LiftPropWithinAt P g s x
hs : s ∈ 𝓝 x
⊢ LiftPropAt P g x
state_after: no goals
tactic: rwa [← univ_inter s, hG.liftPropWithinAt_inter hs] at h
Theorem: CategoryTheory.MonoidalOfChosenFiniteProducts.leftUnitor_naturality
File: Mathlib/CategoryTheory/Monoidal/OfChosenFiniteProducts/Basic.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X₁ X₂ : C
f : X₁ ⟶ X₂
⊢ tensorHom ℬ (𝟙 𝒯.cone.pt) f ≫ (BinaryFan.leftUnitor 𝒯.isLimit (ℬ 𝒯.cone.pt X₂).isLimit).hom =
    (BinaryFan.leftUnitor 𝒯.isLimit (ℬ 𝒯.cone.pt X₁).isLimit).hom ≫ f
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X₁ X₂ : C
f : X₁ ⟶ X₂
⊢ (ℬ 𝒯.cone.pt X₂).isLimit.lift
        (BinaryFan.mk (BinaryFan.fst (ℬ 𝒯.cone.pt X₁).cone ≫ 𝟙 𝒯.cone.pt) (BinaryFan.snd (ℬ 𝒯.cone.pt X₁).cone ≫ f)) ≫
      BinaryFan.snd (ℬ 𝒯.cone.pt X₂).cone =
    BinaryFan.snd (ℬ 𝒯.cone.pt X₁).cone ≫ f
tactic: dsimp [tensorHom]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X₁ X₂ : C
f : X₁ ⟶ X₂
⊢ (ℬ 𝒯.cone.pt X₂).isLimit.lift
        (BinaryFan.mk (BinaryFan.fst (ℬ 𝒯.cone.pt X₁).cone ≫ 𝟙 𝒯.cone.pt) (BinaryFan.snd (ℬ 𝒯.cone.pt X₁).cone ≫ f)) ≫
      BinaryFan.snd (ℬ 𝒯.cone.pt X₂).cone =
    BinaryFan.snd (ℬ 𝒯.cone.pt X₁).cone ≫ f
state_after: no goals
tactic: simp
Theorem: MeasureTheory.IsStoppingTime.measurableSpace_min_const
File: Mathlib/Probability/Process/Stopping.lean

Proof steps:
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
i : ι
⊢ ⋯.measurableSpace = hτ.measurableSpace ⊓ ↑f i
state_after: no goals
tactic: rw [hτ.measurableSpace_min (isStoppingTime_const _ i), measurableSpace_const]
Theorem: Set.div_mem_center
File: Mathlib/Algebra/Group/Center.lean

Proof steps:
state_before: M : Type u_1
S T : Set M
inst✝ : DivisionMonoid M
a b : M
ha : a ∈ center M
hb : b ∈ center M
⊢ a / b ∈ center M
state_after: M : Type u_1
S T : Set M
inst✝ : DivisionMonoid M
a b : M
ha : a ∈ center M
hb : b ∈ center M
⊢ a * b⁻¹ ∈ center M
tactic: rw [div_eq_mul_inv]
state_before: M : Type u_1
S T : Set M
inst✝ : DivisionMonoid M
a b : M
ha : a ∈ center M
hb : b ∈ center M
⊢ a * b⁻¹ ∈ center M
state_after: no goals
tactic: exact mul_mem_center ha (inv_mem_center hb)
Theorem: List.getElem?_modifyNth_eq
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
f : α → α
n : Nat
l : List α
⊢ (modifyNth f n l)[n]? = f <$> l[n]?
state_after: no goals
tactic: simp only [getElem?_modifyNth, if_pos]
Theorem: CategoryTheory.wellPowered_of_equiv
File: Mathlib/CategoryTheory/Subobject/WellPowered.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v, u₁} C
D : Type u₂
inst✝¹ : Category.{v, u₂} D
e : C ≌ D
inst✝ : WellPowered C
X : D
⊢ EssentiallySmall.{v, v, max u₁ v} (MonoOver (e.symm.functor.obj X))
state_after: no goals
tactic: infer_instance
Theorem: CategoryTheory.WithTerminal.map₂_app
File: Mathlib/CategoryTheory/WithTerminal.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{?u.82998, u_1} D
F G : C ⥤ D
η : F ⟶ G
⊢ ∀ ⦃X Y : WithTerminal C⦄ (f : X ⟶ Y),
    (map F).map f ≫
        (fun X =>
            match X with
            | of x => η.app x
            | star => 𝟙 star)
          Y =
      (fun X =>
            match X with
            | of x => η.app x
            | star => 𝟙 star)
          X ≫
        (map G).map f
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{?u.82998, u_1} D
F G : C ⥤ D
η : F ⟶ G
X Y : WithTerminal C
f : X ⟶ Y
⊢ (map F).map f ≫
      (fun X =>
          match X with
          | of x => η.app x
          | star => 𝟙 star)
        Y =
    (fun X =>
          match X with
          | of x => η.app x
          | star => 𝟙 star)
        X ≫
      (map G).map f
tactic: intro X Y f
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{?u.82998, u_1} D
F G : C ⥤ D
η : F ⟶ G
X Y : WithTerminal C
f : X ⟶ Y
⊢ (map F).map f ≫
      (fun X =>
          match X with
          | of x => η.app x
          | star => 𝟙 star)
        Y =
    (fun X =>
          match X with
          | of x => η.app x
          | star => 𝟙 star)
        X ≫
      (map G).map f
state_after: no goals
tactic: match X, Y, f with
    | of x, of y, f => exact η.naturality f
    | of x, star, _ => rfl
    | star, star, _ => rfl
Theorem: Set.mem_iInter₂
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
x : γ
s : (i : ι) → κ i → Set γ
⊢ x ∈ ⋂ i, ⋂ j, s i j ↔ ∀ (i : ι) (j : κ i), x ∈ s i j
state_after: no goals
tactic: simp_rw [mem_iInter]
Theorem: CategoryTheory.Cat.HasLimits.limitConeLift_obj
File: Mathlib/CategoryTheory/Category/Cat/Limit.lean

Proof steps:
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
s : Cone F
X✝ Y✝ : ↑s.pt
f : X✝ ⟶ Y✝
⊢ limit.lift (F ⋙ objects) { pt := ↑s.pt, π := { app := fun j => (s.π.app j).obj, naturality := ⋯ } } X✝ ⟶
    limit.lift (F ⋙ objects) { pt := ↑s.pt, π := { app := fun j => (s.π.app j).obj, naturality := ⋯ } } Y✝
state_after: case x
J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
s : Cone F
X✝ Y✝ : ↑s.pt
f : X✝ ⟶ Y✝
⊢ (j : J) →
    (homDiagram (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := { app := fun j => (s.π.app j).obj, naturality := ⋯ } } X✝)
          (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := { app := fun j => (s.π.app j).obj, naturality := ⋯ } } Y✝)).obj
      j

case h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
s : Cone F
X✝ Y✝ : ↑s.pt
f : X✝ ⟶ Y✝
⊢ ∀ (j j' : J) (f : j ⟶ j'),
    (homDiagram (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := { app := fun j => (s.π.app j).obj, naturality := ⋯ } } X✝)
            (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := { app := fun j => (s.π.app j).obj, naturality := ⋯ } }
              Y✝)).map
        f (?x j) =
      ?x j'
tactic: fapply Types.Limit.mk.{v, v}
Theorem: Matrix.det_invOf
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

Proof steps:
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝⁴ : Fintype n
inst✝³ : DecidableEq n
inst✝² : CommRing α
A B : Matrix n n α
inst✝¹ : Invertible A
inst✝ : Invertible A.det
⊢ (⅟A).det = ⅟A.det
state_after: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝⁴ : Fintype n
inst✝³ : DecidableEq n
inst✝² : CommRing α
A B : Matrix n n α
inst✝¹ : Invertible A
inst✝ : Invertible A.det
this : Invertible A.det := A.detInvertibleOfInvertible
⊢ (⅟A).det = ⅟A.det
tactic: letI := detInvertibleOfInvertible A
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝⁴ : Fintype n
inst✝³ : DecidableEq n
inst✝² : CommRing α
A B : Matrix n n α
inst✝¹ : Invertible A
inst✝ : Invertible A.det
this : Invertible A.det := A.detInvertibleOfInvertible
⊢ (⅟A).det = ⅟A.det
state_after: no goals
tactic: convert (rfl : _ = ⅟ A.det)
Theorem: ZFSet.Hereditarily.empty
File: Mathlib/SetTheory/ZFC/Basic.lean

Proof steps:
state_before: p : ZFSet → Prop
x y : ZFSet
⊢ Hereditarily p x → p ∅
state_after: p : ZFSet → Prop
x y : ZFSet
⊢ ∀ (x : ZFSet), (∀ y ∈ x, Hereditarily p y → p ∅) → Hereditarily p x → p ∅
tactic: apply @ZFSet.inductionOn _ x
state_before: p : ZFSet → Prop
x y : ZFSet
⊢ ∀ (x : ZFSet), (∀ y ∈ x, Hereditarily p y → p ∅) → Hereditarily p x → p ∅
state_after: p : ZFSet → Prop
x y✝ y : ZFSet
IH : ∀ y_1 ∈ y, Hereditarily p y_1 → p ∅
h : Hereditarily p y
⊢ p ∅
tactic: intro y IH h
state_before: p : ZFSet → Prop
x y✝ y : ZFSet
IH : ∀ y_1 ∈ y, Hereditarily p y_1 → p ∅
h : Hereditarily p y
⊢ p ∅
state_after: case inl
p : ZFSet → Prop
x y : ZFSet
IH : ∀ y ∈ ∅, Hereditarily p y → p ∅
h : Hereditarily p ∅
⊢ p ∅

case inr.intro
p : ZFSet → Prop
x y✝ y : ZFSet
IH : ∀ y_1 ∈ y, Hereditarily p y_1 → p ∅
h : Hereditarily p y
a : ZFSet
ha : a ∈ y.toSet
⊢ p ∅
tactic: rcases ZFSet.eq_empty_or_nonempty y with (rfl | ⟨a, ha⟩)
Theorem: Fin.insertNth_apply_above
File: Mathlib/Data/Fin/Tuple/Basic.lean

Proof steps:
state_before: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
i j : Fin (n + 1)
h : i < j
x : α i
p : (k : Fin n) → α (i.succAbove k)
⊢ i.insertNth x p j = Eq.recOn ⋯ (p (j.pred ⋯))
state_after: no goals
tactic: rw [insertNth, succAboveCases, dif_neg (Fin.ne_of_gt h), dif_neg (Fin.lt_asymm h)]
Theorem: orthogonalProjection_unit_singleton
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
v : E
hv : ‖v‖ = 1
w : E
⊢ ↑((orthogonalProjection (Submodule.span 𝕜 {v})) w) = ⟪v, w⟫_𝕜 • v
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
v : E
hv : ‖v‖ = 1
w : E
⊢ ↑((orthogonalProjection (Submodule.span 𝕜 {v})) w) = ↑(‖v‖ ^ 2) • ↑((orthogonalProjection (Submodule.span 𝕜 {v})) w)
tactic: rw [← smul_orthogonalProjection_singleton 𝕜 w]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
v : E
hv : ‖v‖ = 1
w : E
⊢ ↑((orthogonalProjection (Submodule.span 𝕜 {v})) w) = ↑(‖v‖ ^ 2) • ↑((orthogonalProjection (Submodule.span 𝕜 {v})) w)
state_after: no goals
tactic: simp [hv]
Theorem: mfderivWithin_of_mem_nhds
File: Mathlib/Geometry/Manifold/MFDeriv/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹⁵ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹⁴ : NormedAddCommGroup E
inst✝¹³ : NormedSpace 𝕜 E
H : Type u_3
inst✝¹² : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
M : Type u_4
inst✝¹¹ : TopologicalSpace M
inst✝¹⁰ : ChartedSpace H M
E' : Type u_5
inst✝⁹ : NormedAddCommGroup E'
inst✝⁸ : NormedSpace 𝕜 E'
H' : Type u_6
inst✝⁷ : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M' : Type u_7
inst✝⁶ : TopologicalSpace M'
inst✝⁵ : ChartedSpace H' M'
E'' : Type u_8
inst✝⁴ : NormedAddCommGroup E''
inst✝³ : NormedSpace 𝕜 E''
H'' : Type u_9
inst✝² : TopologicalSpace H''
I'' : ModelWithCorners 𝕜 E'' H''
M'' : Type u_10
inst✝¹ : TopologicalSpace M''
inst✝ : ChartedSpace H'' M''
f f₀ f₁ : M → M'
x : M
s t : Set M
g : M' → M''
u : Set M'
Is : SmoothManifoldWithCorners I M
I's : SmoothManifoldWithCorners I' M'
I''s : SmoothManifoldWithCorners I'' M''
f' f₀' f₁' : TangentSpace I x →L[𝕜] TangentSpace I' (f x)
g' : TangentSpace I' (f x) →L[𝕜] TangentSpace I'' (g (f x))
h : s ∈ 𝓝 x
⊢ mfderivWithin I I' f s x = mfderiv I I' f x
state_after: no goals
tactic: rw [← mfderivWithin_univ, ← univ_inter s, mfderivWithin_inter h]
Theorem: Finpartition.isUniform_one
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean

Proof steps:
state_before: α : Type u_1
𝕜 : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : DecidableEq α
A : Finset α
P : Finpartition A
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε δ : 𝕜
u v : Finset α
⊢ P.IsUniform G 1
state_after: α : Type u_1
𝕜 : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : DecidableEq α
A : Finset α
P : Finpartition A
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε δ : 𝕜
u v : Finset α
⊢ (P.nonUniforms G 1).card ≤ P.parts.card * (P.parts.card - 1)
tactic: rw [IsUniform, mul_one, Nat.cast_le]
state_before: α : Type u_1
𝕜 : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : DecidableEq α
A : Finset α
P : Finpartition A
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε δ : 𝕜
u v : Finset α
⊢ (P.nonUniforms G 1).card ≤ P.parts.card * (P.parts.card - 1)
state_after: α : Type u_1
𝕜 : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : DecidableEq α
A : Finset α
P : Finpartition A
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε δ : 𝕜
u v : Finset α
⊢ P.parts.offDiag.card ≤ P.parts.card * (P.parts.card - 1)
tactic: refine (card_filter_le _
    (fun uv => ¬SimpleGraph.IsUniform G 1 (Prod.fst uv) (Prod.snd uv))).trans ?_
state_before: α : Type u_1
𝕜 : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : DecidableEq α
A : Finset α
P : Finpartition A
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε δ : 𝕜
u v : Finset α
⊢ P.parts.offDiag.card ≤ P.parts.card * (P.parts.card - 1)
state_after: no goals
tactic: rw [offDiag_card, Nat.mul_sub_left_distrib, mul_one]
Theorem: MvPowerSeries.coeff_monomial_mul
File: Mathlib/RingTheory/MvPowerSeries/Basic.lean

Proof steps:
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
m n : σ →₀ ℕ
φ ψ : MvPowerSeries σ R
a : R
⊢ (coeff R m) ((monomial R n) a * φ) = if n ≤ m then a * (coeff R (m - n)) φ else 0
state_after: no goals
tactic: classical
  have :
    ∀ p ∈ antidiagonal m,
      coeff R (p : (σ →₀ ℕ) × (σ →₀ ℕ)).1 (monomial R n a) * coeff R p.2 φ ≠ 0 → p.1 = n :=
    fun p _ hp => eq_of_coeff_monomial_ne_zero (left_ne_zero_of_mul hp)
  rw [coeff_mul, ← Finset.sum_filter_of_ne this, Finset.filter_fst_eq_antidiagonal _ n,
    Finset.sum_ite_index]
  simp only [Finset.sum_singleton, coeff_monomial_same, Finset.sum_empty]
Theorem: IsNilpotent.isUnit_add_one
File: Mathlib/RingTheory/Nilpotent/Basic.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
x y : R
inst✝ : Ring R
r : R
hnil : IsNilpotent r
⊢ IsUnit (r + 1)
state_after: R : Type u_1
S : Type u_2
x y : R
inst✝ : Ring R
r : R
hnil : IsNilpotent r
⊢ IsUnit (-r - 1)
tactic: rw [← IsUnit.neg_iff, neg_add']
state_before: R : Type u_1
S : Type u_2
x y : R
inst✝ : Ring R
r : R
hnil : IsNilpotent r
⊢ IsUnit (-r - 1)
state_after: no goals
tactic: exact isUnit_sub_one hnil.neg
Theorem: IsRightRegular.left_of_commute
File: Mathlib/Algebra/Regular/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Mul R
a : R
ca : ∀ (b : R), Commute a b
h : IsRightRegular a
⊢ IsLeftRegular a
state_after: R : Type u_1
inst✝ : Mul R
a : R
h : IsRightRegular a
ca : ∀ (b : R), Commute b a
⊢ IsLeftRegular a
tactic: simp_rw [@Commute.symm_iff R _ a] at ca
state_before: R : Type u_1
inst✝ : Mul R
a : R
h : IsRightRegular a
ca : ∀ (b : R), Commute b a
⊢ IsLeftRegular a
state_after: no goals
tactic: exact fun x y xy => h <| (ca x).trans <| xy.trans <| (ca y).symm
Theorem: EReal.top_add_of_ne_bot
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: x : EReal
h : x ≠ ⊥
⊢ ⊤ + x = ⊤
state_after: case h_bot
h : ⊥ ≠ ⊥
⊢ ⊤ + ⊥ = ⊤

case h_real
a✝ : ℝ
h : ↑a✝ ≠ ⊥
⊢ ⊤ + ↑a✝ = ⊤

case h_top
h : ⊤ ≠ ⊥
⊢ ⊤ + ⊤ = ⊤
tactic: induction x
Theorem: WithTop.pred_untop
File: Mathlib/Order/SuccPred/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : OrderTop α
inst✝ : PredOrder α
a : WithTop α
ha : a ≠ ⊤
⊢ pred a ≠ ⊤
state_after: no goals
tactic: induction a <;> simp
Theorem: map_mul_zero_of_map_zero
File: Mathlib/Analysis/Normed/Ring/SeminormFromBounded.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
x : R
hx : f x = 0
y : R
⊢ f (x * y) = 0
state_after: R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
x : R
hx : f x = 0
y : R
f_mul : f (x * y) ≤ 0
⊢ f (x * y) = 0
tactic: replace f_mul : f (x * y) ≤ 0 := by simpa [hx] using f_mul x y
state_before: R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
x : R
hx : f x = 0
y : R
f_mul : f (x * y) ≤ 0
⊢ f (x * y) = 0
state_after: no goals
tactic: exact le_antisymm f_mul (f_nonneg _)
Theorem: Rel.edgeDensity_empty_left
File: Mathlib/Combinatorics/SimpleGraph/Density.lean

Proof steps:
state_before: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
t : Finset β
⊢ edgeDensity r ∅ t = 0
state_after: no goals
tactic: rw [edgeDensity, Finset.card_empty, Nat.cast_zero, zero_mul, div_zero]
Theorem: Finsupp.prod_finset_sum_index
File: Mathlib/Algebra/BigOperators/Finsupp.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
γ : Type u_3
A : Type u_4
B : Type u_5
C : Type u_6
inst✝⁴ : AddCommMonoid A
inst✝³ : AddCommMonoid B
inst✝² : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s✝¹ : Finset α
f : α → ι →₀ A
i : ι
g✝ : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type u_7
M : Type u_8
M' : Type u_9
N : Type u_10
P : Type u_11
G : Type u_12
H : Type u_13
R : Type u_14
S : Type u_15
inst✝¹ : AddCommMonoid M
inst✝ : CommMonoid N
s✝ : Finset ι
g : ι → α →₀ M
h : α → M → N
h_zero : ∀ (a : α), h a 0 = 1
h_add : ∀ (a : α) (b₁ b₂ : M), h a (b₁ + b₂) = h a b₁ * h a b₂
a : ι
s : Finset ι
has : a ∉ s
ih : ∏ i ∈ s, (g i).prod h = (∑ i ∈ s, g i).prod h
⊢ ∏ i ∈ Finset.cons a s has, (g i).prod h = (∑ i ∈ Finset.cons a s has, g i).prod h
state_after: no goals
tactic: rw [prod_cons, ih, sum_cons, prod_add_index' h_zero h_add]
Theorem: Module.forall_dual_apply_eq_zero_iff
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: K : Type uK
V : Type uV
inst✝³ : CommRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Free K V
v : V
⊢ (∀ (φ : Dual K V), φ v = 0) ↔ v = 0
state_after: K : Type uK
V : Type uV
inst✝³ : CommRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Free K V
v : V
⊢ (∀ (φ : Dual K V), φ v = 0) ↔ ∀ (x : Dual K V), ((eval K V) v) x = 0 x
tactic: rw [← eval_apply_eq_zero_iff K v, LinearMap.ext_iff]
state_before: K : Type uK
V : Type uV
inst✝³ : CommRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Free K V
v : V
⊢ (∀ (φ : Dual K V), φ v = 0) ↔ ∀ (x : Dual K V), ((eval K V) v) x = 0 x
state_after: no goals
tactic: rfl
Theorem: circleMap_mem_sphere'
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

Proof steps:
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
c : ℂ
R θ : ℝ
⊢ circleMap c R θ ∈ sphere c |R|
state_after: no goals
tactic: simp
Theorem: summable_mul_left_iff
File: Mathlib/Topology/Algebra/InfiniteSum/Ring.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
R : Type u_3
α : Type u_4
inst✝² : DivisionSemiring α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSemiring α
f g : ι → α
a a₁ a₂ : α
h : a ≠ 0
H : Summable fun i => a * f i
⊢ Summable f
state_after: no goals
tactic: simpa only [inv_mul_cancel_left₀ h] using H.mul_left a⁻¹
Theorem: PrimeSpectrum.isClosed_zeroLocus
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
s : Set R
⊢ IsClosed (zeroLocus s)
state_after: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
s : Set R
⊢ ∃ s_1, zeroLocus s = zeroLocus s_1
tactic: rw [isClosed_iff_zeroLocus]
state_before: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
s : Set R
⊢ ∃ s_1, zeroLocus s = zeroLocus s_1
state_after: no goals
tactic: exact ⟨s, rfl⟩
Theorem: Int.exists_unique_equiv_nat
File: Mathlib/Data/Int/ModEq.lean

Proof steps:
state_before: m n a✝ b✝ c d a b : ℤ
hb : 0 < b
z : ℤ
hz1 : 0 ≤ z
hz2 : z < b
hz3 : z ≡ a [ZMOD b]
⊢ ↑z.natAbs < b ∧ ↑z.natAbs ≡ a [ZMOD b]
state_after: no goals
tactic: constructor <;> rw [natAbs_of_nonneg hz1] <;> assumption
Theorem: Polynomial.sum_add'
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a b : R
m n : ℕ
inst✝¹ : Semiring R
p✝ q : R[X]
S : Type u_1
inst✝ : AddCommMonoid S
p : R[X]
f g : ℕ → R → S
⊢ p.sum (f + g) = p.sum f + p.sum g
state_after: no goals
tactic: simp [sum_def, Finset.sum_add_distrib]
Theorem: Nat.digits_add
File: Mathlib/Data/Nat/Digits.lean

Proof steps:
state_before: n b : ℕ
h : 1 < b
x y : ℕ
hxb : x < b
hxy : x ≠ 0 ∨ y ≠ 0
⊢ b.digits (x + b * y) = x :: b.digits y
state_after: case intro
n x y : ℕ
hxy : x ≠ 0 ∨ y ≠ 0
b : ℕ
h : 1 < b + 2
hxb : x < b + 2
⊢ (b + 2).digits (x + (b + 2) * y) = x :: (b + 2).digits y
tactic: rcases Nat.exists_eq_add_of_le' h with ⟨b, rfl : _ = _ + 2⟩
state_before: case intro
n x y : ℕ
hxy : x ≠ 0 ∨ y ≠ 0
b : ℕ
h : 1 < b + 2
hxb : x < b + 2
⊢ (b + 2).digits (x + (b + 2) * y) = x :: (b + 2).digits y
state_after: case intro.zero
n x b : ℕ
h : 1 < b + 2
hxb : x < b + 2
hxy : x ≠ 0 ∨ 0 ≠ 0
⊢ (b + 2).digits (x + (b + 2) * 0) = x :: (b + 2).digits 0

case intro.succ
n x b : ℕ
h : 1 < b + 2
hxb : x < b + 2
n✝ : ℕ
hxy : x ≠ 0 ∨ n✝ + 1 ≠ 0
⊢ (b + 2).digits (x + (b + 2) * (n✝ + 1)) = x :: (b + 2).digits (n✝ + 1)
tactic: cases y
state_before: case intro.succ
n x b : ℕ
h : 1 < b + 2
hxb : x < b + 2
n✝ : ℕ
hxy : x ≠ 0 ∨ n✝ + 1 ≠ 0
⊢ (b + 2).digits (x + (b + 2) * (n✝ + 1)) = x :: (b + 2).digits (n✝ + 1)
state_after: case intro.succ
n x b : ℕ
h : 1 < b + 2
hxb : x < b + 2
n✝ : ℕ
hxy : x ≠ 0 ∨ n✝ + 1 ≠ 0
⊢ (b + 2).digitsAux ⋯ (x + (b + 2) * (n✝ + 1)) = x :: (b + 2).digitsAux ⋯ (n✝ + 1)
tactic: dsimp [digits]
state_before: case intro.succ
n x b : ℕ
h : 1 < b + 2
hxb : x < b + 2
n✝ : ℕ
hxy : x ≠ 0 ∨ n✝ + 1 ≠ 0
⊢ (b + 2).digitsAux ⋯ (x + (b + 2) * (n✝ + 1)) = x :: (b + 2).digitsAux ⋯ (n✝ + 1)
state_after: case intro.succ
n x b : ℕ
h : 1 < b + 2
hxb : x < b + 2
n✝ : ℕ
hxy : x ≠ 0 ∨ n✝ + 1 ≠ 0
⊢ (x + (b + 2) * (n✝ + 1)) % (b + 2) :: (b + 2).digitsAux ⋯ ((x + (b + 2) * (n✝ + 1)) / (b + 2)) =
    x :: (b + 2).digitsAux ⋯ (n✝ + 1)

case intro.succ.w
n x b : ℕ
h : 1 < b + 2
hxb : x < b + 2
n✝ : ℕ
hxy : x ≠ 0 ∨ n✝ + 1 ≠ 0
⊢ 0 < x + (b + 2) * (n✝ + 1)
tactic: rw [digitsAux_def]
Theorem: Filter.tendsto_mul_const_atBot_iff_neg
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✝¹ : LinearOrderedField α
l : Filter β
f : β → α
r : α
inst✝ : l.NeBot
h : Tendsto f l atTop
⊢ Tendsto (fun x => f x * r) l atBot ↔ r < 0
state_after: no goals
tactic: simp only [mul_comm _ r, tendsto_const_mul_atBot_iff_neg h]
Theorem: PowerSeries.monomial_eq_mk
File: Mathlib/RingTheory/PowerSeries/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
n : ℕ
a : R
m : ℕ
⊢ (coeff R m) ((monomial R n) a) = (coeff R m) (mk fun m => if m = n then a else 0)
state_after: no goals
tactic: rw [coeff_monomial, coeff_mk]
Theorem: _private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.lambda_not_dvd_X
File: Mathlib/NumberTheory/FLT/Three.lean

Proof steps:
state_before: K : Type u_1
inst✝³ : Field K
inst✝² : NumberField K
inst✝¹ : IsCyclotomicExtension {3} ℚ K
ζ : K
hζ : IsPrimitiveRoot ζ ↑3
S : Solution hζ
S' : Solution' hζ
inst✝ : DecidableRel fun a b => a ∣ b
h : λ ∣ FermatLastTheoremForThreeGen.Solution.X S
⊢ 3 ≠ 0
state_after: no goals
tactic: decide