ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: mem_nhdsSet_iff_exists
File: Mathlib/Topology/NhdsSet.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : Filter X
s t s₁ s₂ t₁ t₂ : Set X
x : X
⊢ s ∈ 𝓝ˢ t ↔ ∃ U, IsOpen U ∧ t ⊆ U ∧ U ⊆ s
state_after: no goals
tactic: rw [← subset_interior_iff_mem_nhdsSet, subset_interior_iff]
Theorem: Set.insert_subset_insert_iff
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
ha : a ∉ s
⊢ insert a s ⊆ insert a t ↔ s ⊆ t
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
ha : a ∉ s
h : insert a s ⊆ insert a t
x : α
hx : x ∈ s
⊢ x ∈ t
tactic: refine ⟨fun h x hx => ?_, insert_subset_insert⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
ha : a ∉ s
h : insert a s ⊆ insert a t
x : α
hx : x ∈ s
⊢ x ∈ t
state_after: case inl
α : Type u
β : Type v
γ : Type w
ι : Sort x
b : α
s s₁ s₂ t t₁ t₂ u : Set α
x : α
hx : x ∈ s
ha : x ∉ s
h : insert x s ⊆ insert x t
⊢ x ∈ t

case inr
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
ha : a ∉ s
h : insert a s ⊆ insert a t
x : α
hx : x ∈ s
hxt : x ∈ t
⊢ x ∈ t
tactic: rcases h (subset_insert _ _ hx) with (rfl | hxt)
state_before: case inl
α : Type u
β : Type v
γ : Type w
ι : Sort x
b : α
s s₁ s₂ t t₁ t₂ u : Set α
x : α
hx : x ∈ s
ha : x ∉ s
h : insert x s ⊆ insert x t
⊢ x ∈ t

case inr
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
ha : a ∉ s
h : insert a s ⊆ insert a t
x : α
hx : x ∈ s
hxt : x ∈ t
⊢ x ∈ t
state_after: no goals
tactic: exacts [(ha hx).elim, hxt]
Theorem: Quaternion.normSq_star
File: Mathlib/Algebra/Quaternion.lean

Proof steps:
state_before: S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
r x y z : R
a b c : ℍ[R]
⊢ normSq (star a) = normSq a
state_after: no goals
tactic: simp [normSq_def']
Theorem: inf_eq_right
File: Mathlib/Order/Lattice.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : SemilatticeInf α
a b c d : α
⊢ a ⊓ b ≤ b ∧ b ≤ a ⊓ b ↔ b ≤ a
state_after: no goals
tactic: simp [le_rfl]
Theorem: PythagoreanTriple.ne_zero_of_coprime
File: Mathlib/NumberTheory/PythagoreanTriples.lean

Proof steps:
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
⊢ z ≠ 0
state_after: x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
⊢ 0 < z * z
tactic: suffices 0 < z * z by
    rintro rfl
    norm_num at this
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
⊢ 0 < z * z
state_after: x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
⊢ 0 < x ^ 2 + y ^ 2
tactic: rw [← h.eq, ← sq, ← sq]
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
⊢ 0 < x ^ 2 + y ^ 2
state_after: x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
hc' : x.gcd y ≠ 0
⊢ 0 < x ^ 2 + y ^ 2
tactic: have hc' : Int.gcd x y ≠ 0 := by
    rw [hc]
    exact one_ne_zero
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
hc' : x.gcd y ≠ 0
⊢ 0 < x ^ 2 + y ^ 2
state_after: case inl
x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
hc' : x.gcd y ≠ 0
hxz : x ≠ 0
⊢ 0 < x ^ 2 + y ^ 2

case inr
x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
hc' : x.gcd y ≠ 0
hyz : y ≠ 0
⊢ 0 < x ^ 2 + y ^ 2
tactic: cases' Int.ne_zero_of_gcd hc' with hxz hyz
Theorem: RingHom.toMorphismProperty_respectsIso_iff
File: Mathlib/RingTheory/RingHomProperties.lean

Proof steps:
state_before: P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
⊢ (RespectsIso fun {R S} [CommRing R] [CommRing S] => P) ↔
    (toMorphismProperty fun {R S} [CommRing R] [CommRing S] => P).RespectsIso
state_after: case refine_1
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
h : RespectsIso fun {R S} [CommRing R] [CommRing S] => P
⊢ ∀ {X Y Z : CommRingCat} (e : X ≅ Y) (f : Y ⟶ Z),
    toMorphismProperty (fun {R S} [CommRing R] [CommRing S] => P) f →
      toMorphismProperty (fun {R S} [CommRing R] [CommRing S] => P) (e.hom ≫ f)

case refine_2
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
h : RespectsIso fun {R S} [CommRing R] [CommRing S] => P
⊢ ∀ {X Y Z : CommRingCat} (e : Y ≅ Z) (f : X ⟶ Y),
    toMorphismProperty (fun {R S} [CommRing R] [CommRing S] => P) f →
      toMorphismProperty (fun {R S} [CommRing R] [CommRing S] => P) (f ≫ e.hom)

case refine_3
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
h : (toMorphismProperty fun {R S} [CommRing R] [CommRing S] => P).RespectsIso
⊢ ∀ {R S T : Type u} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T] (f : R →+* S) (e : S ≃+* T),
    (fun {R S} [CommRing R] [CommRing S] => P) f → (fun {R S} [CommRing R] [CommRing S] => P) (e.toRingHom.comp f)

