ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Orientation.cos_oangle_add_right_mul_norm_of_oangle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean

Proof steps:
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
⊢ (o.oangle x (x + y)).cos * ‖x + y‖ = ‖x‖
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
hs : (o.oangle x (x + y)).sign = 1
⊢ (o.oangle x (x + y)).cos * ‖x + y‖ = ‖x‖
tactic: have hs : (o.oangle x (x + y)).sign = 1 := by
    rw [oangle_sign_add_right, h, Real.Angle.sign_coe_pi_div_two]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
hs : (o.oangle x (x + y)).sign = 1
⊢ (o.oangle x (x + y)).cos * ‖x + y‖ = ‖x‖
state_after: no goals
tactic: rw [o.oangle_eq_angle_of_sign_eq_one hs, Real.Angle.cos_coe,
    InnerProductGeometry.cos_angle_add_mul_norm_of_inner_eq_zero
      (o.inner_eq_zero_of_oangle_eq_pi_div_two h)]
Theorem: Set.Finite.iSup_biInf_of_monotone
File: Mathlib/Data/Set/Finite.lean

Proof steps:
state_before: α✝ : Type u
β : Type v
ι✝ : Sort w
γ : Type x
s✝ t : Set α✝
ι : Type u_1
ι' : Type u_2
α : Type u_3
inst✝³ : Preorder ι'
inst✝² : Nonempty ι'
inst✝¹ : IsDirected ι' fun x x_1 => x ≤ x_1
inst✝ : Order.Frame α
s : Set ι
hs : s.Finite
f : ι → ι' → α
hf : ∀ i ∈ s, Monotone (f i)
⊢ ⨆ j, ⨅ i ∈ s, f i j = ⨅ i ∈ s, ⨆ j, f i j
state_after: case H0
α✝ : Type u
β : Type v
ι✝ : Sort w
γ : Type x
s✝ t : Set α✝
ι : Type u_1
ι' : Type u_2
α : Type u_3
inst✝³ : Preorder ι'
inst✝² : Nonempty ι'
inst✝¹ : IsDirected ι' fun x x_1 => x ≤ x_1
inst✝ : Order.Frame α
s : Set ι
f : ι → ι' → α
hf : ∀ i ∈ ∅, Monotone (f i)
⊢ ⨆ j, ⨅ i ∈ ∅, f i j = ⨅ i ∈ ∅, ⨆ j, f i j

