ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Polynomial.one_lt_rootMultiplicity_iff_isRoot
File: Mathlib/Algebra/Polynomial/FieldDivision.lean

Proof steps:
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p : R[X]
t : R
h : p ≠ 0
⊢ 1 < rootMultiplicity t p ↔ p.IsRoot t ∧ (derivative p).IsRoot t
state_after: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p : R[X]
t : R
h : p ≠ 0
⊢ (∀ m ≤ 1, ((⇑derivative)^[m] p).IsRoot t) ↔ p.IsRoot t ∧ (derivative p).IsRoot t
tactic: rw [one_lt_rootMultiplicity_iff_isRoot_iterate_derivative h]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p : R[X]
t : R
h : p ≠ 0
⊢ (∀ m ≤ 1, ((⇑derivative)^[m] p).IsRoot t) ↔ p.IsRoot t ∧ (derivative p).IsRoot t
state_after: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p : R[X]
t : R
h : p ≠ 0
x✝ : p.IsRoot t ∧ (derivative p).IsRoot t
m : ℕ
hm : m ≤ 1
h0 : p.IsRoot t
h1 : (derivative p).IsRoot t
⊢ ((⇑derivative)^[m] p).IsRoot t
tactic: refine ⟨fun h ↦ ⟨h 0 (by norm_num), h 1 (by norm_num)⟩, fun ⟨h0, h1⟩ m hm ↦ ?_⟩
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p : R[X]
t : R
h : p ≠ 0
x✝ : p.IsRoot t ∧ (derivative p).IsRoot t
m : ℕ
hm : m ≤ 1
h0 : p.IsRoot t
h1 : (derivative p).IsRoot t
⊢ ((⇑derivative)^[m] p).IsRoot t
state_after: case zero
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p : R[X]
t : R
h : p ≠ 0
x✝ : p.IsRoot t ∧ (derivative p).IsRoot t
h0 : p.IsRoot t
h1 : (derivative p).IsRoot t
hm : 0 ≤ 1
⊢ ((⇑derivative)^[0] p).IsRoot t

case succ.zero
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p : R[X]
t : R
h : p ≠ 0
x✝ : p.IsRoot t ∧ (derivative p).IsRoot t
h0 : p.IsRoot t
h1 : (derivative p).IsRoot t
hm : 0 + 1 ≤ 1
⊢ ((⇑derivative)^[0 + 1] p).IsRoot t

case succ.succ
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p : R[X]
t : R
h : p ≠ 0
x✝ : p.IsRoot t ∧ (derivative p).IsRoot t
h0 : p.IsRoot t
h1 : (derivative p).IsRoot t
m : ℕ
hm : m + 1 + 1 ≤ 1
⊢ ((⇑derivative)^[m + 1 + 1] p).IsRoot t
tactic: obtain (_|_|m) := m
state_before: case zero
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p : R[X]
t : R
h : p ≠ 0
x✝ : p.IsRoot t ∧ (derivative p).IsRoot t
h0 : p.IsRoot t
h1 : (derivative p).IsRoot t
hm : 0 ≤ 1
⊢ ((⇑derivative)^[0] p).IsRoot t

case succ.zero
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p : R[X]
t : R
h : p ≠ 0
x✝ : p.IsRoot t ∧ (derivative p).IsRoot t
h0 : p.IsRoot t
h1 : (derivative p).IsRoot t
hm : 0 + 1 ≤ 1
⊢ ((⇑derivative)^[0 + 1] p).IsRoot t

case succ.succ
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p : R[X]
t : R
h : p ≠ 0
x✝ : p.IsRoot t ∧ (derivative p).IsRoot t
h0 : p.IsRoot t
h1 : (derivative p).IsRoot t
m : ℕ
hm : m + 1 + 1 ≤ 1
⊢ ((⇑derivative)^[m + 1 + 1] p).IsRoot t
state_after: no goals
tactic: exacts [h0, h1, by omega]
Theorem: MvPolynomial.psum_one
File: Mathlib/RingTheory/MvPolynomial/Symmetric.lean