case refine_4
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
h : (toMorphismProperty fun {R S} [CommRing R] [CommRing S] => P).RespectsIso
⊢ ∀ {R S T : Type u} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T] (f : S →+* T) (e : R ≃+* S),
    (fun {R S} [CommRing R] [CommRing S] => P) f → (fun {R S} [CommRing R] [CommRing S] => P) (f.comp e.toRingHom)
tactic: refine ⟨fun h ↦ ⟨?_, ?_⟩, fun h ↦ ⟨?_, ?_⟩⟩
Theorem: Batteries.DList.ofList_toList
File: Mathlib/Data/DList/Defs.lean

Proof steps:
state_before: α : Type u
l : DList α
⊢ ofList l.toList = l
state_after: case mk
α : Type u
app : List α → List α
inv : ∀ (l : List α), app l = app [] ++ l
⊢ ofList { apply := app, invariant := inv }.toList = { apply := app, invariant := inv }
tactic: cases' l with app inv
state_before: case mk
α : Type u
app : List α → List α
inv : ∀ (l : List α), app l = app [] ++ l
⊢ ofList { apply := app, invariant := inv }.toList = { apply := app, invariant := inv }
state_after: case mk
α : Type u
app : List α → List α
inv : ∀ (l : List α), app l = app [] ++ l
⊢ (fun x => app [] ++ x) = app
tactic: simp only [ofList, toList, mk.injEq]
state_before: case mk
α : Type u
app : List α → List α
inv : ∀ (l : List α), app l = app [] ++ l
⊢ (fun x => app [] ++ x) = app
state_after: case mk.h
α : Type u
app : List α → List α
inv : ∀ (l : List α), app l = app [] ++ l
x : List α
⊢ app [] ++ x = app x
tactic: funext x
state_before: case mk.h
α : Type u
app : List α → List α
inv : ∀ (l : List α), app l = app [] ++ l
x : List α
⊢ app [] ++ x = app x
state_after: no goals
tactic: rw [(inv x)]
Theorem: Metric.mem_of_closed'
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ
s✝ s : Set α
hs : IsClosed s
a : α
⊢ a ∈ s ↔ ∀ ε > 0, ∃ b ∈ s, dist a b < ε
state_after: no goals
tactic: simpa only [hs.closure_eq] using @mem_closure_iff _ _ s a
Theorem: max_def
File: Mathlib/Init/Order/LinearOrder.lean