case H1
α✝ : Type u
β : Type v
ι✝ : Sort w
γ : Type x
s✝¹ t : Set α✝
ι : Type u_1
ι' : Type u_2
α : Type u_3
inst✝³ : Preorder ι'
inst✝² : Nonempty ι'
inst✝¹ : IsDirected ι' fun x x_1 => x ≤ x_1
inst✝ : Order.Frame α
s✝ : Set ι
f : ι → ι' → α
a : ι
s : Set ι
a✝ : a ∉ s
h✝ : s.Finite
ihs : (∀ i ∈ s, Monotone (f i)) → ⨆ j, ⨅ i ∈ s, f i j = ⨅ i ∈ s, ⨆ j, f i j
hf : ∀ i ∈ insert a s, Monotone (f i)
⊢ ⨆ j, ⨅ i ∈ insert a s, f i j = ⨅ i ∈ insert a s, ⨆ j, f i j
tactic: induction' s, hs using Set.Finite.dinduction_on with a s _ _ ihs hf
Theorem: Finset.norm_prod_le'
File: Mathlib/Analysis/Normed/Field/Basic.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝¹ : SeminormedRing α✝
α : Type u_5
inst✝ : NormedCommRing α
s : Finset ι
hs : s.Nonempty
f : ι → α
⊢ ‖∏ i ∈ s, f i‖ ≤ ∏ i ∈ s, ‖f i‖
state_after: case mk.mk
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝¹ : SeminormedRing α✝
α : Type u_5
inst✝ : NormedCommRing α
f : ι → α
val✝ : Multiset ι
l : List ι
hl : Multiset.Nodup (Quot.mk Setoid.r l)
hs : { val := Quot.mk Setoid.r l, nodup := hl }.Nonempty
⊢ ‖∏ i ∈ { val := Quot.mk Setoid.r l, nodup := hl }, f i‖ ≤ ∏ i ∈ { val := Quot.mk Setoid.r l, nodup := hl }, ‖f i‖
tactic: rcases s with ⟨⟨l⟩, hl⟩
state_before: case mk.mk
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝¹ : SeminormedRing α✝
α : Type u_5
inst✝ : NormedCommRing α
f : ι → α
val✝ : Multiset ι
l : List ι
hl : Multiset.Nodup (Quot.mk Setoid.r l)
hs : { val := Quot.mk Setoid.r l, nodup := hl }.Nonempty
⊢ ‖∏ i ∈ { val := Quot.mk Setoid.r l, nodup := hl }, f i‖ ≤ ∏ i ∈ { val := Quot.mk Setoid.r l, nodup := hl }, ‖f i‖
state_after: case mk.mk
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝¹ : SeminormedRing α✝
α : Type u_5
inst✝ : NormedCommRing α
f : ι → α
val✝ : Multiset ι
l : List ι
hl : Multiset.Nodup (Quot.mk Setoid.r l)
hs : { val := Quot.mk Setoid.r l, nodup := hl }.Nonempty
this : List.map f l ≠ []
⊢ ‖∏ i ∈ { val := Quot.mk Setoid.r l, nodup := hl }, f i‖ ≤ ∏ i ∈ { val := Quot.mk Setoid.r l, nodup := hl }, ‖f i‖
tactic: have : l.map f ≠ [] := by simpa using hs
state_before: case mk.mk
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝¹ : SeminormedRing α✝
α : Type u_5
inst✝ : NormedCommRing α
f : ι → α
val✝ : Multiset ι
l : List ι
hl : Multiset.Nodup (Quot.mk Setoid.r l)
hs : { val := Quot.mk Setoid.r l, nodup := hl }.Nonempty
this : List.map f l ≠ []
⊢ ‖∏ i ∈ { val := Quot.mk Setoid.r l, nodup := hl }, f i‖ ≤ ∏ i ∈ { val := Quot.mk Setoid.r l, nodup := hl }, ‖f i‖
state_after: no goals
tactic: simpa using List.norm_prod_le' this
Theorem: IsAddGroupHom.preimage_normal
File: Mathlib/Deprecated/Subgroup.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set H
hs : IsNormalSubgroup s
⊢ 1 ∈ f ⁻¹' s
state_after: no goals
tactic: simp [hf.map_one, hs.toIsSubgroup.one_mem]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set H
hs : IsNormalSubgroup s
⊢ ∀ {a b : G}, a ∈ f ⁻¹' s → b ∈ f ⁻¹' s → a * b ∈ f ⁻¹' s
state_after: no goals
tactic: simp (config := { contextual := true }) [hf.map_mul, hs.toIsSubgroup.mul_mem]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set H
hs : IsNormalSubgroup s
⊢ ∀ {a : G}, a ∈ f ⁻¹' s → a⁻¹ ∈ f ⁻¹' s
state_after: no goals
tactic: simp (config := { contextual := true }) [hf.map_inv, hs.toIsSubgroup.inv_mem]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set H
hs : IsNormalSubgroup s
⊢ ∀ n ∈ f ⁻¹' s, ∀ (g : G), g * n * g⁻¹ ∈ f ⁻¹' s
state_after: no goals
tactic: simp (config := { contextual := true }) [hs.normal, hf.map_mul, hf.map_inv]
Theorem: Mathlib.Tactic.Ring.neg_congr
File: Mathlib/Tactic/Ring/Basic.lean

