ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: LinearMap.eq_adjoint_iff
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁹ : RCLike 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
A : E →ₗ[𝕜] F
B : F →ₗ[𝕜] E
⊢ A = adjoint B ↔ ∀ (x : E) (y : F), ⟪A x, y⟫_𝕜 = ⟪x, B y⟫_𝕜
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁹ : RCLike 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
A : E →ₗ[𝕜] F
B : F →ₗ[𝕜] E
h : ∀ (x : E) (y : F), ⟪A x, y⟫_𝕜 = ⟪x, B y⟫_𝕜
⊢ A = adjoint B
tactic: refine ⟨fun h x y => by rw [h, adjoint_inner_left], fun h => ?_⟩
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁹ : RCLike 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
A : E →ₗ[𝕜] F
B : F →ₗ[𝕜] E
h : ∀ (x : E) (y : F), ⟪A x, y⟫_𝕜 = ⟪x, B y⟫_𝕜
⊢ A = adjoint B
state_after: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁹ : RCLike 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
A : E →ₗ[𝕜] F
B : F →ₗ[𝕜] E
h : ∀ (x : E) (y : F), ⟪A x, y⟫_𝕜 = ⟪x, B y⟫_𝕜
x : E
⊢ A x = (adjoint B) x
tactic: ext x
state_before: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁹ : RCLike 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
A : E →ₗ[𝕜] F
B : F →ₗ[𝕜] E
h : ∀ (x : E) (y : F), ⟪A x, y⟫_𝕜 = ⟪x, B y⟫_𝕜
x : E
⊢ A x = (adjoint B) x
state_after: no goals
tactic: exact ext_inner_right 𝕜 fun y => by simp only [adjoint_inner_left, h x y]
Theorem: WithLp.unitization_norm_def
File: Mathlib/Analysis/Normed/Algebra/UnitizationL1.lean

Proof steps:
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝⁴ : NormedField 𝕜
inst✝³ : NonUnitalNormedRing A
inst✝² : NormedSpace 𝕜 A
inst✝¹ : IsScalarTower 𝕜 A A
inst✝ : SMulCommClass 𝕜 A A
x : WithLp 1 (Unitization 𝕜 A)
⊢ 0 < ENNReal.toReal 1
state_after: no goals
tactic: simp
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝⁴ : NormedField 𝕜
inst✝³ : NonUnitalNormedRing A
inst✝² : NormedSpace 𝕜 A
inst✝¹ : IsScalarTower 𝕜 A A
inst✝ : SMulCommClass 𝕜 A A
x : WithLp 1 (Unitization 𝕜 A)
⊢ (‖((WithLp.equiv 1 (Unitization 𝕜 A)) x).fst‖ ^ ENNReal.toReal 1 +
        ‖((WithLp.equiv 1 (Unitization 𝕜 A)) x).snd‖ ^ ENNReal.toReal 1) ^
      (1 / ENNReal.toReal 1) =
    ‖((WithLp.equiv 1 (Unitization 𝕜 A)) x).fst‖ + ‖((WithLp.equiv 1 (Unitization 𝕜 A)) x).snd‖
state_after: no goals
tactic: simp
Theorem: Hyperreal.infinite_mul_of_not_infinitesimal_infinite
File: Mathlib/Data/Real/Hyperreal.lean