Proof steps:
state_before: α : Type u
inst✝ : LinearOrder α
a b : α
⊢ max a b = if a ≤ b then b else a
state_after: no goals
tactic: rw [LinearOrder.max_def a]
Theorem: CategoryTheory.MonoidalCategory.fullBraidedSubcategory.map_obj_obj
File: Mathlib/CategoryTheory/Monoidal/Subcategory.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : MonoidalCategory C
P : C → Prop
inst✝² : MonoidalPredicate P
P' : C → Prop
inst✝¹ : MonoidalPredicate P'
inst✝ : BraidedCategory C
h : ∀ ⦃X : C⦄, P X → P' X
X Y : FullSubcategory P
⊢ (fullMonoidalSubcategory.map h).map (β_ X Y).hom =
    inv ((fullMonoidalSubcategory.map h).μ X Y) ≫
      (β_ ((fullMonoidalSubcategory.map h).obj X) ((fullMonoidalSubcategory.map h).obj Y)).hom ≫
        (fullMonoidalSubcategory.map h).μ Y X
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : MonoidalCategory C
P : C → Prop
inst✝² : MonoidalPredicate P
P' : C → Prop
inst✝¹ : MonoidalPredicate P'
inst✝ : BraidedCategory C
h : ∀ ⦃X : C⦄, P X → P' X
X Y : FullSubcategory P
⊢ (fullMonoidalSubcategory.map h).μ X Y ≫ (fullMonoidalSubcategory.map h).map (β_ X Y).hom =
    (β_ ((fullMonoidalSubcategory.map h).obj X) ((fullMonoidalSubcategory.map h).obj Y)).hom ≫
      (fullMonoidalSubcategory.map h).μ Y X
tactic: rw [IsIso.eq_inv_comp]
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : MonoidalCategory C
P : C → Prop
inst✝² : MonoidalPredicate P
P' : C → Prop
inst✝¹ : MonoidalPredicate P'
inst✝ : BraidedCategory C
h : ∀ ⦃X : C⦄, P X → P' X
X Y : FullSubcategory P
⊢ (fullMonoidalSubcategory.map h).μ X Y ≫ (fullMonoidalSubcategory.map h).map (β_ X Y).hom =
    (β_ ((fullMonoidalSubcategory.map h).obj X) ((fullMonoidalSubcategory.map h).obj Y)).hom ≫
      (fullMonoidalSubcategory.map h).μ Y X