Proof steps:
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R✝ : Type u_1
inst✝¹ : CommSemiring R✝
a✝ a'✝ a₁ a₂ a₃ b✝ b' b₁ b₂ b₃ c c₁ c₂ : R✝
R : Type u_2
inst✝ : Ring R
a a' b : R
x✝¹ : a = a'
x✝ : -a' = b
⊢ -a = b
state_after: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R✝ : Type u_1
inst✝¹ : CommSemiring R✝
a a'✝ a₁ a₂ a₃ b b' b₁ b₂ b₃ c c₁ c₂ : R✝
R : Type u_2
inst✝ : Ring R
a' : R
⊢ -a' = -a'
tactic: subst_vars
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R✝ : Type u_1
inst✝¹ : CommSemiring R✝
a a'✝ a₁ a₂ a₃ b b' b₁ b₂ b₃ c c₁ c₂ : R✝
R : Type u_2
inst✝ : Ring R
a' : R
⊢ -a' = -a'
state_after: no goals
tactic: rfl
Theorem: FirstOrder.Language.Lequiv.onTerm_symm_apply
File: Mathlib/ModelTheory/Syntax.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
φ : L ≃ᴸ L'
⊢ Function.LeftInverse φ.invLHom.onTerm φ.toLHom.onTerm
state_after: no goals
tactic: rw [Function.leftInverse_iff_comp, ← LHom.comp_onTerm, φ.left_inv, LHom.id_onTerm]
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
φ : L ≃ᴸ L'
⊢ Function.RightInverse φ.invLHom.onTerm φ.toLHom.onTerm
state_after: no goals
tactic: rw [Function.rightInverse_iff_comp, ← LHom.comp_onTerm, φ.right_inv, LHom.id_onTerm]
Theorem: MvPolynomial.sumAlgEquiv_symm_apply
File: Mathlib/Algebra/MvPolynomial/Equiv.lean

Proof steps:
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
⊢ ∀ (r : R),
    __src✝.toFun ((algebraMap R (MvPolynomial (S₁ ⊕ S₂) R)) r) = (algebraMap R (MvPolynomial S₁ (MvPolynomial S₂ R))) r
state_after: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
r : R
⊢ __src✝.toFun ((algebraMap R (MvPolynomial (S₁ ⊕ S₂) R)) r) = (algebraMap R (MvPolynomial S₁ (MvPolynomial S₂ R))) r
tactic: intro r
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
r : R
⊢ __src✝.toFun ((algebraMap R (MvPolynomial (S₁ ⊕ S₂) R)) r) = (algebraMap R (MvPolynomial S₁ (MvPolynomial S₂ R))) r
state_after: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
r : R
A : (algebraMap R (MvPolynomial S₁ (MvPolynomial S₂ R))) r = C (C r)
⊢ __src✝.toFun ((algebraMap R (MvPolynomial (S₁ ⊕ S₂) R)) r) = (algebraMap R (MvPolynomial S₁ (MvPolynomial S₂ R))) r
tactic: have A : algebraMap R (MvPolynomial S₁ (MvPolynomial S₂ R)) r = (C (C r) : _) := rfl
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
r : R
A : (algebraMap R (MvPolynomial S₁ (MvPolynomial S₂ R))) r = C (C r)
⊢ __src✝.toFun ((algebraMap R (MvPolynomial (S₁ ⊕ S₂) R)) r) = (algebraMap R (MvPolynomial S₁ (MvPolynomial S₂ R))) r
state_after: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
r : R
A : (algebraMap R (MvPolynomial S₁ (MvPolynomial S₂ R))) r = C (C r)
B : (algebraMap R (MvPolynomial (S₁ ⊕ S₂) R)) r = C r
⊢ __src✝.toFun ((algebraMap R (MvPolynomial (S₁ ⊕ S₂) R)) r) = (algebraMap R (MvPolynomial S₁ (MvPolynomial S₂ R))) r
tactic: have B : algebraMap R (MvPolynomial (S₁ ⊕ S₂) R) r = C r := rfl
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
r : R
A : (algebraMap R (MvPolynomial S₁ (MvPolynomial S₂ R))) r = C (C r)
B : (algebraMap R (MvPolynomial (S₁ ⊕ S₂) R)) r = C r
⊢ __src✝.toFun ((algebraMap R (MvPolynomial (S₁ ⊕ S₂) R)) r) = (algebraMap R (MvPolynomial S₁ (MvPolynomial S₂ R))) r
state_after: no goals
tactic: simp only [sumRingEquiv, mvPolynomialEquivMvPolynomial, Equiv.toFun_as_coe,
        Equiv.coe_fn_mk, B, sumToIter_C, A]
Theorem: MeasureTheory.AEEqFun.comp_toGerm
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
g : β → γ
hg : Continuous g
f✝ : α →ₘ[μ] β
f : α → β
x✝ : AEStronglyMeasurable f μ
⊢ (comp g hg (mk f x✝)).toGerm = Germ.map g (mk f x✝).toGerm
state_after: no goals
tactic: simp
Theorem: Equiv.swapCore_self
File: Mathlib/Logic/Equiv/Basic.lean

