ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ne_zero_of_dvd_ne_zero
File: Mathlib/Algebra/GroupWithZero/Divisibility.lean

Proof steps:
state_before: α : Type u_1
inst✝ : MonoidWithZero α
p q : α
h₁ : q ≠ 0
h₂ : p ∣ q
⊢ p ≠ 0
state_after: case intro
α : Type u_1
inst✝ : MonoidWithZero α
p u : α
h₁ : p * u ≠ 0
⊢ p ≠ 0
tactic: rcases h₂ with ⟨u, rfl⟩
state_before: case intro
α : Type u_1
inst✝ : MonoidWithZero α
p u : α
h₁ : p * u ≠ 0
⊢ p ≠ 0
state_after: no goals
tactic: exact left_ne_zero_of_mul h₁
Theorem: PartENat.add_eq_top_iff
File: Mathlib/Data/Nat/PartENat.lean

Proof steps:
state_before: a b : PartENat
⊢ a + b = ⊤ ↔ a = ⊤ ∨ b = ⊤
state_after: case refine_2.refine_2
a b : PartENat
⊢ ∀ (n n_1 : ℕ), ¬↑n_1 + ↑n = ⊤
tactic: refine PartENat.casesOn a ?_ ?_
  <;> refine PartENat.casesOn b ?_ ?_
  <;> simp [top_add, add_top]
state_before: case refine_2.refine_2
a b : PartENat
⊢ ∀ (n n_1 : ℕ), ¬↑n_1 + ↑n = ⊤
state_after: no goals
tactic: simp only [← Nat.cast_add, PartENat.natCast_ne_top, forall_const, not_false_eq_true]
Theorem: AddCircle.homeomorphCircle'_apply
File: Mathlib/Analysis/SpecialFunctions/Complex/Circle.lean

Proof steps:
state_before: T : ℝ
⊢ Continuous
    { toFun := Angle.expMapCircle, invFun := fun x => ↑(↑x).arg, left_inv := Angle.arg_expMapCircle,
        right_inv := expMapCircle_arg }.invFun
state_after: T : ℝ
⊢ ∀ (x : ↥circle),
    ContinuousAt
      { toFun := Angle.expMapCircle, invFun := fun x => ↑(↑x).arg, left_inv := Angle.arg_expMapCircle,
          right_inv := expMapCircle_arg }.invFun
      x
tactic: rw [continuous_iff_continuousAt]
state_before: T : ℝ
⊢ ∀ (x : ↥circle),
    ContinuousAt
      { toFun := Angle.expMapCircle, invFun := fun x => ↑(↑x).arg, left_inv := Angle.arg_expMapCircle,
          right_inv := expMapCircle_arg }.invFun
      x
state_after: T : ℝ
x : ↥circle
⊢ ContinuousAt
    { toFun := Angle.expMapCircle, invFun := fun x => ↑(↑x).arg, left_inv := Angle.arg_expMapCircle,
        right_inv := expMapCircle_arg }.invFun
    x
tactic: intro x
state_before: T : ℝ
x : ↥circle
⊢ ContinuousAt
    { toFun := Angle.expMapCircle, invFun := fun x => ↑(↑x).arg, left_inv := Angle.arg_expMapCircle,
        right_inv := expMapCircle_arg }.invFun
    x
state_after: no goals
tactic: apply (continuousAt_arg_coe_angle (ne_zero_of_mem_circle x)).comp
      continuousAt_subtype_val