state_after: no goals
tactic: aesop_cat
Theorem: antivary_neg_right
File: Mathlib/Algebra/Order/Monovary.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : OrderedCommGroup α
inst✝ : OrderedCommGroup β
s : Set ι
f f₁ f₂ : ι → α
g g₁ g₂ : ι → β
⊢ Antivary f g⁻¹ ↔ Monovary f g
state_after: no goals
tactic: simpa [Monovary, Antivary] using forall_swap
Theorem: Ordinal.limitRecOn_limit
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
C : Ordinal.{u_4} → Sort u_5
o : Ordinal.{u_4}
H₁ : C 0
H₂ : (o : Ordinal.{u_4}) → C o → C (succ o)
H₃ : (o : Ordinal.{u_4}) → o.IsLimit → ((o' : Ordinal.{u_4}) → o' < o → C o') → C o
h : o.IsLimit
⊢ o.limitRecOn H₁ H₂ H₃ = H₃ o h fun x _h => x.limitRecOn H₁ H₂ H₃
state_after: no goals
tactic: simp_rw [limitRecOn, SuccOrder.limitRecOn_limit _ _ h.isSuccLimit, dif_neg h.1]
Theorem: Rat.divInt_eq_iff
File: .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean

Proof steps:
state_before: d₁ d₂ n₁ n₂ : Int
z₁ : d₁ ≠ 0
z₂ : d₂ ≠ 0
⊢ n₁ /. d₁ = n₂ /. d₂ ↔ n₁ * d₂ = n₂ * d₁
state_after: no goals
tactic: rcases Int.eq_nat_or_neg d₁ with ⟨_, rfl | rfl⟩ <;>
  rcases Int.eq_nat_or_neg d₂ with ⟨_, rfl | rfl⟩ <;>
  simp_all [divInt_neg', Int.ofNat_eq_zero, Int.neg_eq_zero,
    mkRat_eq_iff, Int.neg_mul, Int.mul_neg, Int.eq_neg_comm, eq_comm]
Theorem: Order.succ_top
File: Mathlib/Order/SuccPred/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
a b : α
inst✝ : OrderTop α
⊢ succ ⊤ = ⊤
state_after: no goals
tactic: rw [succ_eq_iff_isMax, isMax_iff_eq_top]
Theorem: DMatrix.ext_iff
File: Mathlib/Data/Matrix/DMatrix.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
α : m → n → Type v
M N : DMatrix m n α
h : M = N
⊢ ∀ (i : m) (j : n), M i j = N i j
state_after: no goals
tactic: simp [h]
Theorem: Surreal.dyadicMap_apply
File: Mathlib/SetTheory/Surreal/Dyadic.lean

Proof steps:
state_before: m : ℤ
p : ↥(Submonoid.powers 2)
⊢ dyadicMap (IsLocalization.mk' (Localization (Submonoid.powers 2)) m p) = ↑m * powHalf (Submonoid.log p)
state_after: m : ℤ
p : ↥(Submonoid.powers 2)
⊢ dyadicMap (Localization.mk m p) = ↑m * powHalf (Submonoid.log p)
tactic: rw [← Localization.mk_eq_mk']
state_before: m : ℤ
p : ↥(Submonoid.powers 2)
⊢ dyadicMap (Localization.mk m p) = ↑m * powHalf (Submonoid.log p)
state_after: no goals
tactic: rfl
Theorem: Subgroup.dvd_index_map
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
f : G →* G'
hf : f.ker ≤ H
⊢ H.index ∣ (map f H).index
state_after: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
f : G →* G'
hf : f.ker ≤ H
⊢ H.index ∣ H.index * f.range.index
tactic: rw [index_map, sup_of_le_left hf]
state_before: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
f : G →* G'
hf : f.ker ≤ H
⊢ H.index ∣ H.index * f.range.index
state_after: no goals
tactic: apply dvd_mul_right
Theorem: EuclideanGeometry.exists_circumradius_eq_of_cospherical
File: Mathlib/Geometry/Euclidean/Circumcenter.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
ps : Set P
n : ℕ
inst✝ : FiniteDimensional ℝ V
hd : finrank ℝ V = n
hc : Cospherical ps
⊢ ∃ r, ∀ (sx : Simplex ℝ P n), Set.range sx.points ⊆ ps → sx.circumradius = r
state_after: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
ps : Set P
n : ℕ
inst✝ : FiniteDimensional ℝ V
hd : finrank ℝ V = n
hc : Cospherical ps
this : Nonempty ↥⊤
⊢ ∃ r, ∀ (sx : Simplex ℝ P n), Set.range sx.points ⊆ ps → sx.circumradius = r
tactic: haveI : Nonempty (⊤ : AffineSubspace ℝ P) := Set.univ.nonempty
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
ps : Set P
n : ℕ
inst✝ : FiniteDimensional ℝ V
hd : finrank ℝ V = n
hc : Cospherical ps
this : Nonempty ↥⊤
⊢ ∃ r, ∀ (sx : Simplex ℝ P n), Set.range sx.points ⊆ ps → sx.circumradius = r
state_after: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
ps : Set P
n : ℕ
inst✝ : FiniteDimensional ℝ V
hd : finrank ℝ ↥⊤.direction = n
hc : Cospherical ps
this : Nonempty ↥⊤
⊢ ∃ r, ∀ (sx : Simplex ℝ P n), Set.range sx.points ⊆ ps → sx.circumradius = r
tactic: rw [← finrank_top, ← direction_top ℝ V P] at hd
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
ps : Set P
n : ℕ
inst✝ : FiniteDimensional ℝ V
hd : finrank ℝ ↥⊤.direction = n
hc : Cospherical ps
this : Nonempty ↥⊤
⊢ ∃ r, ∀ (sx : Simplex ℝ P n), Set.range sx.points ⊆ ps → sx.circumradius = r
state_after: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
ps : Set P
n : ℕ
inst✝ : FiniteDimensional ℝ V
hd : finrank ℝ ↥⊤.direction = n
hc : Cospherical ps
this : Nonempty ↥⊤
⊢ ps ⊆ ↑⊤
tactic: refine exists_circumradius_eq_of_cospherical_subset ?_ hd hc
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
ps : Set P
n : ℕ
inst✝ : FiniteDimensional ℝ V
hd : finrank ℝ ↥⊤.direction = n
hc : Cospherical ps
this : Nonempty ↥⊤
⊢ ps ⊆ ↑⊤
state_after: no goals
tactic: exact Set.subset_univ _
Theorem: IsAdjoinRootMonic.coeff_algebraMap
File: Mathlib/RingTheory/IsAdjoinRoot.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
inst✝ : Nontrivial S
h : IsAdjoinRootMonic S f
x : R
⊢ h.coeff ((algebraMap R S) x) = Pi.single 0 x
state_after: case h
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
inst✝ : Nontrivial S
h : IsAdjoinRootMonic S f
x : R
i : ℕ
⊢ h.coeff ((algebraMap R S) x) i = Pi.single 0 x i
tactic: ext i
state_before: case h
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
inst✝ : Nontrivial S
h : IsAdjoinRootMonic S f
x : R
i : ℕ
⊢ h.coeff ((algebraMap R S) x) i = Pi.single 0 x i
state_after: case h
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
inst✝ : Nontrivial S
h : IsAdjoinRootMonic S f
x : R
i : ℕ
⊢ x * Pi.single 0 1 i = Pi.single 0 x i
tactic: rw [Algebra.algebraMap_eq_smul_one, map_smul, coeff_one, Pi.smul_apply, smul_eq_mul]
state_before: case h
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
inst✝ : Nontrivial S
h : IsAdjoinRootMonic S f
x : R
i : ℕ
⊢ x * Pi.single 0 1 i = Pi.single 0 x i
state_after: case h
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
inst✝ : Nontrivial S
h : IsAdjoinRootMonic S f
x : R
i : ℕ
⊢ ∀ (i : ℕ), (fun x_1 y => x * y) i 0 = 0
tactic: refine (Pi.apply_single (fun _ y => x * y) ?_ 0 1 i).trans (by simp)
state_before: case h
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
inst✝ : Nontrivial S
h : IsAdjoinRootMonic S f
x : R
i : ℕ
⊢ ∀ (i : ℕ), (fun x_1 y => x * y) i 0 = 0
state_after: no goals
tactic: simp
Theorem: HasDerivWithinAt.liminf_right_slope_norm_le
File: Mathlib/Analysis/Calculus/Deriv/Slope.lean

Proof steps:
state_before: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
f' : E
s : Set ℝ
x r : ℝ
hf : HasDerivWithinAt f f' (Ici x) x
hr : ‖f'‖ < r
⊢ ∃ᶠ (z : ℝ) in 𝓝[>] x, (z - x)⁻¹ * (‖f z‖ - ‖f x‖) < r
state_after: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
f' : E
s : Set ℝ
x r : ℝ
hf : HasDerivWithinAt f f' (Ici x) x
hr : ‖f'‖ < r
this : ∃ᶠ (x_1 : ℝ) in 𝓝[>] x, ‖x_1 - x‖⁻¹ * (‖f x_1‖ - ‖f x‖) < r
⊢ ∃ᶠ (z : ℝ) in 𝓝[>] x, (z - x)⁻¹ * (‖f z‖ - ‖f x‖) < r
tactic: have := (hf.Ioi_of_Ici.limsup_slope_norm_le hr).frequently
state_before: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
f' : E
s : Set ℝ
x r : ℝ
hf : HasDerivWithinAt f f' (Ici x) x
hr : ‖f'‖ < r
this : ∃ᶠ (x_1 : ℝ) in 𝓝[>] x, ‖x_1 - x‖⁻¹ * (‖f x_1‖ - ‖f x‖) < r
⊢ ∃ᶠ (z : ℝ) in 𝓝[>] x, (z - x)⁻¹ * (‖f z‖ - ‖f x‖) < r
state_after: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
f' : E
s : Set ℝ
x r : ℝ
hf : HasDerivWithinAt f f' (Ici x) x
hr : ‖f'‖ < r
this : ∃ᶠ (x_1 : ℝ) in 𝓝[>] x, ‖x_1 - x‖⁻¹ * (‖f x_1‖ - ‖f x‖) < r
z : ℝ
hxz : x < z
hz : ‖z - x‖⁻¹ * (‖f z‖ - ‖f x‖) < r
⊢ (z - x)⁻¹ * (‖f z‖ - ‖f x‖) < r
tactic: refine this.mp (Eventually.mono self_mem_nhdsWithin fun z hxz hz ↦ ?_)
state_before: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
f' : E
s : Set ℝ
x r : ℝ
hf : HasDerivWithinAt f f' (Ici x) x
hr : ‖f'‖ < r
this : ∃ᶠ (x_1 : ℝ) in 𝓝[>] x, ‖x_1 - x‖⁻¹ * (‖f x_1‖ - ‖f x‖) < r
z : ℝ
hxz : x < z
hz : ‖z - x‖⁻¹ * (‖f z‖ - ‖f x‖) < r
⊢ (z - x)⁻¹ * (‖f z‖ - ‖f x‖) < r
state_after: no goals
tactic: rwa [Real.norm_eq_abs, abs_of_pos (sub_pos_of_lt hxz)] at hz
Theorem: NeZero.of_neZero_natCast
File: Mathlib/Data/Nat/Cast/NeZero.lean

Proof steps:
state_before: R : Type u_1
inst✝ : AddMonoidWithOne R
n : ℕ
h : NeZero ↑n
⊢ n ≠ 0
state_after: R : Type u_1
inst✝ : AddMonoidWithOne R
h : NeZero ↑0
⊢ False
tactic: rintro rfl
state_before: R : Type u_1
inst✝ : AddMonoidWithOne R
h : NeZero ↑0
⊢ False
state_after: no goals
tactic: exact h.out Nat.cast_zero
Theorem: CategoryTheory.Limits.coconeOfIsSplitEpi_ι_app
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
inst✝ : IsSplitEpi f
⊢ 𝟙 X ≫ f = (f ≫ section_ f) ≫ f
state_after: no goals
tactic: simp
Theorem: Orientation.oangle_neg_self_right
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean

Proof steps:
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x : V
hx : x ≠ 0
⊢ o.oangle x (-x) = ↑π
state_after: no goals
tactic: simp [oangle_neg_right, hx]
Theorem: Units.mul_inv_of_eq
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
inst✝ : Monoid α
a✝ b c u : αˣ
a : α
h : ↑u = a
⊢ a * ↑u⁻¹ = 1
state_after: no goals
tactic: rw [← h, u.mul_inv]
Theorem: CanonicallyOrderedCommSemiring.mul_lt_mul_of_lt_of_lt
File: Mathlib/Algebra/Order/Ring/Canonical.lean

Proof steps:
state_before: α : Type u
β : Type u_1
inst✝¹ : CanonicallyOrderedCommSemiring α
a b c d : α
inst✝ : PosMulStrictMono α
hab : a < b
hcd : c < d
⊢ a * c < b * d
state_after: α : Type u
β : Type u_1
inst✝¹ : CanonicallyOrderedCommSemiring α
a b c d : α
inst✝ : PosMulStrictMono α
hab : a < b
hcd : c < d
this : MulPosStrictMono α
⊢ a * c < b * d
tactic: have := posMulStrictMono_iff_mulPosStrictMono.1 ‹_›
state_before: α : Type u
β : Type u_1
inst✝¹ : CanonicallyOrderedCommSemiring α
a b c d : α
inst✝ : PosMulStrictMono α
hab : a < b
hcd : c < d
this : MulPosStrictMono α
⊢ a * c < b * d
state_after: case inl
α : Type u
β : Type u_1
inst✝¹ : CanonicallyOrderedCommSemiring α
a b d : α
inst✝ : PosMulStrictMono α
hab : a < b
this : MulPosStrictMono α
hcd : 0 < d
⊢ a * 0 < b * d

case inr
α : Type u
β : Type u_1
inst✝¹ : CanonicallyOrderedCommSemiring α
a b c d : α
inst✝ : PosMulStrictMono α
hab : a < b
hcd : c < d
this : MulPosStrictMono α
hc : 0 < c
⊢ a * c < b * d
tactic: obtain rfl | hc := eq_zero_or_pos c
Theorem: GaussianInt.toComplex_re
File: Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean

Proof steps:
state_before: x y : ℤ
⊢ (toComplex { re := x, im := y }).re = ↑x
state_after: no goals
tactic: simp [toComplex_def]
Theorem: Matrix.Pivot.listTransvecCol_mul_mul_listTransvecRow_last_row
File: Mathlib/LinearAlgebra/Matrix/Transvection.lean

Proof steps:
state_before: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝³ : Field 𝕜
inst✝² : DecidableEq n
inst✝¹ : DecidableEq p
inst✝ : CommRing R
r : ℕ
M : Matrix (Fin r ⊕ Unit) (Fin r ⊕ Unit) 𝕜
hM : M (inr ()) (inr ()) ≠ 0
i : Fin r
⊢ ((listTransvecCol M).prod * M * (listTransvecRow M).prod) (inl i) (inr ()) = 0
state_after: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝³ : Field 𝕜
inst✝² : DecidableEq n
inst✝¹ : DecidableEq p
inst✝ : CommRing R
r : ℕ
M : Matrix (Fin r ⊕ Unit) (Fin r ⊕ Unit) 𝕜
hM : M (inr ()) (inr ()) ≠ 0
i : Fin r
this : listTransvecCol M = listTransvecCol (M * (listTransvecRow M).prod)
⊢ ((listTransvecCol M).prod * M * (listTransvecRow M).prod) (inl i) (inr ()) = 0
tactic: have : listTransvecCol M = listTransvecCol (M * (listTransvecRow M).prod) := by
    simp [listTransvecCol, mul_listTransvecRow_last_col]
state_before: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝³ : Field 𝕜
inst✝² : DecidableEq n
inst✝¹ : DecidableEq p
inst✝ : CommRing R
r : ℕ
M : Matrix (Fin r ⊕ Unit) (Fin r ⊕ Unit) 𝕜
hM : M (inr ()) (inr ()) ≠ 0
i : Fin r
this : listTransvecCol M = listTransvecCol (M * (listTransvecRow M).prod)
⊢ ((listTransvecCol M).prod * M * (listTransvecRow M).prod) (inl i) (inr ()) = 0
state_after: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝³ : Field 𝕜
inst✝² : DecidableEq n
inst✝¹ : DecidableEq p
inst✝ : CommRing R
r : ℕ
M : Matrix (Fin r ⊕ Unit) (Fin r ⊕ Unit) 𝕜
hM : M (inr ()) (inr ()) ≠ 0
i : Fin r
this : listTransvecCol M = listTransvecCol (M * (listTransvecRow M).prod)
⊢ ((listTransvecCol (M * (listTransvecRow M).prod)).prod * (M * (listTransvecRow M).prod)) (inl i) (inr ()) = 0
tactic: rw [this, Matrix.mul_assoc]
state_before: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝³ : Field 𝕜
inst✝² : DecidableEq n
inst✝¹ : DecidableEq p
inst✝ : CommRing R
r : ℕ
M : Matrix (Fin r ⊕ Unit) (Fin r ⊕ Unit) 𝕜
hM : M (inr ()) (inr ()) ≠ 0
i : Fin r
this : listTransvecCol M = listTransvecCol (M * (listTransvecRow M).prod)
⊢ ((listTransvecCol (M * (listTransvecRow M).prod)).prod * (M * (listTransvecRow M).prod)) (inl i) (inr ()) = 0
state_after: case hM
n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝³ : Field 𝕜
inst✝² : DecidableEq n
inst✝¹ : DecidableEq p
inst✝ : CommRing R
r : ℕ
M : Matrix (Fin r ⊕ Unit) (Fin r ⊕ Unit) 𝕜
hM : M (inr ()) (inr ()) ≠ 0
i : Fin r
this : listTransvecCol M = listTransvecCol (M * (listTransvecRow M).prod)
⊢ (M * (listTransvecRow M).prod) (inr ()) (inr ()) ≠ 0
tactic: apply listTransvecCol_mul_last_col
state_before: case hM
n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝³ : Field 𝕜
inst✝² : DecidableEq n
inst✝¹ : DecidableEq p
inst✝ : CommRing R
r : ℕ
M : Matrix (Fin r ⊕ Unit) (Fin r ⊕ Unit) 𝕜
hM : M (inr ()) (inr ()) ≠ 0
i : Fin r
this : listTransvecCol M = listTransvecCol (M * (listTransvecRow M).prod)
⊢ (M * (listTransvecRow M).prod) (inr ()) (inr ()) ≠ 0
state_after: no goals
tactic: simpa [mul_listTransvecRow_last_col] using hM
Theorem: Polynomial.natDegree_natCast
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
⊢ (↑n).natDegree = 0
state_after: no goals
tactic: simp only [← C_eq_natCast, natDegree_C]