Proof steps:
state_before: α : Sort u_1
inst✝ : DecidableEq α
r a : α
⊢ swapCore a a r = r
state_after: α : Sort u_1
inst✝ : DecidableEq α
r a : α
⊢ (if r = a then a else if r = a then a else r) = r
tactic: unfold swapCore
state_before: α : Sort u_1
inst✝ : DecidableEq α
r a : α
⊢ (if r = a then a else if r = a then a else r) = r
state_after: no goals
tactic: split_ifs <;> simp [*]
Theorem: AddLocalization.mkOrderEmbedding_apply
File: Mathlib/GroupTheory/MonoidLocalization/Order.lean

Proof steps:
state_before: α : Type u_1
inst✝ : OrderedCancelCommMonoid α
s : Submonoid α
a₁ b₁ : α
a₂ b₂ b✝ : ↥s
a b : α
⊢ { toFun := fun a => mk a b✝, inj' := ⋯ } a ≤ { toFun := fun a => mk a b✝, inj' := ⋯ } b ↔ a ≤ b
state_after: no goals
tactic: simp [-mk_eq_monoidOf_mk', mk_le_mk]
Theorem: CategoryTheory.Center.ext
File: Mathlib/CategoryTheory/Monoidal/Center.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y : Center C
f g : X ⟶ Y
w : f.f = g.f
⊢ f = g
state_after: case mk
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y : Center C
g : X ⟶ Y
f✝ : X.fst ⟶ Y.fst
comm✝ : ∀ (U : C), f✝ ▷ U ≫ (Y.snd.β U).hom = (X.snd.β U).hom ≫ U ◁ f✝
w : { f := f✝, comm := comm✝ }.f = g.f
⊢ { f := f✝, comm := comm✝ } = g
tactic: cases f
state_before: case mk
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y : Center C
g : X ⟶ Y
f✝ : X.fst ⟶ Y.fst
comm✝ : ∀ (U : C), f✝ ▷ U ≫ (Y.snd.β U).hom = (X.snd.β U).hom ≫ U ◁ f✝
w : { f := f✝, comm := comm✝ }.f = g.f
⊢ { f := f✝, comm := comm✝ } = g
state_after: case mk.mk
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y : Center C
f✝¹ : X.fst ⟶ Y.fst
comm✝¹ : ∀ (U : C), f✝¹ ▷ U ≫ (Y.snd.β U).hom = (X.snd.β U).hom ≫ U ◁ f✝¹
f✝ : X.fst ⟶ Y.fst
comm✝ : ∀ (U : C), f✝ ▷ U ≫ (Y.snd.β U).hom = (X.snd.β U).hom ≫ U ◁ f✝
w : { f := f✝¹, comm := comm✝¹ }.f = { f := f✝, comm := comm✝ }.f
⊢ { f := f✝¹, comm := comm✝¹ } = { f := f✝, comm := comm✝ }
tactic: cases g
state_before: case mk.mk
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y : Center C
f✝¹ : X.fst ⟶ Y.fst
comm✝¹ : ∀ (U : C), f✝¹ ▷ U ≫ (Y.snd.β U).hom = (X.snd.β U).hom ≫ U ◁ f✝¹
f✝ : X.fst ⟶ Y.fst
comm✝ : ∀ (U : C), f✝ ▷ U ≫ (Y.snd.β U).hom = (X.snd.β U).hom ≫ U ◁ f✝
w : { f := f✝¹, comm := comm✝¹ }.f = { f := f✝, comm := comm✝ }.f
⊢ { f := f✝¹, comm := comm✝¹ } = { f := f✝, comm := comm✝ }
state_after: no goals
tactic: congr
Theorem: map_nsmul
File: Mathlib/Algebra/Group/Hom/Defs.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
H : Type u_8
F : Type u_9
inst✝⁶ : MulOneClass M
inst✝⁵ : MulOneClass N
inst✝⁴ : FunLike F M N
inst✝³ : FunLike F G H
inst✝² : Monoid G
inst✝¹ : Monoid H
inst✝ : MonoidHomClass F G H
f : F
a : G
⊢ f (a ^ 0) = f a ^ 0
state_after: no goals
tactic: rw [pow_zero, pow_zero, map_one]
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
H : Type u_8
F : Type u_9
inst✝⁶ : MulOneClass M
inst✝⁵ : MulOneClass N
inst✝⁴ : FunLike F M N
inst✝³ : FunLike F G H
inst✝² : Monoid G
inst✝¹ : Monoid H
inst✝ : MonoidHomClass F G H
f : F
a : G
n : ℕ
⊢ f (a ^ (n + 1)) = f a ^ (n + 1)
state_after: no goals
tactic: rw [pow_succ, pow_succ, map_mul, map_pow f a n]
Theorem: Nat.ofDigits_one_cons
File: Mathlib/Data/Nat/Digits.lean

Proof steps:
state_before: n : ℕ
α : Type u_1
inst✝ : Semiring α
h : ℕ
L : List ℕ
⊢ ofDigits 1 (h :: L) = ↑h + ofDigits 1 L
state_after: no goals
tactic: simp [ofDigits]
Theorem: Multiset.toFinset_dedup
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t m : Multiset α
⊢ m.dedup.toFinset = m.toFinset
state_after: no goals
tactic: simp_rw [toFinset, dedup_idem]
Theorem: Set.image_iUnion₂
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β
s : (i : ι) → κ i → Set α
⊢ f '' ⋃ i, ⋃ j, s i j = ⋃ i, ⋃ j, f '' s i j
state_after: no goals
tactic: simp_rw [image_iUnion]
Theorem: IsAdjoinRoot.lift_root
File: Mathlib/RingTheory/IsAdjoinRoot.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
⊢ (lift i x hx h) h.root = x
state_after: no goals
tactic: rw [← h.map_X, lift_map, eval₂_X]
Theorem: Subgroup.IsComplement.leftCosetEquivalence_equiv_fst
File: Mathlib/GroupTheory/Complement.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
⊢ LeftCosetEquivalence (↑K) g ↑(hSK.equiv g).1
state_after: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
⊢ LeftCosetEquivalence (↑K) g (g * (↑(hSK.equiv g).2)⁻¹)
tactic: rw [equiv_fst_eq_mul_inv]
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
⊢ LeftCosetEquivalence (↑K) g (g * (↑(hSK.equiv g).2)⁻¹)
state_after: no goals
tactic: simp [LeftCosetEquivalence, leftCoset_eq_iff]
Theorem: smul_closedBall_one
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

Proof steps:
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ x • closedBall 1 δ = closedBall x δ
state_after: no goals
tactic: simp
Theorem: Projectivization.dependent_iff
File: Mathlib/LinearAlgebra/Projectivization/Independence.lean

Proof steps:
state_before: ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → ℙ K V
⊢ Dependent f ↔ ¬LinearIndependent K (Projectivization.rep ∘ f)
state_after: case refine_1
ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → ℙ K V
⊢ Dependent f → ¬LinearIndependent K (Projectivization.rep ∘ f)

case refine_2
ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → ℙ K V
h : ¬LinearIndependent K (Projectivization.rep ∘ f)
⊢ Dependent f
tactic: refine ⟨?_, fun h => ?_⟩
Theorem: continuousAt_const_cpow'
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

Proof steps:
state_before: α : Type u_1
a b : ℂ
h : b ≠ 0
⊢ ContinuousAt (fun x => a ^ x) b
state_after: case pos
α : Type u_1
a b : ℂ
h : b ≠ 0
ha : a = 0
⊢ ContinuousAt (fun x => a ^ x) b

case neg
α : Type u_1
a b : ℂ
h : b ≠ 0
ha : ¬a = 0
⊢ ContinuousAt (fun x => a ^ x) b
tactic: by_cases ha : a = 0
Theorem: Set.Countable.image2
File: Mathlib/Data/Set/Countable.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
t : Set β
hs : s.Countable
ht : t.Countable
f : α → β → γ
⊢ (Set.image2 f s t).Countable
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
t : Set β
hs : s.Countable
ht : t.Countable
f : α → β → γ
⊢ ((fun x => f x.1 x.2) '' s ×ˢ t).Countable
tactic: rw [← image_prod]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
t : Set β
hs : s.Countable
ht : t.Countable
f : α → β → γ
⊢ ((fun x => f x.1 x.2) '' s ×ˢ t).Countable
state_after: no goals
tactic: exact (hs.prod ht).image _
Theorem: Complex.I_pow_four
File: Mathlib/Data/Complex/Basic.lean

Proof steps:
state_before: ⊢ I ^ 4 = 1
state_after: no goals
tactic: rw [(by norm_num : 4 = 2 * 2), pow_mul, I_sq, neg_one_sq]
Theorem: LieSubmodule.le_normalizer
File: Mathlib/Algebra/Lie/Normalizer.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
⊢ N ≤ N.normalizer
state_after: R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
m : M
hm : m ∈ N
⊢ m ∈ N.normalizer
tactic: intro m hm
state_before: R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
m : M
hm : m ∈ N
⊢ m ∈ N.normalizer
state_after: R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
m : M
hm : m ∈ N
⊢ ∀ (x : L), ⁅x, m⁆ ∈ N
tactic: rw [mem_normalizer]
state_before: R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
m : M
hm : m ∈ N
⊢ ∀ (x : L), ⁅x, m⁆ ∈ N
state_after: no goals
tactic: exact fun x => N.lie_mem hm
Theorem: differentiable_tsum
File: Mathlib/Analysis/Calculus/SmoothSeries.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
𝕜 : Type u_3
E : Type u_4
F : Type u_5
inst✝⁵ : RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : NormedSpace 𝕜 F
f : α → E → F
f' : α → E → E →L[𝕜] F
g g' : α → 𝕜 → F
v : ℕ → α → ℝ
s : Set E
t : Set 𝕜
x₀ x : E
y₀ y : 𝕜
N : ℕ∞
hu : Summable u
hf : ∀ (n : α) (x : E), HasFDerivAt (f n) (f' n x) x
hf' : ∀ (n : α) (x : E), ‖f' n x‖ ≤ u n
⊢ Differentiable 𝕜 fun y => ∑' (n : α), f n y
state_after: case pos
α : Type u_1
β : Type u_2
𝕜 : Type u_3
E : Type u_4
F : Type u_5
inst✝⁵ : RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : NormedSpace 𝕜 F
f : α → E → F
f' : α → E → E →L[𝕜] F
g g' : α → 𝕜 → F
v : ℕ → α → ℝ
s : Set E
t : Set 𝕜
x₀ x : E
y₀ y : 𝕜
N : ℕ∞
hu : Summable u
hf : ∀ (n : α) (x : E), HasFDerivAt (f n) (f' n x) x
hf' : ∀ (n : α) (x : E), ‖f' n x‖ ≤ u n
h : ∃ x₀, Summable fun n => f n x₀
⊢ Differentiable 𝕜 fun y => ∑' (n : α), f n y

case neg
α : Type u_1
β : Type u_2
𝕜 : Type u_3
E : Type u_4
F : Type u_5
inst✝⁵ : RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : NormedSpace 𝕜 F
f : α → E → F
f' : α → E → E →L[𝕜] F
g g' : α → 𝕜 → F
v : ℕ → α → ℝ
s : Set E
t : Set 𝕜
x₀ x : E
y₀ y : 𝕜
N : ℕ∞
hu : Summable u
hf : ∀ (n : α) (x : E), HasFDerivAt (f n) (f' n x) x
hf' : ∀ (n : α) (x : E), ‖f' n x‖ ≤ u n
h : ¬∃ x₀, Summable fun n => f n x₀
⊢ Differentiable 𝕜 fun y => ∑' (n : α), f n y
tactic: by_cases h : ∃ x₀, Summable fun n => f n x₀
Theorem: Nat.bit_lt_bit
File: Mathlib/Data/Nat/Bits.lean

Proof steps:
state_before: m n : ℕ
a b : Bool
h : m < n
⊢ bit a m < 2 * n
state_after: no goals
tactic: cases a <;> dsimp [bit] <;> omega
state_before: m n : ℕ
a b : Bool
h : m < n
⊢ 2 * n ≤ bit b n
state_after: no goals
tactic: cases b <;> dsimp [bit] <;> omega