Proof steps:
state_before: σ : Type u_1
R : Type u_2
τ : Type u_3
S : Type u_4
inst✝² : CommSemiring R
inst✝¹ : Fintype σ
inst✝ : Fintype τ
⊢ psum σ R 1 = ∑ i : σ, X i
state_after: no goals
tactic: simp only [psum, _root_.pow_one]
Theorem: OrderedAddCommGroup.to_contravariantClass_right_le
File: Mathlib/Algebra/Order/Group/Defs.lean

Proof steps:
state_before: α✝ α : Type u
inst✝ : OrderedCommGroup α
a b c : α
bc : swap (fun x x_1 => x * x_1) a b ≤ swap (fun x x_1 => x * x_1) a c
⊢ b ≤ c
state_after: no goals
tactic: simpa using mul_le_mul_right' bc a⁻¹
Theorem: Filter.map_inf'
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f g : Filter α
m : α → β
t : Set α
htf : t ∈ f
htg : t ∈ g
h : InjOn m t
⊢ map m (f ⊓ g) = map m f ⊓ map m g
state_after: case intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l g : Filter α
m : α → β
t : Set α
htg : t ∈ g
h : InjOn m t
f : Filter ↑t
⊢ map m (map Subtype.val f ⊓ g) = map m (map Subtype.val f) ⊓ map m g
tactic: lift f to Filter t using htf
state_before: case intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l g : Filter α
m : α → β
t : Set α
htg : t ∈ g
h : InjOn m t
f : Filter ↑t
⊢ map m (map Subtype.val f ⊓ g) = map m (map Subtype.val f) ⊓ map m g
state_after: case intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
m : α → β
t : Set α
h : InjOn m t
f g : Filter ↑t
⊢ map m (map Subtype.val f ⊓ map Subtype.val g) = map m (map Subtype.val f) ⊓ map m (map Subtype.val g)
tactic: lift g to Filter t using htg
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
m : α → β
t : Set α
h : InjOn m t
f g : Filter ↑t
⊢ map m (map Subtype.val f ⊓ map Subtype.val g) = map m (map Subtype.val f) ⊓ map m (map Subtype.val g)
state_after: case intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
m : α → β
t : Set α
f g : Filter ↑t
h : Injective (m ∘ Subtype.val)
⊢ map m (map Subtype.val f ⊓ map Subtype.val g) = map m (map Subtype.val f) ⊓ map m (map Subtype.val g)
tactic: replace h : Injective (m ∘ ((↑) : t → α)) := h.injective
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
m : α → β
t : Set α
f g : Filter ↑t
h : Injective (m ∘ Subtype.val)
⊢ map m (map Subtype.val f ⊓ map Subtype.val g) = map m (map Subtype.val f) ⊓ map m (map Subtype.val g)
state_after: no goals
tactic: simp only [map_map, ← map_inf Subtype.coe_injective, map_inf h]
Theorem: Complex.tanh_neg
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℂ
⊢ tanh (-x) = -tanh x
state_after: no goals
tactic: simp [tanh, neg_div]
Theorem: Matrix.toMvPolynomial_map
File: Mathlib/Algebra/Module/LinearMap/Polynomial.lean