Proof steps:
state_before: x y : ℝ*
hx : ¬x.Infinitesimal
hy : y.Infinite
⊢ (x * y).Infinite
state_after: x y : ℝ*
hx : ¬x.Infinitesimal
hy : y.Infinite
⊢ (y * x).Infinite
tactic: rw [mul_comm]
state_before: x y : ℝ*
hx : ¬x.Infinitesimal
hy : y.Infinite
⊢ (y * x).Infinite
state_after: no goals
tactic: exact infinite_mul_of_infinite_not_infinitesimal hy hx
Theorem: AddLocalization.mk_eq_addMonoidOf_mk'_apply
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
x : M
y : ↥S
⊢ mk x y * (monoidOf S).toMap ↑y = (monoidOf S).toMap x
state_after: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
x : M
y : ↥S
⊢ mk (x * ↑y) (1 * y) = mk x 1
tactic: rw [← mk_one_eq_monoidOf_mk, ← mk_one_eq_monoidOf_mk, mk_mul x y y 1, mul_comm y 1]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
x : M
y : ↥S
⊢ mk (x * ↑y) (1 * y) = mk x 1
state_after: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
x : M
y : ↥S
⊢ mk (x * ↑y) (1 * y) = mk (x * 1) (1 * 1)
tactic: conv => rhs; rw [← mul_one 1]; rw [← mul_one x]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
x : M
y : ↥S
⊢ mk (x * ↑y) (1 * y) = mk (x * 1) (1 * 1)
state_after: no goals
tactic: exact mk_eq_mk_iff.2 (Con.symm _ <| (Localization.r S).mul (Con.refl _ (x, 1)) <| one_rel _)
Theorem: Num.ofZNum_toNat
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
p : PosNum
⊢ ↑(ofZNum (ZNum.pos p)) = (↑p).toNat
state_after: α : Type u_1
p : PosNum
⊢ ↑(ofZNum (ZNum.pos p)) = (↑↑p).toNat
tactic: rw [← PosNum.to_nat_to_int p]
state_before: α : Type u_1
p : PosNum
⊢ ↑(ofZNum (ZNum.pos p)) = (↑↑p).toNat
state_after: no goals
tactic: rfl
state_before: α : Type u_1
p : PosNum
⊢ ↑(↑p.pred' + 1) = ↑p
state_after: α : Type u_1
p : PosNum
⊢ ↑↑p.pred'.succ' = ↑p
tactic: rw [← succ'_to_nat]
state_before: α : Type u_1
p : PosNum
⊢ ↑↑p.pred'.succ' = ↑p
state_after: no goals
tactic: simp
Theorem: dist_sum_sum_le_of_le
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a✝ a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
s : Finset ι
f a : ι → E
d : ι → ℝ
h : ∀ b ∈ s, dist (f b) (a b) ≤ d b
⊢ dist (∏ b ∈ s, f b) (∏ b ∈ s, a b) ≤ ∑ b ∈ s, d b
state_after: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a✝ a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
s : Finset ι
f a : ι → E
d : ι → ℝ
h : ∀ b ∈ s, ‖f b / a b‖ ≤ d b
⊢ ‖∏ x ∈ s, f x / a x‖ ≤ ∑ b ∈ s, d b
tactic: simp only [dist_eq_norm_div, ← Finset.prod_div_distrib] at *
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a✝ a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
s : Finset ι
f a : ι → E
d : ι → ℝ
h : ∀ b ∈ s, ‖f b / a b‖ ≤ d b
⊢ ‖∏ x ∈ s, f x / a x‖ ≤ ∑ b ∈ s, d b
state_after: no goals
tactic: exact norm_prod_le_of_le s h
Theorem: ProjectiveSpectrum.basicOpen_zero
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
⊢ ↑(basicOpen 𝒜 0) = ↑⊥
state_after: no goals
tactic: simp
Theorem: Disjoint.edgeSet
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
H₁ H₂ : G.Subgraph
h : Disjoint H₁ H₂
⊢ H₁.edgeSet ⊓ H₂.edgeSet ≤ ⊥
state_after: no goals
tactic: simpa using edgeSet_mono h.le_bot
Theorem: CategoryTheory.NonPreadditiveAbelian.sub_sub_sub
File: Mathlib/CategoryTheory/Abelian/NonPreadditive.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b c d : X ⟶ Y
⊢ a - c - (b - d) = a - b - (c - d)
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b c d : X ⟶ Y
⊢ prod.lift (prod.lift a b ≫ σ) (prod.lift c d ≫ σ) ≫ σ = a - b - (c - d)
tactic: rw [sub_def, ← lift_sub_lift, sub_def, Category.assoc, σ_comp, prod.lift_map_assoc]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b c d : X ⟶ Y
⊢ prod.lift (prod.lift a b ≫ σ) (prod.lift c d ≫ σ) ≫ σ = a - b - (c - d)
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.Limits.Types.limitConeIsLimit_lift_coe
File: Mathlib/CategoryTheory/Limits/Types.lean

Proof steps:
state_before: J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ TypeMax
x✝¹ : Cone F
x✝ : x✝¹.pt ⟶ (limitCone F).pt
w : ∀ (j : J), x✝ ≫ (limitCone F).π.app j = x✝¹.π.app j
⊢ x✝ = (fun s v => ⟨fun j => s.π.app j v, ⋯⟩) x✝¹
state_after: case h
J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ TypeMax
x✝¹ : Cone F
x✝ : x✝¹.pt ⟶ (limitCone F).pt
w : ∀ (j : J), x✝ ≫ (limitCone F).π.app j = x✝¹.π.app j
x : x✝¹.pt
⊢ x✝ x = (fun s v => ⟨fun j => s.π.app j v, ⋯⟩) x✝¹ x
tactic: funext x
state_before: case h
J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ TypeMax
x✝¹ : Cone F
x✝ : x✝¹.pt ⟶ (limitCone F).pt
w : ∀ (j : J), x✝ ≫ (limitCone F).π.app j = x✝¹.π.app j
x : x✝¹.pt
⊢ x✝ x = (fun s v => ⟨fun j => s.π.app j v, ⋯⟩) x✝¹ x
state_after: case h.a
J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ TypeMax
x✝¹ : Cone F
x✝ : x✝¹.pt ⟶ (limitCone F).pt
w : ∀ (j : J), x✝ ≫ (limitCone F).π.app j = x✝¹.π.app j
x : x✝¹.pt
⊢ ↑(x✝ x) = ↑((fun s v => ⟨fun j => s.π.app j v, ⋯⟩) x✝¹ x)
tactic: apply Subtype.ext
state_before: case h.a
J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ TypeMax
x✝¹ : Cone F
x✝ : x✝¹.pt ⟶ (limitCone F).pt
w : ∀ (j : J), x✝ ≫ (limitCone F).π.app j = x✝¹.π.app j
x : x✝¹.pt
⊢ ↑(x✝ x) = ↑((fun s v => ⟨fun j => s.π.app j v, ⋯⟩) x✝¹ x)
state_after: case h.a.h
J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ TypeMax
x✝¹ : Cone F
x✝ : x✝¹.pt ⟶ (limitCone F).pt
w : ∀ (j : J), x✝ ≫ (limitCone F).π.app j = x✝¹.π.app j
x : x✝¹.pt
j : J
⊢ ↑(x✝ x) j = ↑((fun s v => ⟨fun j => s.π.app j v, ⋯⟩) x✝¹ x) j
tactic: funext j
state_before: case h.a.h
J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ TypeMax
x✝¹ : Cone F
x✝ : x✝¹.pt ⟶ (limitCone F).pt
w : ∀ (j : J), x✝ ≫ (limitCone F).π.app j = x✝¹.π.app j
x : x✝¹.pt
j : J
⊢ ↑(x✝ x) j = ↑((fun s v => ⟨fun j => s.π.app j v, ⋯⟩) x✝¹ x) j
state_after: no goals
tactic: exact congr_fun (w j) x
Theorem: SimpleGraph.Path.singleton_coe
File: Mathlib/Combinatorics/SimpleGraph/Path.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
h : G.Adj u v
⊢ (Walk.cons h Walk.nil).IsPath
state_after: no goals
tactic: simp [h.ne]
Theorem: EMetric.infEdist_image
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t : Set α
Φ : α → β
hΦ : Isometry Φ
⊢ infEdist (Φ x) (Φ '' t) = infEdist x t
state_after: no goals
tactic: simp only [infEdist, iInf_image, hΦ.edist_eq]
Theorem: TendstoUniformlyOn.tendstoLocallyUniformlyOn
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x✝¹ : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
h : TendstoUniformlyOn F f p s
u : Set (β × β)
hu : u ∈ 𝓤 β
x : α
x✝ : x ∈ s
⊢ ∀ᶠ (n : ι) in p, ∀ y ∈ s, (f y, F n y) ∈ u
state_after: no goals
tactic: simpa using h u hu
Theorem: PartialEquiv.trans_assoc
File: Mathlib/Logic/Equiv/PartialEquiv.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e' : PartialEquiv β γ
e'' : PartialEquiv γ δ
⊢ ((e.trans e').trans e'').source = (e.trans (e'.trans e'')).source
state_after: no goals
tactic: simp [trans_source, @preimage_comp α β γ, inter_assoc]
Theorem: map_normEDS
File: Mathlib/NumberTheory/EllipticDivisibilitySequence.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
n : ℤ
⊢ f (normEDS b c d n) = normEDS (f b) (f c) (f d) n
state_after: no goals
tactic: rw [normEDS, map_mul, map_preNormEDS, map_pow, apply_ite f, map_one, normEDS]
Theorem: div_pos
File: Mathlib/Algebra/Order/Field/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝⁴ : Semifield α
inst✝³ : LinearOrder α
inst✝² : PosMulReflectLT α
inst✝¹ : ZeroLEOneClass α
a b : α
inst✝ : PosMulStrictMono α
ha : 0 < a
hb : 0 < b
⊢ 0 < a / b
state_after: α : Type u_1
inst✝⁴ : Semifield α
inst✝³ : LinearOrder α
inst✝² : PosMulReflectLT α
inst✝¹ : ZeroLEOneClass α
a b : α
inst✝ : PosMulStrictMono α
ha : 0 < a
hb : 0 < b
⊢ 0 < a * b⁻¹
tactic: rw [div_eq_mul_inv]
state_before: α : Type u_1
inst✝⁴ : Semifield α
inst✝³ : LinearOrder α
inst✝² : PosMulReflectLT α
inst✝¹ : ZeroLEOneClass α
a b : α
inst✝ : PosMulStrictMono α
ha : 0 < a
hb : 0 < b
⊢ 0 < a * b⁻¹
state_after: no goals
tactic: exact mul_pos ha (inv_pos.2 hb)
Theorem: AddSemiconjBy.eq_zero_iff
File: Mathlib/Algebra/Group/Semiconj/Basic.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
a x y : G
h : SemiconjBy a x y
⊢ x = 1 ↔ y = 1
state_after: no goals
tactic: rw [← conj_eq_one_iff (a := a) (b := x), h.eq, mul_inv_cancel_right]
Theorem: Real.sign_of_pos
File: Mathlib/Data/Real/Sign.lean

Proof steps:
state_before: r : ℝ
hr : 0 < r
⊢ r.sign = 1
state_after: no goals
tactic: rw [sign, if_pos hr, if_neg hr.not_lt]
Theorem: List.alternatingSum_reverse
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommGroup α
⊢ [].reverse.alternatingProd = [].alternatingProd ^ (-1) ^ ([].length + 1)
state_after: no goals
tactic: simp only [alternatingProd_nil, one_zpow, reverse_nil]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommGroup α
a : α
l : List α
⊢ (a :: l).reverse.alternatingProd = (a :: l).alternatingProd ^ (-1) ^ ((a :: l).length + 1)
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommGroup α
a : α
l : List α
⊢ (l.alternatingProd ^ (-1) ^ l.length)⁻¹ * a ^ (-1) ^ l.length = (a / l.alternatingProd) ^ (-1) ^ l.length
tactic: simp_rw [reverse_cons, alternatingProd_append, alternatingProd_reverse,
      alternatingProd_singleton, alternatingProd_cons, length_reverse, length, pow_succ',
      Int.neg_mul, one_mul, zpow_neg, inv_inv]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommGroup α
a : α
l : List α
⊢ (l.alternatingProd ^ (-1) ^ l.length)⁻¹ * a ^ (-1) ^ l.length = (a / l.alternatingProd) ^ (-1) ^ l.length
state_after: no goals
tactic: rw [mul_comm, ← div_eq_mul_inv, div_zpow]
Theorem: Finset.max'_mem
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset α
H : s.Nonempty
x : α
⊢ s.max = ↑(s.max' H)
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset α
H : s.Nonempty
x : α
⊢ s.sup WithBot.some = s.sup (WithBot.some ∘ fun x => x)
tactic: simp only [max', Finset.max, id_eq, coe_sup']
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset α
H : s.Nonempty
x : α
⊢ s.sup WithBot.some = s.sup (WithBot.some ∘ fun x => x)
state_after: no goals
tactic: rfl
Theorem: Nat.max_sq_add_min_le_pair
File: Mathlib/Data/Nat/Pairing.lean

Proof steps:
state_before: m n : ℕ
⊢ max m n ^ 2 + min m n ≤ pair m n
state_after: m n : ℕ
⊢ max m n ^ 2 + min m n ≤ if m < n then n * n + m else m * m + m + n
tactic: rw [pair]
state_before: m n : ℕ
⊢ max m n ^ 2 + min m n ≤ if m < n then n * n + m else m * m + m + n
state_after: case inl
m n : ℕ
h : m < n
⊢ max m n ^ 2 + min m n ≤ if m < n then n * n + m else m * m + m + n

case inr
m n : ℕ
h : n ≤ m
⊢ max m n ^ 2 + min m n ≤ if m < n then n * n + m else m * m + m + n
tactic: cases' lt_or_le m n with h h
state_before: case inr
m n : ℕ
h : n ≤ m
⊢ max m n ^ 2 + min m n ≤ if m < n then n * n + m else m * m + m + n
state_after: case inr
m n : ℕ
h : n ≤ m
⊢ n ≤ m + n
tactic: rw [if_neg h.not_lt, max_eq_left h, min_eq_right h, Nat.pow_two, Nat.add_assoc,
    Nat.add_le_add_iff_left]
state_before: case inr
m n : ℕ
h : n ≤ m
⊢ n ≤ m + n
state_after: no goals
tactic: exact Nat.le_add_left _ _
Theorem: TrivSqZeroExt.lift_apply_inl
File: Mathlib/Algebra/TrivSqZeroExt.lean

Proof steps:
state_before: S : Type u_1
R R' : Type u
M : Type v
inst✝¹⁸ : CommSemiring S
inst✝¹⁷ : Semiring R
inst✝¹⁶ : CommSemiring R'
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : Algebra S R
inst✝¹³ : Algebra S R'
inst✝¹² : Module S M
inst✝¹¹ : Module R M
inst✝¹⁰ : Module Rᵐᵒᵖ M
inst✝⁹ : SMulCommClass R Rᵐᵒᵖ M
inst✝⁸ : IsScalarTower S R M
inst✝⁷ : IsScalarTower S Rᵐᵒᵖ M
inst✝⁶ : Module R' M
inst✝⁵ : Module R'ᵐᵒᵖ M
inst✝⁴ : IsCentralScalar R' M
inst✝³ : IsScalarTower S R' M
A : Type u_2
inst✝² : Semiring A
inst✝¹ : Algebra S A
inst✝ : Algebra R' A
f : R →ₐ[S] A
g : M →ₗ[S] A
hg : ∀ (x y : M), g x * g y = 0
hfg : ∀ (r : R) (x : M), g (r •> x) = f r * g x
hgf : ∀ (r : R) (x : M), g (x <• r) = g x * f r
r : R
⊢ f r + g 0 = f r
state_after: no goals
tactic: rw [map_zero, add_zero]
Theorem: coe_add_coe
File: Mathlib/Algebra/Group/Subgroup/Pointwise.lean

Proof steps:
state_before: α : Type u_1
G : Type u_2
A : Type u_3
S : Type u_4
inst✝² : SetLike S G
inst✝¹ : DivInvMonoid G
inst✝ : SubgroupClass S G
H : S
⊢ ↑H * ↑H = ↑H
state_after: no goals
tactic: aesop (add simp mem_mul)
Theorem: isEmpty_sum
File: Mathlib/Logic/IsEmpty.lean

Proof steps:
state_before: α✝ : Sort u_1
β✝ : Sort u_2
γ : Sort u_3
α : Type u_4
β : Type u_5
⊢ IsEmpty (α ⊕ β) ↔ IsEmpty α ∧ IsEmpty β
state_after: no goals
tactic: simp only [← not_nonempty_iff, nonempty_sum, not_or]
Theorem: Matrix.single_vecMul_diagonal
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : NonUnitalNonAssocSemiring α
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : NonUnitalNonAssocSemiring R
v : n → R
j : n
x : R
⊢ Pi.single j x ᵥ* diagonal v = Pi.single j (x * v j)
state_after: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : NonUnitalNonAssocSemiring α
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : NonUnitalNonAssocSemiring R
v : n → R
j : n
x : R
i : n
⊢ (Pi.single j x ᵥ* diagonal v) i = Pi.single j (x * v j) i
tactic: ext i
state_before: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : NonUnitalNonAssocSemiring α
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : NonUnitalNonAssocSemiring R
v : n → R
j : n
x : R
i : n
⊢ (Pi.single j x ᵥ* diagonal v) i = Pi.single j (x * v j) i
state_after: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : NonUnitalNonAssocSemiring α
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : NonUnitalNonAssocSemiring R
v : n → R
j : n
x : R
i : n
⊢ Pi.single j x i * v i = Pi.single j (x * v j) i
tactic: rw [vecMul_diagonal]
state_before: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : NonUnitalNonAssocSemiring α
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : NonUnitalNonAssocSemiring R
v : n → R
j : n
x : R
i : n
⊢ Pi.single j x i * v i = Pi.single j (x * v j) i
state_after: no goals
tactic: exact Pi.apply_single (fun i x => x * v i) (fun i => zero_mul _) j x i
Theorem: Ordinal.nfpBFamily_lt_ord
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{u} → Ordinal.{u}
c : Ordinal.{u}
hc : ℵ₀ < c.cof
hc' : o.card < c.cof
hf : ∀ (i : Ordinal.{u}) (hi : i < o), ∀ b < c, f i hi b < c
a : Ordinal.{u}
⊢ Cardinal.lift.{u, u} o.card < c.cof
state_after: no goals
tactic: rwa [o.card.lift_id]
Theorem: Subalgebra.fg_of_fg_map
File: Mathlib/RingTheory/Adjoin/FG.lean

Proof steps:
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
f : A →ₐ[R] B
hf : Function.Injective ⇑f
hs✝ : (map f S).FG
s : Finset B
hs : Algebra.adjoin R ↑s = map f S
⊢ map f (Algebra.adjoin R ↑(s.preimage ⇑f ⋯)) = map f S
state_after: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
f : A →ₐ[R] B
hf : Function.Injective ⇑f
hs✝ : (map f S).FG
s : Finset B
hs : Algebra.adjoin R ↑s = map f S
⊢ ↑s ⊆ Set.range ⇑f
tactic: rw [← Algebra.adjoin_image, Finset.coe_preimage, Set.image_preimage_eq_of_subset, hs]
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
f : A →ₐ[R] B
hf : Function.Injective ⇑f
hs✝ : (map f S).FG
s : Finset B
hs : Algebra.adjoin R ↑s = map f S
⊢ ↑s ⊆ Set.range ⇑f
state_after: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
f : A →ₐ[R] B
hf : Function.Injective ⇑f
hs✝ : (map f S).FG
s : Finset B
hs : Algebra.adjoin R ↑s = map f S
⊢ map f S ≤ map f ⊤
tactic: rw [← AlgHom.coe_range, ← Algebra.adjoin_le_iff, hs, ← Algebra.map_top]
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
f : A →ₐ[R] B
hf : Function.Injective ⇑f
hs✝ : (map f S).FG
s : Finset B
hs : Algebra.adjoin R ↑s = map f S
⊢ map f S ≤ map f ⊤
state_after: no goals
tactic: exact map_mono le_top
Theorem: Finset.mem_map_equiv
File: Mathlib/Data/Finset/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : α ↪ β
s : Finset α
f : α ≃ β
b : β
⊢ b ∈ map f.toEmbedding s ↔ f.symm b ∈ s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : α ↪ β
s : Finset α
f : α ≃ β
b : β
⊢ (∃ a ∈ s, f.toEmbedding a = b) ↔ f.symm b ∈ s
tactic: rw [mem_map]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : α ↪ β
s : Finset α
f : α ≃ β
b : β
⊢ (∃ a ∈ s, f.toEmbedding a = b) ↔ f.symm b ∈ s
state_after: no goals
tactic: exact
    ⟨by
      rintro ⟨a, H, rfl⟩
      simpa, fun h => ⟨_, h, by simp⟩⟩
Theorem: PadicInt.toZModPow_eq_iff_ext
File: Mathlib/NumberTheory/Padics/RingHoms.lean

Proof steps:
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
R : Type u_1
inst✝ : NonAssocSemiring R
g g' : R →+* ℤ_[p]
⊢ (∀ (n : ℕ), (toZModPow n).comp g = (toZModPow n).comp g') ↔ g = g'
state_after: case mp
p : ℕ
hp_prime : Fact (Nat.Prime p)
R : Type u_1
inst✝ : NonAssocSemiring R
g g' : R →+* ℤ_[p]
⊢ (∀ (n : ℕ), (toZModPow n).comp g = (toZModPow n).comp g') → g = g'

case mpr
p : ℕ
hp_prime : Fact (Nat.Prime p)
R : Type u_1
inst✝ : NonAssocSemiring R
g g' : R →+* ℤ_[p]
⊢ g = g' → ∀ (n : ℕ), (toZModPow n).comp g = (toZModPow n).comp g'
tactic: constructor