Theorem: SimplicialObject.Splitting.ofIso_ι
File: Mathlib/AlgebraicTopology/SplitSimplicialObject.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{?u.26425, u_1} C
X Y : SimplicialObject C
s : Splitting X
e : X ≅ Y
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ (s.cofan Δ).inj A ≫ (e.app Δ).hom = (cofan' s.N Y (fun n => s.ι n ≫ e.hom.app (op [n])) Δ).inj A
state_after: no goals
tactic: simp [cofan, cofan']
Theorem: Set.toFinset_Icc
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✝¹ : LocallyFiniteOrder α
a b : α
inst✝ : Fintype ↑(Icc a b)
⊢ (Icc a b).toFinset = Finset.Icc a b
state_after: case a
α✝ : Type u_1
β : Type u_2
inst✝⁴ : Preorder α✝
p : α✝ → Prop
inst✝³ : DecidablePred p
y : α✝
α : Type u_3
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a b : α
inst✝ : Fintype ↑(Icc a b)
a✝ : α
⊢ a✝ ∈ (Icc a b).toFinset ↔ a✝ ∈ Finset.Icc a b
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✝¹ : LocallyFiniteOrder α
a b : α
inst✝ : Fintype ↑(Icc a b)
a✝ : α
⊢ a✝ ∈ (Icc a b).toFinset ↔ a✝ ∈ Finset.Icc a b
state_after: no goals
tactic: simp
Theorem: LinearMap.rank_comp_le_left
File: Mathlib/LinearAlgebra/Dimension/LinearMap.lean

Proof steps:
state_before: K : Type u
V V₁ : Type v
V' V'₁ : Type v'
V'' : Type v''
inst✝⁸ : Ring K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
inst✝⁵ : AddCommGroup V₁
inst✝⁴ : Module K V₁
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V''
inst✝ : Module K V''
g : V →ₗ[K] V'
f : V' →ₗ[K] V''
⊢ (f ∘ₗ g).rank ≤ f.rank
state_after: K : Type u
V V₁ : Type v
V' V'₁ : Type v'
V'' : Type v''
inst✝⁸ : Ring K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
inst✝⁵ : AddCommGroup V₁
inst✝⁴ : Module K V₁
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V''
inst✝ : Module K V''
g : V →ₗ[K] V'
f : V' →ₗ[K] V''
⊢ range (f ∘ₗ g) ≤ range f
tactic: refine rank_le_of_submodule _ _ ?_
state_before: K : Type u
V V₁ : Type v
V' V'₁ : Type v'
V'' : Type v''
inst✝⁸ : Ring K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
inst✝⁵ : AddCommGroup V₁
inst✝⁴ : Module K V₁
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V''
inst✝ : Module K V''
g : V →ₗ[K] V'
f : V' →ₗ[K] V''
⊢ range (f ∘ₗ g) ≤ range f
state_after: K : Type u
V V₁ : Type v
V' V'₁ : Type v'
V'' : Type v''
inst✝⁸ : Ring K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
inst✝⁵ : AddCommGroup V₁
inst✝⁴ : Module K V₁
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V''
inst✝ : Module K V''
g : V →ₗ[K] V'
f : V' →ₗ[K] V''
⊢ Submodule.map f (range g) ≤ range f
tactic: rw [LinearMap.range_comp]
state_before: K : Type u
V V₁ : Type v
V' V'₁ : Type v'
V'' : Type v''
inst✝⁸ : Ring K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
inst✝⁵ : AddCommGroup V₁
inst✝⁴ : Module K V₁
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V''
inst✝ : Module K V''
g : V →ₗ[K] V'
f : V' →ₗ[K] V''
⊢ Submodule.map f (range g) ≤ range f
state_after: no goals
tactic: exact LinearMap.map_le_range
Theorem: SetTheory.PGame.sub_zero
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
x : PGame
⊢ x + -0 = x + 0
state_after: no goals
tactic: rw [neg_zero]
Theorem: Submodule.span_singleton_eq_span_singleton
File: Mathlib/LinearAlgebra/Span.lean

Proof steps:
state_before: R✝ : Type u_1
R₂ : Type u_2
K : Type u_3
M✝ : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝¹¹ : Semiring R✝
inst✝¹⁰ : AddCommMonoid M✝
inst✝⁹ : Module R✝ M✝
x✝ : M✝
p p' : Submodule R✝ M✝
inst✝⁸ : Semiring R₂
σ₁₂ : R✝ →+* R₂
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Module R₂ M₂
F : Type u_8
inst✝⁵ : FunLike F M✝ M₂
inst✝⁴ : SemilinearMapClass F σ₁₂ M✝ M₂
s t : Set M✝
R : Type u_9
M : Type u_10
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
x y : M
⊢ span R {x} = span R {y} ↔ ∃ z, z • x = y
state_after: case mp
R✝ : Type u_1
R₂ : Type u_2
K : Type u_3
M✝ : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝¹¹ : Semiring R✝
inst✝¹⁰ : AddCommMonoid M✝
inst✝⁹ : Module R✝ M✝
x✝ : M✝
p p' : Submodule R✝ M✝
inst✝⁸ : Semiring R₂
σ₁₂ : R✝ →+* R₂
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Module R₂ M₂
F : Type u_8
inst✝⁵ : FunLike F M✝ M₂
inst✝⁴ : SemilinearMapClass F σ₁₂ M✝ M₂
s t : Set M✝
R : Type u_9
M : Type u_10
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
x y : M
⊢ span R {x} = span R {y} → ∃ z, z • x = y

case mpr
R✝ : Type u_1
R₂ : Type u_2
K : Type u_3
M✝ : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝¹¹ : Semiring R✝
inst✝¹⁰ : AddCommMonoid M✝
inst✝⁹ : Module R✝ M✝
x✝ : M✝
p p' : Submodule R✝ M✝
inst✝⁸ : Semiring R₂
σ₁₂ : R✝ →+* R₂
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Module R₂ M₂
F : Type u_8
inst✝⁵ : FunLike F M✝ M₂
inst✝⁴ : SemilinearMapClass F σ₁₂ M✝ M₂
s t : Set M✝
R : Type u_9
M : Type u_10
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
x y : M
⊢ (∃ z, z • x = y) → span R {x} = span R {y}
tactic: constructor
Theorem: Ideal.injective_quotient_le_comap_map
File: Mathlib/RingTheory/Ideal/Over.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommRing R
S : Type u_2
inst✝ : CommRing S
f : R →+* S
I J : Ideal S
P : Ideal R[X]
⊢ Function.Injective
    ⇑(quotientMap (map (mapRingHom (Quotient.mk (comap C P))) P) (mapRingHom (Quotient.mk (comap C P))) ⋯)
state_after: R : Type u_1
inst✝¹ : CommRing R
S : Type u_2
inst✝ : CommRing S
f : R →+* S
I J : Ideal S
P : Ideal R[X]
⊢ comap (mapRingHom (Quotient.mk (comap C P))) (map (mapRingHom (Quotient.mk (comap C P))) P) = P
tactic: refine quotientMap_injective' (le_of_eq ?_)
state_before: R : Type u_1
inst✝¹ : CommRing R
S : Type u_2
inst✝ : CommRing S
f : R →+* S
I J : Ideal S
P : Ideal R[X]
⊢ comap (mapRingHom (Quotient.mk (comap C P))) (map (mapRingHom (Quotient.mk (comap C P))) P) = P
state_after: R : Type u_1
inst✝¹ : CommRing R
S : Type u_2
inst✝ : CommRing S
f : R →+* S
I J : Ideal S
P : Ideal R[X]
⊢ P ⊔ comap (mapRingHom (Quotient.mk (comap C P))) ⊥ = P
tactic: rw [comap_map_of_surjective (mapRingHom (Ideal.Quotient.mk (P.comap (C : R →+* R[X]))))
      (map_surjective (Ideal.Quotient.mk (P.comap (C : R →+* R[X]))) Ideal.Quotient.mk_surjective)]
state_before: R : Type u_1
inst✝¹ : CommRing R
S : Type u_2
inst✝ : CommRing S
f : R →+* S
I J : Ideal S
P : Ideal R[X]
⊢ P ⊔ comap (mapRingHom (Quotient.mk (comap C P))) ⊥ = P
state_after: R : Type u_1
inst✝¹ : CommRing R
S : Type u_2
inst✝ : CommRing S
f : R →+* S
I J : Ideal S
P : Ideal R[X]
⊢ comap (mapRingHom (Quotient.mk (comap C P))) ⊥ ≤ P
tactic: refine le_antisymm (sup_le le_rfl ?_) (le_sup_of_le_left le_rfl)
state_before: R : Type u_1
inst✝¹ : CommRing R
S : Type u_2
inst✝ : CommRing S
f : R →+* S
I J : Ideal S
P : Ideal R[X]
⊢ comap (mapRingHom (Quotient.mk (comap C P))) ⊥ ≤ P
state_after: R : Type u_1
inst✝¹ : CommRing R
S : Type u_2
inst✝ : CommRing S
f : R →+* S
I J : Ideal S
P : Ideal R[X]
p : R[X]
hp : p ∈ comap (mapRingHom (Quotient.mk (comap C P))) ⊥
n : ℕ
⊢ (Quotient.mk (comap C P)) (p.coeff n) = 0
tactic: refine fun p hp =>
    polynomial_mem_ideal_of_coeff_mem_ideal P p fun n => Ideal.Quotient.eq_zero_iff_mem.mp ?_
state_before: R : Type u_1
inst✝¹ : CommRing R
S : Type u_2
inst✝ : CommRing S
f : R →+* S
I J : Ideal S
P : Ideal R[X]
p : R[X]
hp : p ∈ comap (mapRingHom (Quotient.mk (comap C P))) ⊥
n : ℕ
⊢ (Quotient.mk (comap C P)) (p.coeff n) = 0
state_after: no goals
tactic: simpa only [coeff_map, coe_mapRingHom] using ext_iff.mp (Ideal.mem_bot.mp (mem_comap.mp hp)) n
Theorem: WittVector.verschiebungFun_coeff
File: Mathlib/RingTheory/WittVector/Verschiebung.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
x : 𝕎 R
n : ℕ
⊢ x.verschiebungFun.coeff n = if n = 0 then 0 else x.coeff (n - 1)
state_after: no goals
tactic: simp only [verschiebungFun]
Theorem: _private.Mathlib.Algebra.Polynomial.Identities.0.Polynomial.poly_binom_aux2
File: Mathlib/Algebra/Polynomial/Identities.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type x
k : Type y
A : Type z
a b : R
m n : ℕ
inst✝ : CommRing R
f : R[X]
x y : R
⊢ eval (x + y) f = f.sum fun e a => a * (x ^ e + ↑e * x ^ (e - 1) * y + ↑(Polynomial.polyBinomAux1 x y e a) * y ^ 2)
state_after: R : Type u
S : Type v
T : Type w
ι : Type x
k : Type y
A : Type z
a b : R
m n : ℕ
inst✝ : CommRing R
f : R[X]
x y : R
⊢ eval₂ (RingHom.id R) (x + y) f =
    f.sum fun e a => a * (x ^ e + ↑e * x ^ (e - 1) * y + ↑(Polynomial.polyBinomAux1 x y e a) * y ^ 2)
tactic: unfold eval
state_before: R : Type u
S : Type v
T : Type w
ι : Type x
k : Type y
A : Type z
a b : R
m n : ℕ
inst✝ : CommRing R
f : R[X]
x y : R
⊢ eval₂ (RingHom.id R) (x + y) f =
    f.sum fun e a => a * (x ^ e + ↑e * x ^ (e - 1) * y + ↑(Polynomial.polyBinomAux1 x y e a) * y ^ 2)
state_after: R : Type u
S : Type v
T : Type w
ι : Type x
k : Type y
A : Type z
a b : R
m n : ℕ
inst✝ : CommRing R
f : R[X]
x y : R
⊢ (f.sum fun e a => (RingHom.id R) a * (x + y) ^ e) =
    f.sum fun e a => a * (x ^ e + ↑e * x ^ (e - 1) * y + ↑(Polynomial.polyBinomAux1 x y e a) * y ^ 2)
tactic: rw [eval₂_eq_sum]
state_before: R : Type u
S : Type v
T : Type w
ι : Type x
k : Type y
A : Type z
a b : R
m n : ℕ
inst✝ : CommRing R
f : R[X]
x y : R
⊢ (f.sum fun e a => (RingHom.id R) a * (x + y) ^ e) =
    f.sum fun e a => a * (x ^ e + ↑e * x ^ (e - 1) * y + ↑(Polynomial.polyBinomAux1 x y e a) * y ^ 2)
state_after: case e_f.h.h
R : Type u
S : Type v
T : Type w
ι : Type x
k : Type y
A : Type z
a b : R
m n✝ : ℕ
inst✝ : CommRing R
f : R[X]
x y : R
n : ℕ
z : R
⊢ (RingHom.id R) z * (x + y) ^ n = z * (x ^ n + ↑n * x ^ (n - 1) * y + ↑(Polynomial.polyBinomAux1 x y n z) * y ^ 2)
tactic: congr with (n z)
state_before: case e_f.h.h
R : Type u
S : Type v
T : Type w
ι : Type x
k : Type y
A : Type z
a b : R
m n✝ : ℕ
inst✝ : CommRing R
f : R[X]
x y : R
n : ℕ
z : R
⊢ (RingHom.id R) z * (x + y) ^ n = z * (x ^ n + ↑n * x ^ (n - 1) * y + ↑(Polynomial.polyBinomAux1 x y n z) * y ^ 2)
state_after: no goals
tactic: apply (polyBinomAux1 x y _ _).property
Theorem: card_derangements_fin_add_two
File: Mathlib/Combinatorics/Derangements/Finite.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
n : ℕ
⊢ card ↑(derangements (Fin (n + 2))) =
    (n + 1) * card ↑(derangements (Fin n)) + (n + 1) * card ↑(derangements (Fin (n + 1)))
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
n : ℕ
h1 : ∀ (a : Fin (n + 1)), card ↑{a}ᶜ = card (Fin n)
⊢ card ↑(derangements (Fin (n + 2))) =
    (n + 1) * card ↑(derangements (Fin n)) + (n + 1) * card ↑(derangements (Fin (n + 1)))
tactic: have h1 : ∀ a : Fin (n + 1), card ({a}ᶜ : Set (Fin (n + 1))) = card (Fin n) := by
    intro a
    simp only [Fintype.card_fin, Finset.card_fin, Fintype.card_ofFinset, Finset.filter_ne' _ a,
      Set.mem_compl_singleton_iff, Finset.card_erase_of_mem (Finset.mem_univ a),
      add_tsub_cancel_right]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
n : ℕ
h1 : ∀ (a : Fin (n + 1)), card ↑{a}ᶜ = card (Fin n)
⊢ card ↑(derangements (Fin (n + 2))) =
    (n + 1) * card ↑(derangements (Fin n)) + (n + 1) * card ↑(derangements (Fin (n + 1)))
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
n : ℕ
h1 : ∀ (a : Fin (n + 1)), card ↑{a}ᶜ = card (Fin n)
h2 : card (Fin (n + 2)) = card (Option (Fin (n + 1)))
⊢ card ↑(derangements (Fin (n + 2))) =
    (n + 1) * card ↑(derangements (Fin n)) + (n + 1) * card ↑(derangements (Fin (n + 1)))
tactic: have h2 : card (Fin (n + 2)) = card (Option (Fin (n + 1))) := by simp only [card_fin, card_option]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
n : ℕ
h1 : ∀ (a : Fin (n + 1)), card ↑{a}ᶜ = card (Fin n)
h2 : card (Fin (n + 2)) = card (Option (Fin (n + 1)))
⊢ card ↑(derangements (Fin (n + 2))) =
    (n + 1) * card ↑(derangements (Fin n)) + (n + 1) * card ↑(derangements (Fin (n + 1)))
state_after: no goals
tactic: simp only [card_derangements_invariant h2,
    card_congr
      (@derangementsRecursionEquiv (Fin (n + 1))
        _),-- push the cardinality through the Σ and ⊕ so that we can use `card_n`
    card_sigma,
    card_sum, card_derangements_invariant (h1 _), Finset.sum_const, nsmul_eq_mul, Finset.card_fin,
    mul_add, Nat.cast_id]
Theorem: Set.wellFoundedOn_image
File: Mathlib/Order/WellFoundedSet.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
π : ι → Type u_5
r r' : α → α → Prop
f : β → α
s✝ t : Set α
x y : α
s : Set β
⊢ (f '' s).WellFoundedOn r ↔ s.WellFoundedOn (r on f)
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
π : ι → Type u_5
r r' : α → α → Prop
f : β → α
s✝ t : Set α
x y : α
s : Set β
⊢ (range fun x => f ↑x).WellFoundedOn r ↔ s.WellFoundedOn (r on f)
tactic: rw [image_eq_range]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
π : ι → Type u_5
r r' : α → α → Prop
f : β → α
s✝ t : Set α
x y : α
s : Set β
⊢ (range fun x => f ↑x).WellFoundedOn r ↔ s.WellFoundedOn (r on f)
state_after: no goals
tactic: exact wellFoundedOn_range
Theorem: Filter.tendsto_nhds_max_left
File: Mathlib/Topology/Order/OrderClosed.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderClosedTopology α
f g : β → α
l : Filter β
a : α
h : Tendsto f l (𝓝[>] a)
⊢ Tendsto (fun i => max (f i) a) l (𝓝[>] a)
state_after: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderClosedTopology α
f g : β → α
l : Filter β
a : α
h : Tendsto f l (𝓝[>] a)
⊢ Tendsto (fun i => max a (f i)) l (𝓝[>] a)
tactic: simp_rw [max_comm _ a]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderClosedTopology α
f g : β → α
l : Filter β
a : α
h : Tendsto f l (𝓝[>] a)
⊢ Tendsto (fun i => max a (f i)) l (𝓝[>] a)
state_after: no goals
tactic: exact Filter.tendsto_nhds_max_right h
Theorem: nhds_bot_order
File: Mathlib/Topology/Order/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : Preorder α
inst✝¹ : OrderBot α
inst✝ : OrderTopology α
⊢ 𝓝 ⊥ = ⨅ l, ⨅ (_ : ⊥ < l), 𝓟 (Iio l)
state_after: no goals
tactic: simp [nhds_eq_order (⊥ : α)]
Theorem: max_def'
File: Mathlib/Order/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : LinearOrder α
a b : α
⊢ max a b = if b ≤ a then a else b
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : LinearOrder α
a b : α
⊢ (if a ≤ b then b else a) = if b ≤ a then a else b
tactic: rw [max_def]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : LinearOrder α
a b : α
⊢ (if a ≤ b then b else a) = if b ≤ a then a else b
state_after: case inl
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : LinearOrder α
a b : α
lt : a < b
⊢ (if a ≤ b then b else a) = if b ≤ a then a else b

case inr.inl
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : LinearOrder α
a b : α
eq : a = b
⊢ (if a ≤ b then b else a) = if b ≤ a then a else b

case inr.inr
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : LinearOrder α
a b : α
gt : b < a
⊢ (if a ≤ b then b else a) = if b ≤ a then a else b
tactic: rcases lt_trichotomy a b with (lt | eq | gt)
Theorem: CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.imageMonoFactorisation_e'
File: Mathlib/CategoryTheory/Abelian/Basic.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
inst✝¹ : HasKernels C
inst✝ : HasCokernels C
X Y : C
f : X ⟶ Y
⊢ (imageMonoFactorisation f).e = cokernel.π (kernel.ι f) ≫ coimageImageComparison f
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
inst✝¹ : HasKernels C
inst✝ : HasCokernels C
X Y : C
f : X ⟶ Y
⊢ kernel.lift (cokernel.π f) f ⋯ = cokernel.π (kernel.ι f) ≫ coimageImageComparison f
tactic: dsimp
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
inst✝¹ : HasKernels C
inst✝ : HasCokernels C
X Y : C
f : X ⟶ Y
⊢ kernel.lift (cokernel.π f) f ⋯ = cokernel.π (kernel.ι f) ≫ coimageImageComparison f
state_after: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
inst✝¹ : HasKernels C
inst✝ : HasCokernels C
X Y : C
f : X ⟶ Y
⊢ kernel.lift (cokernel.π f) f ⋯ ≫ equalizer.ι (cokernel.π f) 0 =
    (cokernel.π (kernel.ι f) ≫ coimageImageComparison f) ≫ equalizer.ι (cokernel.π f) 0
tactic: ext
state_before: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
inst✝¹ : HasKernels C
inst✝ : HasCokernels C
X Y : C
f : X ⟶ Y
⊢ kernel.lift (cokernel.π f) f ⋯ ≫ equalizer.ι (cokernel.π f) 0 =
    (cokernel.π (kernel.ι f) ≫ coimageImageComparison f) ≫ equalizer.ι (cokernel.π f) 0
state_after: no goals
tactic: simp only [Abelian.coimageImageComparison, imageMonoFactorisation_e, Category.assoc,
    cokernel.π_desc_assoc]
Theorem: t2Quotient.unique_lift
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X✝ : Type u_1
Y✝ : Type u_2
inst✝⁴ : TopologicalSpace X✝
inst✝³ : FirstCountableTopology X✝
X : Type u_3
Y : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : T2Space Y
f : X → Y
hf : Continuous f
g : t2Quotient X → Y
hfg : g ∘ mk = f
⊢ g = lift hf
state_after: X✝ : Type u_1
Y✝ : Type u_2
inst✝⁴ : TopologicalSpace X✝
inst✝³ : FirstCountableTopology X✝
X : Type u_3
Y : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : T2Space Y
f : X → Y
hf : Continuous f
g : t2Quotient X → Y
hfg : g ∘ mk = f
⊢ ∀ (x : X), (g ∘ mk) x = (lift hf ∘ mk) x
tactic: apply surjective_mk X |>.right_cancellable |>.mp <| funext _
state_before: X✝ : Type u_1
Y✝ : Type u_2
inst✝⁴ : TopologicalSpace X✝
inst✝³ : FirstCountableTopology X✝
X : Type u_3
Y : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : T2Space Y
f : X → Y
hf : Continuous f
g : t2Quotient X → Y
hfg : g ∘ mk = f
⊢ ∀ (x : X), (g ∘ mk) x = (lift hf ∘ mk) x
state_after: no goals
tactic: simp [← hfg]
Theorem: CharTwo.add_self_eq_zero
File: Mathlib/Algebra/CharP/Two.lean

Proof steps:
state_before: R : Type u_1
ι : Type u_2
inst✝¹ : Semiring R
inst✝ : CharP R 2
x : R
⊢ x + x = 0
state_after: no goals
tactic: rw [← two_smul R x, two_eq_zero, zero_smul]
Theorem: Mathlib.Meta.NormNum.isRat_inv_neg
File: Mathlib/Tactic/NormNum/Inv.lean

Proof steps:
state_before: u : Lean.Level
α : Type u_1
inst✝¹ : DivisionRing α
inst✝ : CharZero α
a : α
n d : ℕ
⊢ IsRat a (Int.negOfNat n.succ) d → IsRat a⁻¹ (Int.negOfNat d) n.succ
state_after: case mk
u : Lean.Level
α : Type u_1
inst✝¹ : DivisionRing α
inst✝ : CharZero α
n d : ℕ
inv✝ : Invertible ↑d
⊢ IsRat (↑(Int.negOfNat n.succ) * ⅟↑d)⁻¹ (Int.negOfNat d) n.succ
tactic: rintro ⟨_, rfl⟩
state_before: case mk
u : Lean.Level
α : Type u_1
inst✝¹ : DivisionRing α
inst✝ : CharZero α
n d : ℕ
inv✝ : Invertible ↑d
⊢ IsRat (↑(Int.negOfNat n.succ) * ⅟↑d)⁻¹ (Int.negOfNat d) n.succ
state_after: case mk
u : Lean.Level
α : Type u_1
inst✝¹ : DivisionRing α
inst✝ : CharZero α
n d : ℕ
inv✝ : Invertible ↑d
⊢ IsRat (↑(-Int.ofNat n.succ) * ⅟↑d)⁻¹ (-Int.ofNat d) n.succ
tactic: simp only [Int.negOfNat_eq]
state_before: case mk
u : Lean.Level
α : Type u_1
inst✝¹ : DivisionRing α
inst✝ : CharZero α
n d : ℕ
inv✝ : Invertible ↑d
⊢ IsRat (↑(-Int.ofNat n.succ) * ⅟↑d)⁻¹ (-Int.ofNat d) n.succ
state_after: case mk
u : Lean.Level
α : Type u_1
inst✝¹ : DivisionRing α
inst✝ : CharZero α
n d : ℕ
inv✝ : Invertible ↑d
this : Invertible ↑n.succ
⊢ IsRat (↑(-Int.ofNat n.succ) * ⅟↑d)⁻¹ (-Int.ofNat d) n.succ
tactic: have := invertibleOfNonzero (α := α) (Nat.cast_ne_zero.2 (Nat.succ_ne_zero n))
state_before: case mk
u : Lean.Level
α : Type u_1
inst✝¹ : DivisionRing α
inst✝ : CharZero α
n d : ℕ
inv✝ : Invertible ↑d
this : Invertible ↑n.succ
⊢ IsRat (↑(-Int.ofNat n.succ) * ⅟↑d)⁻¹ (-Int.ofNat d) n.succ
state_after: case mk
u : Lean.Level
α : Type u_1
inst✝¹ : DivisionRing α
inst✝ : CharZero α
n✝ d : ℕ
inv✝ : Invertible ↑d
n : ℕ
this : Invertible ↑n
⊢ IsRat (↑(-Int.ofNat n) * ⅟↑d)⁻¹ (-Int.ofNat d) n
tactic: generalize Nat.succ n = n at *
state_before: case mk
u : Lean.Level
α : Type u_1
inst✝¹ : DivisionRing α
inst✝ : CharZero α
n✝ d : ℕ
inv✝ : Invertible ↑d
n : ℕ
this : Invertible ↑n
⊢ IsRat (↑(-Int.ofNat n) * ⅟↑d)⁻¹ (-Int.ofNat d) n
state_after: case eq
u : Lean.Level
α : Type u_1
inst✝¹ : DivisionRing α
inst✝ : CharZero α
n✝ d : ℕ
inv✝ : Invertible ↑d
n : ℕ
this : Invertible ↑n
⊢ (↑(-Int.ofNat n) * ⅟↑d)⁻¹ = ↑(-Int.ofNat d) * ⅟↑n
tactic: use this
state_before: case eq
u : Lean.Level
α : Type u_1
inst✝¹ : DivisionRing α
inst✝ : CharZero α
n✝ d : ℕ
inv✝ : Invertible ↑d
n : ℕ
this : Invertible ↑n
⊢ (↑(-Int.ofNat n) * ⅟↑d)⁻¹ = ↑(-Int.ofNat d) * ⅟↑n
state_after: no goals
tactic: simp only [Int.ofNat_eq_coe, Int.cast_neg,
    Int.cast_natCast, invOf_eq_inv, inv_neg, neg_mul, mul_inv_rev, inv_inv]
Theorem: IntermediateField.mem_adjoin_simple_iff
File: Mathlib/FieldTheory/Adjoin.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α x : E
⊢ x ∈ adjoin F {α} ↔ ∃ r s, x = (aeval α) r / (aeval α) s
state_after: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α x : E
⊢ (∃ a a_1, (aeval α) a / (aeval α) a_1 = x) ↔ ∃ r s, x = (aeval α) r / (aeval α) s
tactic: simp only [adjoin, mem_mk, Subring.mem_toSubsemiring, Subfield.mem_toSubring,
    Subfield.mem_closure_iff, ← Algebra.adjoin_eq_ring_closure, Subalgebra.mem_toSubring,
    Algebra.adjoin_singleton_eq_range_aeval, AlgHom.mem_range, exists_exists_eq_and]
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α x : E
⊢ (∃ a a_1, (aeval α) a / (aeval α) a_1 = x) ↔ ∃ r s, x = (aeval α) r / (aeval α) s
state_after: no goals
tactic: tauto