ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: IsAddGroupHom.map_sub
File: Mathlib/Deprecated/Group.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝¹ : Group α
inst✝ : Group β
f : α → β
hf✝ hf : IsGroupHom f
a b : α
⊢ f (a / b) = f a / f b
state_after: no goals
tactic: simp_rw [div_eq_mul_inv, hf.map_mul, hf.map_inv]
Theorem: coe_div_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✝¹ : DivisionMonoid G
inst✝ : SubgroupClass S G
H : S
⊢ ↑H / ↑H = ↑H
state_after: no goals
tactic: simp [div_eq_mul_inv]
Theorem: MonoidAlgebra.support_gen_of_gen'
File: Mathlib/RingTheory/FiniteType.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
inst✝ : Monoid M
S : Set (MonoidAlgebra R M)
hS : adjoin R S = ⊤
⊢ adjoin R (⇑(of R M) '' ⋃ f ∈ S, ↑f.support) = ⊤
state_after: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
inst✝ : Monoid M
S : Set (MonoidAlgebra R M)
hS : adjoin R S = ⊤
⊢ ⇑(of R M) '' ⋃ f ∈ S, ↑f.support = ⋃ f ∈ S, ⇑(of R M) '' ↑f.support
tactic: suffices (of R M '' ⋃ f ∈ S, (f.support : Set M)) = ⋃ f ∈ S, of R M '' (f.support : Set M) by
    rw [this]
    exact support_gen_of_gen hS
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
inst✝ : Monoid M
S : Set (MonoidAlgebra R M)
hS : adjoin R S = ⊤
⊢ ⇑(of R M) '' ⋃ f ∈ S, ↑f.support = ⋃ f ∈ S, ⇑(of R M) '' ↑f.support
state_after: no goals
tactic: simp only [Set.image_iUnion]
Theorem: Cubic.equiv_apply_coe
File: Mathlib/Algebra/CubicDiscriminant.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P✝ Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
P : Cubic R
⊢ (fun f => { a := (↑f).coeff 3, b := (↑f).coeff 2, c := (↑f).coeff 1, d := (↑f).coeff 0 })
      ((fun P => ⟨P.toPoly, ⋯⟩) P) =
    P