Proof steps:
state_before: m : Type u_1
n : Type u_2
o : Type u_3
R : Type u_4
S : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* S
M : Matrix m n R
i : m
⊢ (M.map ⇑f).toMvPolynomial i = (MvPolynomial.map f) (M.toMvPolynomial i)
state_after: no goals
tactic: simp only [toMvPolynomial, map_apply, map_sum, map_monomial]
Theorem: CategoryTheory.CostructuredArrow.map_comp
File: Mathlib/CategoryTheory/Comma/StructuredArrow.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' Y'' : C
S S' : C ⥤ D
f : T ⟶ T'
f' : T' ⟶ T''
h : CostructuredArrow S T
⊢ (map (f ≫ f')).obj h = (map f').obj ((map f).obj h)
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' Y'' : C
S S' : C ⥤ D
f : T ⟶ T'
f' : T' ⟶ T''
h : CostructuredArrow S T
⊢ (map (f ≫ f')).obj (mk h.hom) = (map f').obj ((map f).obj (mk h.hom))
tactic: rw [eq_mk h]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' Y'' : C
S S' : C ⥤ D
f : T ⟶ T'
f' : T' ⟶ T''
h : CostructuredArrow S T
⊢ (map (f ≫ f')).obj (mk h.hom) = (map f').obj ((map f).obj (mk h.hom))
state_after: no goals
tactic: simp
Theorem: Finset.inter_erase
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t✝ u v : Finset α
a✝ b a : α
s t : Finset α
⊢ s ∩ t.erase a = (s ∩ t).erase a
state_after: no goals
tactic: simp only [erase_eq, inter_sdiff_assoc]
Theorem: mul_right_surjective₀
File: Mathlib/Algebra/GroupWithZero/Basic.lean

Proof steps:
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : GroupWithZero G₀
a✝ b c a : G₀
h : a ≠ 0
g : G₀
⊢ (fun g => g * a) (g * a⁻¹) = g
state_after: no goals
tactic: simp [mul_assoc, inv_mul_cancel h]
Theorem: IsPGroup.isNilpotent
File: Mathlib/GroupTheory/Nilpotent.lean

Proof steps:
state_before: G : Type u_1
hG : Group G
inst✝ : Finite G
p : ℕ
hp : Fact (Nat.Prime p)
h : IsPGroup p G
⊢ Group.IsNilpotent G
state_after: case intro
G : Type u_1
hG : Group G
inst✝ : Finite G
p : ℕ
hp : Fact (Nat.Prime p)
h : IsPGroup p G
val✝ : Fintype G
⊢ Group.IsNilpotent G
tactic: cases' nonempty_fintype G
Theorem: TopCat.GlueData.ofOpenSubsets_toGlueData_V
File: Mathlib/Topology/Gluing.lean

Proof steps:
state_before: D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i j : J
⊢ Continuous fun x => ⟨⟨↑↑x, ⋯⟩, ⋯⟩
state_after: D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i j : J
⊢ Continuous fun x => ⟨↑↑x, ⋯⟩
tactic: refine Continuous.subtype_mk ?_ ?_
state_before: D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i j : J
⊢ Continuous fun x => ⟨↑↑x, ⋯⟩
state_after: D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i j : J
⊢ Continuous fun x => ↑↑x
tactic: refine Continuous.subtype_mk ?_ ?_
state_before: D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i j : J
⊢ Continuous fun x => ↑↑x
state_after: no goals
tactic: continuity
state_before: D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i : J
⊢ (fun i j => (Opens.map (U i).inclusion).obj (U j)) i i = ⊤
state_after: case h.h
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i : J
x✝ : ↑((Opens.toTopCat (of α)).obj (U i))
⊢ x✝ ∈ ↑((fun i j => (Opens.map (U i).inclusion).obj (U j)) i i) ↔ x✝ ∈ ↑⊤
tactic: ext
state_before: case h.h
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i : J
x✝ : ↑((Opens.toTopCat (of α)).obj (U i))
⊢ x✝ ∈ ↑((fun i j => (Opens.map (U i).inclusion).obj (U j)) i i) ↔ x✝ ∈ ↑⊤
state_after: no goals
tactic: simp
state_before: D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i : J
⊢ ⇑((fun i j => { toFun := fun x => ⟨⟨↑↑x, ⋯⟩, ⋯⟩, continuous_toFun := ⋯ }) i i) = id
state_after: case h
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i : J
x✝ :
  ↑((Opens.toTopCat ((fun i => (Opens.toTopCat (of α)).obj (U i)) i)).obj
      ((fun i j => (Opens.map (U i).inclusion).obj (U j)) i i))
⊢ ((fun i j => { toFun := fun x => ⟨⟨↑↑x, ⋯⟩, ⋯⟩, continuous_toFun := ⋯ }) i i) x✝ = id x✝
tactic: ext
state_before: case h
D : GlueData
α : Type u
inst✝ : TopologicalSpace α
J : Type u
U : J → Opens α
i : J
x✝ :
  ↑((Opens.toTopCat ((fun i => (Opens.toTopCat (of α)).obj (U i)) i)).obj
      ((fun i j => (Opens.map (U i).inclusion).obj (U j)) i i))
⊢ ((fun i j => { toFun := fun x => ⟨⟨↑↑x, ⋯⟩, ⋯⟩, continuous_toFun := ⋯ }) i i) x✝ = id x✝
state_after: no goals
tactic: rfl
Theorem: SimplexCategory.len_le_of_epi
File: Mathlib/AlgebraicTopology/SimplexCategory.lean

Proof steps:
state_before: x y : SimplexCategory
f : x ⟶ y
⊢ Epi f → y.len ≤ x.len
state_after: x y : SimplexCategory
f : x ⟶ y
hyp_f_epi : Epi f
⊢ y.len ≤ x.len
tactic: intro hyp_f_epi
state_before: x y : SimplexCategory
f : x ⟶ y
hyp_f_epi : Epi f
⊢ y.len ≤ x.len
state_after: x y : SimplexCategory
f : x ⟶ y
hyp_f_epi : Epi f
f_surj : Function.Surjective (Hom.toOrderHom f).toFun
⊢ y.len ≤ x.len
tactic: have f_surj : Function.Surjective f.toOrderHom.toFun := epi_iff_surjective.1 hyp_f_epi
state_before: x y : SimplexCategory
f : x ⟶ y
hyp_f_epi : Epi f
f_surj : Function.Surjective (Hom.toOrderHom f).toFun
⊢ y.len ≤ x.len
state_after: no goals
tactic: simpa using Fintype.card_le_of_surjective f.toOrderHom.toFun f_surj
Theorem: TensorAlgebra.GradedAlgebra.ι_apply
File: Mathlib/LinearAlgebra/TensorAlgebra/Grading.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
m : M
⊢ (TensorAlgebra.ι R) m ∈ LinearMap.range (TensorAlgebra.ι R) ^ 1
state_after: no goals
tactic: simpa only [pow_one] using LinearMap.mem_range_self _ m
Theorem: EuclideanGeometry.tan_oangle_right_mul_dist_of_oangle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.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
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(π / 2)
⊢ (∡ p₂ p₃ p₁).tan * dist p₃ p₂ = dist p₁ p₂
state_after: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(π / 2)
hs : (∡ p₂ p₃ p₁).sign = 1
⊢ (∡ p₂ p₃ p₁).tan * dist p₃ p₂ = dist p₁ p₂
tactic: have hs : (∡ p₂ p₃ p₁).sign = 1 := by rw [oangle_rotate_sign, h, Real.Angle.sign_coe_pi_div_two]
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(π / 2)
hs : (∡ p₂ p₃ p₁).sign = 1
⊢ (∡ p₂ p₃ p₁).tan * dist p₃ p₂ = dist p₁ p₂
state_after: no goals
tactic: rw [oangle_eq_angle_of_sign_eq_one hs, Real.Angle.tan_coe,
    tan_angle_mul_dist_of_angle_eq_pi_div_two (angle_eq_pi_div_two_of_oangle_eq_pi_div_two h)
      (Or.inr (right_ne_of_oangle_eq_pi_div_two h))]
Theorem: HomologicalComplex.natIsoSc'_inv_app_τ₂
File: Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.3350, u_1} C
inst✝ : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
i j k : ι
hi : c.prev j = i
hk : c.next j = k
K : HomologicalComplex C c
⊢ (K.XIsoOfEq hi).hom ≫ ((shortComplexFunctor' C c i j k).obj K).f =
    ((shortComplexFunctor C c j).obj K).f ≫ (Iso.refl ((shortComplexFunctor C c j).obj K).X₂).hom
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
inst✝¹ : Category.{?u.3350, u_1} C
inst✝ : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
i j k : ι
hi : c.prev j = i
hk : c.next j = k
K : HomologicalComplex C c
⊢ (Iso.refl ((shortComplexFunctor C c j).obj K).X₂).hom ≫ ((shortComplexFunctor' C c i j k).obj K).g =
    ((shortComplexFunctor C c j).obj K).g ≫ (K.XIsoOfEq hk).hom
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
inst✝¹ : Category.{?u.3350, u_1} C
inst✝ : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
i j k : ι
hi : c.prev j = i
hk : c.next j = k
⊢ ∀ {X Y : HomologicalComplex C c} (f : X ⟶ Y),
    (shortComplexFunctor C c j).map f ≫
        ((fun K =>
              ShortComplex.isoMk (K.XIsoOfEq hi) (Iso.refl ((shortComplexFunctor C c j).obj K).X₂) (K.XIsoOfEq hk) ⋯ ⋯)
            Y).hom =
      ((fun K =>
              ShortComplex.isoMk (K.XIsoOfEq hi) (Iso.refl ((shortComplexFunctor C c j).obj K).X₂) (K.XIsoOfEq hk) ⋯ ⋯)
            X).hom ≫
        (shortComplexFunctor' C c i j k).map f
state_after: no goals
tactic: aesop_cat
Theorem: Submonoid.fg_iff
File: Mathlib/GroupTheory/Finiteness.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
inst✝¹ : Monoid M
inst✝ : AddMonoid N
P : Submonoid M
x✝ : ∃ S, closure S = P ∧ S.Finite
S : Set M
hS : closure S = P
hf : S.Finite
⊢ closure ↑hf.toFinset = P
state_after: no goals
tactic: simp [hS]
Theorem: Equiv.Perm.IsSwap.of_subtype_isSwap
File: Mathlib/GroupTheory/Perm/Support.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
p : α → Prop
inst✝ : DecidablePred p
f : Perm (Subtype p)
h : f.IsSwap
x : α
hx : p x
y : α
hy : p y
hxy : ⟨x, hx⟩ ≠ ⟨y, hy⟩ ∧ f = swap ⟨x, hx⟩ ⟨y, hy⟩
⊢ x ≠ y
state_after: α : Type u_1
inst✝¹ : DecidableEq α
p : α → Prop
inst✝ : DecidablePred p
f : Perm (Subtype p)
h : f.IsSwap
x : α
hx : p x
y : α
hy : p y
hxy : ¬x = y ∧ f = swap ⟨x, hx⟩ ⟨y, hy⟩
⊢ x ≠ y
tactic: simp only [Ne, Subtype.ext_iff] at hxy
state_before: α : Type u_1
inst✝¹ : DecidableEq α
p : α → Prop
inst✝ : DecidablePred p
f : Perm (Subtype p)
h : f.IsSwap
x : α
hx : p x
y : α
hy : p y
hxy : ¬x = y ∧ f = swap ⟨x, hx⟩ ⟨y, hy⟩
⊢ x ≠ y
state_after: no goals
tactic: exact hxy.1
state_before: α : Type u_1
inst✝¹ : DecidableEq α
p : α → Prop
inst✝ : DecidablePred p
f : Perm (Subtype p)
h : f.IsSwap
x : α
hx : p x
y : α
hy : p y
hxy : ⟨x, hx⟩ ≠ ⟨y, hy⟩ ∧ f = swap ⟨x, hx⟩ ⟨y, hy⟩
⊢ ofSubtype f = swap x y
state_after: no goals
tactic: rw [hxy.2, ofSubtype_swap_eq]
Theorem: SimpleGraph.Subgraph.map_monotone
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
G' : SimpleGraph W
f : G →g G'
⊢ Monotone (Subgraph.map f)
state_after: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
G' : SimpleGraph W
f : G →g G'
H H' : G.Subgraph
h : H ≤ H'
⊢ Subgraph.map f H ≤ Subgraph.map f H'
tactic: intro H H' h
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
G' : SimpleGraph W
f : G →g G'
H H' : G.Subgraph
h : H ≤ H'
⊢ Subgraph.map f H ≤ Subgraph.map f H'
state_after: case left
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
G' : SimpleGraph W
f : G →g G'
H H' : G.Subgraph
h : H ≤ H'
⊢ (Subgraph.map f H).verts ⊆ (Subgraph.map f H').verts

case right
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
G' : SimpleGraph W
f : G →g G'
H H' : G.Subgraph
h : H ≤ H'
⊢ ∀ ⦃v w : W⦄, (Subgraph.map f H).Adj v w → (Subgraph.map f H').Adj v w
tactic: constructor
Theorem: compact_open_separated_add_left
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : MulOneClass G
inst✝ : ContinuousMul G
K U : Set G
hK : IsCompact K
hU : IsOpen U
hKU : K ⊆ U
⊢ ∃ V ∈ 𝓝 1, V * K ⊆ U
state_after: case intro.intro
G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : MulOneClass G
inst✝ : ContinuousMul G
K U : Set G
hK : IsCompact K
hU : IsOpen U
hKU : K ⊆ U
V : Set Gᵐᵒᵖ
hV : V ∈ 𝓝 (op 1)
hV' : op '' K * V ⊆ op '' U
⊢ ∃ V ∈ 𝓝 1, V * K ⊆ U
tactic: rcases compact_open_separated_mul_right (hK.image continuous_op) (opHomeomorph.isOpenMap U hU)
      (image_subset op hKU) with
    ⟨V, hV : V ∈ 𝓝 (op (1 : G)), hV' : op '' K * V ⊆ op '' U⟩
state_before: case intro.intro
G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : MulOneClass G
inst✝ : ContinuousMul G
K U : Set G
hK : IsCompact K
hU : IsOpen U
hKU : K ⊆ U
V : Set Gᵐᵒᵖ
hV : V ∈ 𝓝 (op 1)
hV' : op '' K * V ⊆ op '' U
⊢ ∃ V ∈ 𝓝 1, V * K ⊆ U
state_after: case intro.intro
G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : MulOneClass G
inst✝ : ContinuousMul G
K U : Set G
hK : IsCompact K
hU : IsOpen U
hKU : K ⊆ U
V : Set Gᵐᵒᵖ
hV : V ∈ 𝓝 (op 1)
hV' : op '' K * V ⊆ op '' U
⊢ op ⁻¹' V * K ⊆ U
tactic: refine ⟨op ⁻¹' V, continuous_op.continuousAt hV, ?_⟩
state_before: case intro.intro
G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : MulOneClass G
inst✝ : ContinuousMul G
K U : Set G
hK : IsCompact K
hU : IsOpen U
hKU : K ⊆ U
V : Set Gᵐᵒᵖ
hV : V ∈ 𝓝 (op 1)
hV' : op '' K * V ⊆ op '' U
⊢ op ⁻¹' V * K ⊆ U
state_after: no goals
tactic: rwa [← image_preimage_eq V op_surjective, ← image_op_mul, image_subset_iff,
    preimage_image_eq _ op_injective] at hV'
Theorem: HasDerivWithinAt.log
File: Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean

Proof steps:
state_before: f : ℝ → ℝ
x f' : ℝ
s : Set ℝ
hf : HasDerivWithinAt f f' s x
hx : f x ≠ 0
⊢ HasDerivWithinAt (fun y => Real.log (f y)) (f' / f x) s x
state_after: f : ℝ → ℝ
x f' : ℝ
s : Set ℝ
hf : HasDerivWithinAt f f' s x
hx : f x ≠ 0
⊢ HasDerivWithinAt (fun y => Real.log (f y)) ((f x)⁻¹ * f') s x
tactic: rw [div_eq_inv_mul]
state_before: f : ℝ → ℝ
x f' : ℝ
s : Set ℝ
hf : HasDerivWithinAt f f' s x
hx : f x ≠ 0
⊢ HasDerivWithinAt (fun y => Real.log (f y)) ((f x)⁻¹ * f') s x
state_after: no goals
tactic: exact (hasDerivAt_log hx).comp_hasDerivWithinAt x hf
Theorem: FreeLieAlgebra.universalEnvelopingEquivFreeAlgebra_symm_apply
File: Mathlib/Algebra/Lie/Free.lean

Proof steps:
state_before: R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
⊢ ((UniversalEnvelopingAlgebra.lift R) ((lift R) (FreeAlgebra.ι R))).comp
      ((FreeAlgebra.lift R) (⇑(UniversalEnvelopingAlgebra.ι R) ∘ of R)) =
    AlgHom.id R (FreeAlgebra R X)
state_after: case w.h
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
x✝ : X
⊢ (⇑(((UniversalEnvelopingAlgebra.lift R) ((lift R) (FreeAlgebra.ι R))).comp
            ((FreeAlgebra.lift R) (⇑(UniversalEnvelopingAlgebra.ι R) ∘ of R))) ∘
        FreeAlgebra.ι R)
      x✝ =
    (⇑(AlgHom.id R (FreeAlgebra R X)) ∘ FreeAlgebra.ι R) x✝
tactic: ext
state_before: case w.h
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
x✝ : X
⊢ (⇑(((UniversalEnvelopingAlgebra.lift R) ((lift R) (FreeAlgebra.ι R))).comp
            ((FreeAlgebra.lift R) (⇑(UniversalEnvelopingAlgebra.ι R) ∘ of R))) ∘
        FreeAlgebra.ι R)
      x✝ =
    (⇑(AlgHom.id R (FreeAlgebra R X)) ∘ FreeAlgebra.ι R) x✝
state_after: no goals
tactic: simp
state_before: R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
⊢ ((FreeAlgebra.lift R) (⇑(UniversalEnvelopingAlgebra.ι R) ∘ of R)).comp
      ((UniversalEnvelopingAlgebra.lift R) ((lift R) (FreeAlgebra.ι R))) =
    AlgHom.id R (UniversalEnvelopingAlgebra R (FreeLieAlgebra R X))
state_after: case h.h
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
x✝ : X
⊢ ((((FreeAlgebra.lift R) (⇑(UniversalEnvelopingAlgebra.ι R) ∘ of R)).comp
              ((UniversalEnvelopingAlgebra.lift R) ((lift R) (FreeAlgebra.ι R)))).toLieHom.comp
        (UniversalEnvelopingAlgebra.ι R))
      (of R x✝) =
    ((AlgHom.id R (UniversalEnvelopingAlgebra R (FreeLieAlgebra R X))).toLieHom.comp (UniversalEnvelopingAlgebra.ι R))
      (of R x✝)
tactic: ext
state_before: case h.h
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
x✝ : X
⊢ ((((FreeAlgebra.lift R) (⇑(UniversalEnvelopingAlgebra.ι R) ∘ of R)).comp
              ((UniversalEnvelopingAlgebra.lift R) ((lift R) (FreeAlgebra.ι R)))).toLieHom.comp
        (UniversalEnvelopingAlgebra.ι R))
      (of R x✝) =
    ((AlgHom.id R (UniversalEnvelopingAlgebra R (FreeLieAlgebra R X))).toLieHom.comp (UniversalEnvelopingAlgebra.ι R))
      (of R x✝)
state_after: no goals
tactic: simp
Theorem: Real.arccos_le_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

Proof steps:
state_before: x✝ y x : ℝ
⊢ arccos x ≤ π / 2 ↔ 0 ≤ x
state_after: no goals
tactic: simp [arccos]
Theorem: Subalgebra.map_comap_eq_self_of_surjective
File: Mathlib/Algebra/Algebra/Subalgebra/Basic.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
f : A →ₐ[R] B
hf : Function.Surjective ⇑f
S : Subalgebra R B
⊢ S ≤ f.range
state_after: no goals
tactic: simp [(Algebra.range_top_iff_surjective f).2 hf]