state_after: no goals
tactic: ext <;> simp only [Subtype.coe_mk, coeffs]
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
f : { p // p.degree ≤ 3 }
⊢ (fun P => ⟨P.toPoly, ⋯⟩)
      ((fun f => { a := (↑f).coeff 3, b := (↑f).coeff 2, c := (↑f).coeff 1, d := (↑f).coeff 0 }) f) =
    f
state_after: case a.a.succ.succ.succ.succ
R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
f : { p // p.degree ≤ 3 }
n : ℕ
⊢ { a := (↑f).coeff 3, b := (↑f).coeff 2, c := (↑f).coeff 1, d := (↑f).coeff 0 }.toPoly.coeff (4 + n) =
    (↑f).coeff (4 + n)
tactic: ext (_ | _ | _ | _ | n) <;> simp only [Nat.zero_eq, Nat.succ_eq_add_one] <;> ring_nf
      <;> try simp only [coeffs]
state_before: case a.a.succ.succ.succ.succ
R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
f : { p // p.degree ≤ 3 }
n : ℕ
⊢ { a := (↑f).coeff 3, b := (↑f).coeff 2, c := (↑f).coeff 1, d := (↑f).coeff 0 }.toPoly.coeff (4 + n) =
    (↑f).coeff (4 + n)
state_after: case a.a.succ.succ.succ.succ
R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
f : { p // p.degree ≤ 3 }
n : ℕ
h3 : 3 < 4 + n
⊢ { a := (↑f).coeff 3, b := (↑f).coeff 2, c := (↑f).coeff 1, d := (↑f).coeff 0 }.toPoly.coeff (4 + n) =
    (↑f).coeff (4 + n)
tactic: have h3 : 3 < 4 + n := by linarith only
state_before: case a.a.succ.succ.succ.succ
R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
f : { p // p.degree ≤ 3 }
n : ℕ
h3 : 3 < 4 + n
⊢ { a := (↑f).coeff 3, b := (↑f).coeff 2, c := (↑f).coeff 1, d := (↑f).coeff 0 }.toPoly.coeff (4 + n) =
    (↑f).coeff (4 + n)
state_after: no goals
tactic: rw [coeff_eq_zero h3,
      (degree_le_iff_coeff_zero (f : R[X]) 3).mp f.2 _ <| WithBot.coe_lt_coe.mpr (by exact h3)]
Theorem: goldConj_neg
File: Mathlib/Data/Real/GoldenRatio.lean

Proof steps:
state_before: ⊢ ψ < 0
state_after: no goals
tactic: linarith [one_sub_goldConj, one_lt_gold]
Theorem: AlgebraicGeometry.Scheme.image_basicOpen
File: Mathlib/AlgebraicGeometry/OpenImmersion.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : Scheme
f : X ⟶ Y
H : IsOpenImmersion f
U : X.Opens
r : ↑Γ(X, U)
⊢ f ''ᵁ X.basicOpen r = Y.basicOpen ((Hom.appIso f U).inv r)
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : Scheme
f : X ⟶ Y
H : IsOpenImmersion f
U : X.Opens
r : ↑Γ(X, U)
e : f ⁻¹ᵁ Y.basicOpen ((Hom.appIso f U).inv r) = X.basicOpen ((Hom.app f (f ''ᵁ U)) ((Hom.appIso f U).inv r))
⊢ f ''ᵁ X.basicOpen r = Y.basicOpen ((Hom.appIso f U).inv r)
tactic: have e := Scheme.preimage_basicOpen f ((f.appIso U).inv r)
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : Scheme
f : X ⟶ Y
H : IsOpenImmersion f
U : X.Opens
r : ↑Γ(X, U)
e : f ⁻¹ᵁ Y.basicOpen ((Hom.appIso f U).inv r) = X.basicOpen ((Hom.app f (f ''ᵁ U)) ((Hom.appIso f U).inv r))
⊢ f ''ᵁ X.basicOpen r = Y.basicOpen ((Hom.appIso f U).inv r)
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : Scheme
f : X ⟶ Y
H : IsOpenImmersion f
U : X.Opens
r : ↑Γ(X, U)
e : f ⁻¹ᵁ Y.basicOpen ((Hom.appIso f U).inv r) = X.basicOpen r
⊢ f ''ᵁ X.basicOpen r = Y.basicOpen ((Hom.appIso f U).inv r)

C : Type u
inst✝ : Category.{v, u} C
X Y : Scheme
f : X ⟶ Y
H : IsOpenImmersion f
U : X.Opens
r : ↑Γ(X, U)
e : f ⁻¹ᵁ Y.basicOpen ((Hom.appIso f U).inv r) = f ⁻¹ᵁ f ''ᵁ U ⊓ X.basicOpen r
⊢ X.basicOpen r ≤ f ⁻¹ᵁ f ''ᵁ U
tactic: rw [Scheme.Hom.appIso_inv_app_apply, Scheme.basicOpen_res, inf_eq_right.mpr _] at e
Theorem: YoungDiagram.transpose_eq_iff
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

Proof steps:
state_before: μ ν : YoungDiagram
⊢ μ.transpose = ν.transpose ↔ μ = ν
state_after: μ ν : YoungDiagram
⊢ μ = ν.transpose.transpose ↔ μ = ν
tactic: rw [transpose_eq_iff_eq_transpose]
state_before: μ ν : YoungDiagram
⊢ μ = ν.transpose.transpose ↔ μ = ν
state_after: no goals
tactic: simp
Theorem: AlgebraicTopology.DoldKan.degeneracy_comp_PInfty
File: Mathlib/AlgebraicTopology/DoldKan/Degeneracies.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
n : ℕ
Δ' : SimplexCategory
θ : [n] ⟶ Δ'
hθ : ¬Mono θ
⊢ X.map θ.op ≫ PInfty.f n = 0
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
n : ℕ
Δ' : SimplexCategory
θ : [n] ⟶ Δ'
hθ : ¬Function.Injective ⇑(SimplexCategory.Hom.toOrderHom θ)
⊢ X.map θ.op ≫ PInfty.f n = 0
tactic: rw [SimplexCategory.mono_iff_injective] at hθ
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
n : ℕ
Δ' : SimplexCategory
θ : [n] ⟶ Δ'
hθ : ¬Function.Injective ⇑(SimplexCategory.Hom.toOrderHom θ)
⊢ X.map θ.op ≫ PInfty.f n = 0
state_after: case zero
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
Δ' : SimplexCategory
θ : [0] ⟶ Δ'
hθ : ¬Function.Injective ⇑(SimplexCategory.Hom.toOrderHom θ)
⊢ X.map θ.op ≫ PInfty.f 0 = 0

case succ
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
Δ' : SimplexCategory
n✝ : ℕ
θ : [n✝ + 1] ⟶ Δ'
hθ : ¬Function.Injective ⇑(SimplexCategory.Hom.toOrderHom θ)
⊢ X.map θ.op ≫ PInfty.f (n✝ + 1) = 0
tactic: cases n
Theorem: CategoryTheory.MonoOver.congr_unitIso
File: Mathlib/CategoryTheory/Subobject/MonoOver.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
f : MonoOver X
⊢ Mono ((Over.post e.functor).obj ((forget X).obj f)).hom
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
f : MonoOver X
⊢ Mono (e.functor.map f.arrow)
tactic: dsimp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
f : MonoOver X
⊢ Mono (e.functor.map f.arrow)
state_after: no goals
tactic: infer_instance
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
f : MonoOver (e.functor.obj X)
⊢ Mono ((Over.post e.inverse).obj ((forget (e.functor.obj X)).obj f)).hom
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
f : MonoOver (e.functor.obj X)
⊢ Mono (e.inverse.map f.arrow)
tactic: dsimp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
f : MonoOver (e.functor.obj X)
⊢ Mono (e.inverse.map f.arrow)
state_after: no goals
tactic: infer_instance
Theorem: map_inv_intCast_smul
File: Mathlib/Algebra/Module/Basic.lean

Proof steps:
state_before: α : Type u_1
R✝ : Type u_2
M : Type u_3
M₂ : Type u_4
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M₂
F : Type u_5
inst✝⁵ : FunLike F M M₂
inst✝⁴ : AddMonoidHomClass F M M₂
f : F
R : Type u_6
S : Type u_7
inst✝³ : DivisionRing R
inst✝² : DivisionRing S
inst✝¹ : Module R M
inst✝ : Module S M₂
z : ℤ
x : M
⊢ f ((↑z)⁻¹ • x) = (↑z)⁻¹ • f x
state_after: case intro.inl
α : Type u_1
R✝ : Type u_2
M : Type u_3
M₂ : Type u_4
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M₂
F : Type u_5
inst✝⁵ : FunLike F M M₂
inst✝⁴ : AddMonoidHomClass F M M₂
f : F
R : Type u_6
S : Type u_7
inst✝³ : DivisionRing R
inst✝² : DivisionRing S
inst✝¹ : Module R M
inst✝ : Module S M₂
x : M
n : ℕ
⊢ f ((↑↑n)⁻¹ • x) = (↑↑n)⁻¹ • f x

case intro.inr
α : Type u_1
R✝ : Type u_2
M : Type u_3
M₂ : Type u_4
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M₂
F : Type u_5
inst✝⁵ : FunLike F M M₂
inst✝⁴ : AddMonoidHomClass F M M₂
f : F
R : Type u_6
S : Type u_7
inst✝³ : DivisionRing R
inst✝² : DivisionRing S
inst✝¹ : Module R M
inst✝ : Module S M₂
x : M
n : ℕ
⊢ f ((↑(-↑n))⁻¹ • x) = (↑(-↑n))⁻¹ • f x
tactic: obtain ⟨n, rfl | rfl⟩ := z.eq_nat_or_neg
Theorem: orthogonalProjection_map_apply
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
E : Type u_4
E' : Type u_5
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup E'
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace 𝕜 E'
f : E ≃ₗᵢ[𝕜] E'
p : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection p
x : E'
⊢ ↑((orthogonalProjection (Submodule.map (↑f.toLinearEquiv) p)) x) = f ↑((orthogonalProjection p) (f.symm x))
state_after: no goals
tactic: simpa only [f.coe_toLinearIsometry, f.apply_symm_apply] using
    (f.toLinearIsometry.map_orthogonalProjection' p (f.symm x)).symm
Theorem: RatFunc.num_one
File: Mathlib/FieldTheory/RatFunc/Basic.lean

Proof steps:
state_before: K : Type u
inst✝ : Field K
⊢ num 1 = 1
state_after: no goals
tactic: convert num_div (1 : K[X]) 1 <;> simp
Theorem: Set.ncard_eq_succ
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t : Set α
f : α → β
n : ℕ
hs : autoParam s.Finite _auto✝
⊢ s.ncard = n + 1 ↔ ∃ a t, a ∉ t ∧ insert a t = s ∧ t.ncard = n
state_after: α : Type u_1
β : Type u_2
s t : Set α
f : α → β
n : ℕ
hs : autoParam s.Finite _auto✝
⊢ (∃ a t, a ∉ t ∧ insert a t = s ∧ t.ncard = n) → s.ncard = n + 1
tactic: refine ⟨eq_insert_of_ncard_eq_succ, ?_⟩
state_before: α : Type u_1
β : Type u_2
s t : Set α
f : α → β
n : ℕ
hs : autoParam s.Finite _auto✝
⊢ (∃ a t, a ∉ t ∧ insert a t = s ∧ t.ncard = n) → s.ncard = n + 1
state_after: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
s t✝ : Set α
f : α → β
hs : autoParam s.Finite _auto✝
a : α
t : Set α
hat : a ∉ t
h : insert a t = s
⊢ s.ncard = t.ncard + 1
tactic: rintro ⟨a, t, hat, h, rfl⟩
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
s t✝ : Set α
f : α → β
hs : autoParam s.Finite _auto✝
a : α
t : Set α
hat : a ∉ t
h : insert a t = s
⊢ s.ncard = t.ncard + 1
state_after: no goals
tactic: rw [← h, ncard_insert_of_not_mem hat (hs.subset ((subset_insert a t).trans_eq h))]
Theorem: toIcoMod_zsmul_add
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
m : ℤ
⊢ toIcoMod hp a (m • p + b) = toIcoMod hp a b
state_after: no goals
tactic: rw [add_comm, toIcoMod_add_zsmul]
Theorem: Part.bind_assoc
File: Mathlib/Data/Part.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ✝ : Type u_3
γ : Type u_4
f : Part α
g : α → Part β
k : β → Part γ
a : γ
⊢ a ∈ (f.bind g).bind k ↔ a ∈ f.bind fun x => (g x).bind k
state_after: α : Type u_1
β : Type u_2
γ✝ : Type u_3
γ : Type u_4
f : Part α
g : α → Part β
k : β → Part γ
a : γ
⊢ (∃ a_1, (∃ a ∈ f, a_1 ∈ g a) ∧ a ∈ k a_1) ↔ ∃ a_1 ∈ f, ∃ a_2 ∈ g a_1, a ∈ k a_2
tactic: simp only [mem_bind_iff]
state_before: α : Type u_1
β : Type u_2
γ✝ : Type u_3
γ : Type u_4
f : Part α
g : α → Part β
k : β → Part γ
a : γ
⊢ (∃ a_1, (∃ a ∈ f, a_1 ∈ g a) ∧ a ∈ k a_1) ↔ ∃ a_1 ∈ f, ∃ a_2 ∈ g a_1, a ∈ k a_2
state_after: no goals
tactic: exact ⟨fun ⟨_, ⟨_, h₁, h₂⟩, h₃⟩ => ⟨_, h₁, _, h₂, h₃⟩,
           fun ⟨_, h₁, _, h₂, h₃⟩ => ⟨_, ⟨_, h₁, h₂⟩, h₃⟩⟩
Theorem: exists_isOpen_superset_and_isCompact_closure
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : FirstCountableTopology X
inst✝¹ : R1Space X
x y : X
inst✝ : WeaklyLocallyCompactSpace X
K : Set X
hK : IsCompact K
⊢ ∃ V, IsOpen V ∧ K ⊆ V ∧ IsCompact (closure V)
state_after: case intro.intro
X : Type u_1
Y : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : FirstCountableTopology X
inst✝¹ : R1Space X
x y : X
inst✝ : WeaklyLocallyCompactSpace X
K : Set X
hK : IsCompact K
K' : Set X
hK' : IsCompact K'
hKK' : K ⊆ interior K'
⊢ ∃ V, IsOpen V ∧ K ⊆ V ∧ IsCompact (closure V)
tactic: rcases exists_compact_superset hK with ⟨K', hK', hKK'⟩
state_before: case intro.intro
X : Type u_1
Y : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : FirstCountableTopology X
inst✝¹ : R1Space X
x y : X
inst✝ : WeaklyLocallyCompactSpace X
K : Set X
hK : IsCompact K
K' : Set X
hK' : IsCompact K'
hKK' : K ⊆ interior K'
⊢ ∃ V, IsOpen V ∧ K ⊆ V ∧ IsCompact (closure V)
state_after: no goals
tactic: exact ⟨interior K', isOpen_interior, hKK', hK'.closure_of_subset interior_subset⟩
Theorem: MeasureTheory.measure_null_iff_singleton
File: Mathlib/MeasureTheory/OuterMeasure/Basic.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
F : Type u_3
inst✝¹ : FunLike F (Set α) ℝ≥0∞
inst✝ : OuterMeasureClass F α
μ : F
s t : Set α
hs : s.Countable
⊢ μ s = 0 ↔ ∀ x ∈ s, μ {x} = 0
state_after: no goals
tactic: rw [← measure_biUnion_null_iff hs, biUnion_of_singleton]
Theorem: CategoryTheory.Limits.imageSubobject_iso_comp
File: Mathlib/CategoryTheory/Subobject/Limits.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
X Y Z : C
f✝ : X ⟶ Y
inst✝³ : HasImage f✝
inst✝² : HasEqualizers C
X' : C
h : X' ⟶ X
inst✝¹ : IsIso h
f : X ⟶ Y
inst✝ : HasImage f
⊢ inv (image.preComp h f) ≫ image.ι (h ≫ f) = image.ι f
state_after: no goals
tactic: simp
Theorem: smul_add_smul_le_smul_add_smul'
File: Mathlib/Algebra/Order/Module/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
inst✝³ : OrderedRing α
inst✝² : OrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : PosSMulMono α β
b₁ b₂ : α
a d : β
hba : b₂ ≤ b₁
hdc : d ≤ a
⊢ b₁ • d + b₂ • a ≤ b₁ • a + b₂ • d
state_after: α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
inst✝³ : OrderedRing α
inst✝² : OrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : PosSMulMono α β
b₁ b₂ : α
a d : β
hba : b₂ ≤ b₁
hdc : d ≤ a
⊢ b₂ • a + b₁ • d ≤ b₂ • d + b₁ • a
tactic: rw [add_comm (b₁ • d), add_comm (b₁ • a)]
state_before: α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
inst✝³ : OrderedRing α
inst✝² : OrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : PosSMulMono α β
b₁ b₂ : α
a d : β
hba : b₂ ≤ b₁
hdc : d ≤ a
⊢ b₂ • a + b₁ • d ≤ b₂ • d + b₁ • a
state_after: no goals
tactic: exact smul_add_smul_le_smul_add_smul hba hdc
Theorem: Nat.ord_compl_of_not_prime
File: Mathlib/Data/Nat/Factorization/Basic.lean

Proof steps:
state_before: a b m n✝ p✝ n p : ℕ
hp : ¬Prime p
⊢ n / p ^ n.factorization p = n
state_after: no goals
tactic: simp [factorization_eq_zero_of_non_prime n hp]
Theorem: CategoryTheory.MonoidalCategory.prodMonoidal_leftUnitor_hom_fst
File: Mathlib/CategoryTheory/Monoidal/Category.lean

Proof steps:
state_before: C : Type u
𝒞 : Category.{v, u} C
inst✝⁴ : MonoidalCategory C
C₁ : Type u₁
inst✝³ : Category.{v₁, u₁} C₁
inst✝² : MonoidalCategory C₁
C₂ : Type u₂
inst✝¹ : Category.{v₂, u₂} C₂
inst✝ : MonoidalCategory C₂
X : C₁ × C₂
⊢ (λ_ X).hom.1 = (λ_ X.1).hom
state_after: case mk
C : Type u
𝒞 : Category.{v, u} C
inst✝⁴ : MonoidalCategory C
C₁ : Type u₁
inst✝³ : Category.{v₁, u₁} C₁
inst✝² : MonoidalCategory C₁
C₂ : Type u₂
inst✝¹ : Category.{v₂, u₂} C₂
inst✝ : MonoidalCategory C₂
fst✝ : C₁
snd✝ : C₂
⊢ (λ_ (fst✝, snd✝)).hom.1 = (λ_ (fst✝, snd✝).1).hom
tactic: cases X
state_before: case mk
C : Type u
𝒞 : Category.{v, u} C
inst✝⁴ : MonoidalCategory C
C₁ : Type u₁
inst✝³ : Category.{v₁, u₁} C₁
inst✝² : MonoidalCategory C₁
C₂ : Type u₂
inst✝¹ : Category.{v₂, u₂} C₂
inst✝ : MonoidalCategory C₂
fst✝ : C₁
snd✝ : C₂
⊢ (λ_ (fst✝, snd✝)).hom.1 = (λ_ (fst✝, snd✝).1).hom
state_after: no goals
tactic: rfl
Theorem: Fin.natCast_eq_zero
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n✝ m a n : ℕ
inst✝ : NeZero n
⊢ ↑a = 0 ↔ n ∣ a
state_after: no goals
tactic: simp [Fin.ext_iff, Nat.dvd_iff_mod_eq_zero]
Theorem: AlgebraicGeometry.RingedSpace.basicOpen_mul
File: Mathlib/Geometry/RingedSpace/Basic.lean

Proof steps:
state_before: X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f g : ↑(X.presheaf.obj (op U))
⊢ X.basicOpen (f * g) = X.basicOpen f ⊓ X.basicOpen g
state_after: case h
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f g : ↑(X.presheaf.obj (op U))
⊢ ↑(X.basicOpen (f * g)) = ↑(X.basicOpen f ⊓ X.basicOpen g)
tactic: ext1
state_before: case h
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f g : ↑(X.presheaf.obj (op U))
⊢ ↑(X.basicOpen (f * g)) = ↑(X.basicOpen f ⊓ X.basicOpen g)
state_after: case h
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f g : ↑(X.presheaf.obj (op U))
⊢ Subtype.val '' {x | IsUnit ((X.presheaf.germ x) (f * g))} =
    Subtype.val '' {x | IsUnit ((X.presheaf.germ x) f)} ∩ Subtype.val '' {x | IsUnit ((X.presheaf.germ x) g)}
tactic: dsimp [RingedSpace.basicOpen]
state_before: case h
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f g : ↑(X.presheaf.obj (op U))
⊢ Subtype.val '' {x | IsUnit ((X.presheaf.germ x) (f * g))} =
    Subtype.val '' {x | IsUnit ((X.presheaf.germ x) f)} ∩ Subtype.val '' {x | IsUnit ((X.presheaf.germ x) g)}
state_after: case h
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f g : ↑(X.presheaf.obj (op U))
⊢ Subtype.val '' {x | IsUnit ((X.presheaf.germ x) (f * g))} =
    (fun a => ↑a) '' ({x | IsUnit ((X.presheaf.germ x) f)} ∩ {x | IsUnit ((X.presheaf.germ x) g)})
tactic: rw [← Set.image_inter Subtype.coe_injective]
state_before: case h
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f g : ↑(X.presheaf.obj (op U))
⊢ Subtype.val '' {x | IsUnit ((X.presheaf.germ x) (f * g))} =
    (fun a => ↑a) '' ({x | IsUnit ((X.presheaf.germ x) f)} ∩ {x | IsUnit ((X.presheaf.germ x) g)})
state_after: case h.h
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f g : ↑(X.presheaf.obj (op U))
x : ↑↑X.toPresheafedSpace
⊢ x ∈ Subtype.val '' {x | IsUnit ((X.presheaf.germ x) (f * g))} ↔
    x ∈ (fun a => ↑a) '' ({x | IsUnit ((X.presheaf.germ x) f)} ∩ {x | IsUnit ((X.presheaf.germ x) g)})
tactic: ext x
state_before: case h.h
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f g : ↑(X.presheaf.obj (op U))
x : ↑↑X.toPresheafedSpace
⊢ x ∈ Subtype.val '' {x | IsUnit ((X.presheaf.germ x) (f * g))} ↔
    x ∈ (fun a => ↑a) '' ({x | IsUnit ((X.presheaf.germ x) f)} ∩ {x | IsUnit ((X.presheaf.germ x) g)})
state_after: no goals
tactic: simp [map_mul, Set.mem_image]
Theorem: skewAdjointPart_eq_I_smul_imaginaryPart
File: Mathlib/Data/Complex/Module.lean

Proof steps:
state_before: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
x : A
⊢ ↑((skewAdjointPart ℝ) x) = I • ↑(ℑ x)
state_after: no goals
tactic: simp [imaginaryPart_apply_coe, smul_smul]
Theorem: CategoryTheory.Subobject.ofLEMk_comp_ofMkLEMk
File: Mathlib/CategoryTheory/Subobject/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X✝ Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
B A₁ A₂ : C
X : Subobject B
f : A₁ ⟶ B
inst✝¹ : Mono f
g : A₂ ⟶ B
inst✝ : Mono g
h₁ : X ≤ mk f
h₂ : mk f ≤ mk g
⊢ X.ofLEMk f h₁ ≫ ofMkLEMk f g h₂ = X.ofLEMk g ⋯
state_after: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X✝ Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
B A₁ A₂ : C
X : Subobject B
f : A₁ ⟶ B
inst✝¹ : Mono f
g : A₂ ⟶ B
inst✝ : Mono g
h₁ : X ≤ mk f
h₂ : mk f ≤ mk g
⊢ underlying.map (h₁.hom ≫ h₂.hom) ≫ (underlyingIso g).hom = underlying.map ⋯.hom ≫ (underlyingIso g).hom
tactic: simp only [ofMkLE, ofLEMk, ofLE, ofMkLEMk, ← Functor.map_comp_assoc underlying,
    assoc, Iso.hom_inv_id_assoc]
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X✝ Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
B A₁ A₂ : C
X : Subobject B
f : A₁ ⟶ B
inst✝¹ : Mono f
g : A₂ ⟶ B
inst✝ : Mono g
h₁ : X ≤ mk f
h₂ : mk f ≤ mk g
⊢ underlying.map (h₁.hom ≫ h₂.hom) ≫ (underlyingIso g).hom = underlying.map ⋯.hom ≫ (underlyingIso g).hom
state_after: no goals
tactic: congr 1
Theorem: Even.neg_zpow
File: Mathlib/Algebra/Ring/Parity.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : DivisionMonoid α
inst✝ : HasDistribNeg α
a : α
n : ℤ
⊢ Even n → ∀ (a : α), (-a) ^ n = a ^ n
state_after: case intro
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : DivisionMonoid α
inst✝ : HasDistribNeg α
a✝ : α
c : ℤ
a : α
⊢ (-a) ^ (c + c) = a ^ (c + c)
tactic: rintro ⟨c, rfl⟩ a
state_before: case intro
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : DivisionMonoid α
inst✝ : HasDistribNeg α
a✝ : α
c : ℤ
a : α
⊢ (-a) ^ (c + c) = a ^ (c + c)
state_after: no goals
tactic: simp_rw [← Int.two_mul, zpow_mul, zpow_two, neg_mul_neg]
Theorem: AddAction.stabilizer_singleton
File: Mathlib/Algebra/Pointwise/Stabilizer.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a : G
b : α
⊢ stabilizer G {b} = stabilizer G b
state_after: case h
G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a : G
b : α
x✝ : G
⊢ x✝ ∈ stabilizer G {b} ↔ x✝ ∈ stabilizer G b
tactic: ext
state_before: case h
G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a : G
b : α
x✝ : G
⊢ x✝ ∈ stabilizer G {b} ↔ x✝ ∈ stabilizer G b
state_after: no goals
tactic: simp
Theorem: Mathlib.Meta.Positivity.nonneg_of_isRat
File: Mathlib/Tactic/Positivity/Core.lean

Proof steps:
state_before: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℤ
d : ℕ
inst✝ : LinearOrderedRing A
inv : Invertible ↑d
eq : e = ↑n * ⅟↑d
h : decide (n = 0) = true
⊢ 0 ≤ e
state_after: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℤ
d : ℕ
inst✝ : LinearOrderedRing A
inv : Invertible ↑d
eq : e = ↑n * ⅟↑d
h : decide (n = 0) = true
⊢ 0 ≤ ↑0 * ⅟↑d
tactic: rw [eq, of_decide_eq_true h]
state_before: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℤ
d : ℕ
inst✝ : LinearOrderedRing A
inv : Invertible ↑d
eq : e = ↑n * ⅟↑d
h : decide (n = 0) = true
⊢ 0 ≤ ↑0 * ⅟↑d
state_after: no goals
tactic: simp