ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: LieDerivation.eqOn_lieSpan
File: Mathlib/Algebra/Lie/Derivation/Basic.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
M : Type u_3
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
D D1 D2 : LieDerivation R L M
a b : L
s : Set L
h : Set.EqOn (⇑D1) (⇑D2) s
z : L
hz : z ∈ ↑(LieSubalgebra.lieSpan R L s)
⊢ D1 0 = D2 0
state_after: no goals
tactic: simp only [map_zero]
state_before: R : Type u_1
L : Type u_2
M : Type u_3
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
D D1 D2 : LieDerivation R L M
a b : L
s : Set L
h : Set.EqOn (⇑D1) (⇑D2) s
z : L
hz : z ∈ ↑(LieSubalgebra.lieSpan R L s)
zero : D1 0 = D2 0
x✝¹ : R
x✝ : L
hx : D1 x✝ = D2 x✝
⊢ D1 (x✝¹ • x✝) = D2 (x✝¹ • x✝)
state_after: no goals
tactic: simp only [map_smul, hx]
state_before: R : Type u_1
L : Type u_2
M : Type u_3
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
D D1 D2 : LieDerivation R L M
a b : L
s : Set L
h : Set.EqOn (⇑D1) (⇑D2) s
z : L
hz : z ∈ ↑(LieSubalgebra.lieSpan R L s)
zero : D1 0 = D2 0
smul : ∀ (r : R) {x : L}, D1 x = D2 x → D1 (r • x) = D2 (r • x)
x✝¹ x✝ : L
hx : D1 x✝¹ = D2 x✝¹
hy : D1 x✝ = D2 x✝
⊢ D1 (x✝¹ + x✝) = D2 (x✝¹ + x✝)
state_after: no goals
tactic: simp only [map_add, hx, hy]
state_before: R : Type u_1
L : Type u_2
M : Type u_3
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
D D1 D2 : LieDerivation R L M
a b : L
s : Set L
h : Set.EqOn (⇑D1) (⇑D2) s
z : L
hz : z ∈ ↑(LieSubalgebra.lieSpan R L s)
zero : D1 0 = D2 0
smul : ∀ (r : R) {x : L}, D1 x = D2 x → D1 (r • x) = D2 (r • x)
add : ∀ (x y : L), D1 x = D2 x → D1 y = D2 y → D1 (x + y) = D2 (x + y)
x✝¹ x✝ : L
hx : D1 x✝¹ = D2 x✝¹
hy : D1 x✝ = D2 x✝
⊢ D1 ⁅x✝¹, x✝⁆ = D2 ⁅x✝¹, x✝⁆
state_after: no goals
tactic: simp only [apply_lie_eq_sub, hx, hy]
Theorem: ZFSet.IsTransitive.sUnion
File: Mathlib/SetTheory/ZFC/Ordinal.lean

Proof steps:
state_before: x y✝ z✝ : ZFSet
h : x.IsTransitive
y : ZFSet
hy : y ∈ ⋃₀ x
z : ZFSet
hz : z ∈ y
⊢ z ∈ ⋃₀ x
state_after: case intro.intro
x y✝ z✝ : ZFSet
h : x.IsTransitive
y : ZFSet
hy : y ∈ ⋃₀ x
z : ZFSet
hz : z ∈ y
w : ZFSet
hw : w ∈ x
hw' : y ∈ w
⊢ z ∈ ⋃₀ x
tactic: rcases mem_sUnion.1 hy with ⟨w, hw, hw'⟩
state_before: case intro.intro
x y✝ z✝ : ZFSet
h : x.IsTransitive
y : ZFSet
hy : y ∈ ⋃₀ x
z : ZFSet
hz : z ∈ y
w : ZFSet
hw : w ∈ x
hw' : y ∈ w
⊢ z ∈ ⋃₀ x
state_after: no goals
tactic: exact mem_sUnion_of_mem hz (h.mem_trans hw' hw)
Theorem: Matrix.toLinAlgEquiv_mul
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

Proof steps:
state_before: R : Type u_1
inst✝⁹ : CommSemiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝⁸ : Fintype n
inst✝⁷ : Fintype m
inst✝⁶ : DecidableEq n
M₁ : Type u_5
M₂ : Type u_6
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₁
inst✝² : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M₃ : Type u_7
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
v₃ : Basis l R M₃
A B : Matrix n n R
⊢ (toLinAlgEquiv v₁) (A * B) = (toLinAlgEquiv v₁) A ∘ₗ (toLinAlgEquiv v₁) B
state_after: no goals
tactic: convert Matrix.toLin_mul v₁ v₁ v₁ A B
Theorem: abs_eq
File: Mathlib/Algebra/Order/Group/Abs.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
hb : 0 ≤ b
⊢ |a| = b ↔ a = b ∨ a = -b
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
hb : 0 ≤ b
⊢ a = b ∨ a = -b → |a| = b
tactic: refine ⟨eq_or_eq_neg_of_abs_eq, ?_⟩
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
hb : 0 ≤ b
⊢ a = b ∨ a = -b → |a| = b
state_after: no goals
tactic: rintro (rfl | rfl) <;> simp only [abs_neg, abs_of_nonneg hb]
Theorem: Equiv.sumCongr_apply
File: Mathlib/Logic/Equiv/Basic.lean

Proof steps:
state_before: α₁ : Type ?u.9567
α₂ : Type ?u.9569
β₁ : Type ?u.9566
β₂ : Type ?u.9568
ea : α₁ ≃ α₂
eb : β₁ ≃ β₂
x : α₁ ⊕ β₁
⊢ Sum.map (⇑ea.symm) (⇑eb.symm) (Sum.map (⇑ea) (⇑eb) x) = x
state_after: no goals
tactic: simp
state_before: α₁ : Type ?u.9567
α₂ : Type ?u.9569
β₁ : Type ?u.9566
β₂ : Type ?u.9568
ea : α₁ ≃ α₂
eb : β₁ ≃ β₂
x : α₂ ⊕ β₂
⊢ Sum.map (⇑ea) (⇑eb) (Sum.map (⇑ea.symm) (⇑eb.symm) x) = x
state_after: no goals
tactic: simp
Theorem: Equiv.Perm.cycleOf_apply
File: Mathlib/GroupTheory/Perm/Cycle/Factors.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x✝ y✝ : α
inst✝² : DecidableRel f✝.SameCycle
inst✝¹ : DecidableRel g.SameCycle
f : Perm α
inst✝ : DecidableRel f.SameCycle
x y : α
⊢ (f.cycleOf x) y = if f.SameCycle x y then f y else y
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x✝ y✝ : α
inst✝² : DecidableRel f✝.SameCycle
inst✝¹ : DecidableRel g.SameCycle
f : Perm α
inst✝ : DecidableRel f.SameCycle
x y : α
⊢ (ofSubtype (f.subtypePerm ⋯)) y = if f.SameCycle x y then f y else y
tactic: dsimp only [cycleOf]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x✝ y✝ : α
inst✝² : DecidableRel f✝.SameCycle
inst✝¹ : DecidableRel g.SameCycle
f : Perm α
inst✝ : DecidableRel f.SameCycle
x y : α
⊢ (ofSubtype (f.subtypePerm ⋯)) y = if f.SameCycle x y then f y else y
state_after: case pos
ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x✝ y✝ : α
inst✝² : DecidableRel f✝.SameCycle
inst✝¹ : DecidableRel g.SameCycle
f : Perm α
inst✝ : DecidableRel f.SameCycle
x y : α
h : f.SameCycle x y
⊢ (ofSubtype (f.subtypePerm ⋯)) y = f y

case neg
ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x✝ y✝ : α
inst✝² : DecidableRel f✝.SameCycle
inst✝¹ : DecidableRel g.SameCycle
f : Perm α
inst✝ : DecidableRel f.SameCycle
x y : α
h : ¬f.SameCycle x y
⊢ (ofSubtype (f.subtypePerm ⋯)) y = y
tactic: split_ifs with h
Theorem: Finset.weightedVSub_apply_const
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
w : ι → k
p : P
h : ∑ i ∈ s, w i = 0
⊢ (s.weightedVSub fun x => p) w = 0
state_after: no goals
tactic: rw [weightedVSub, weightedVSubOfPoint_apply_const, h, zero_smul]
Theorem: Polynomial.cardinal_mk_eq_max
File: Mathlib/Algebra/Polynomial/Cardinal.lean

Proof steps:
state_before: R : Type u
inst✝¹ : Semiring R
inst✝ : Nontrivial R
⊢ #(AddMonoidAlgebra R ℕ) = max #R ℵ₀
state_after: R : Type u
inst✝¹ : Semiring R
inst✝ : Nontrivial R
⊢ max (#R) (lift.{u, 0} #ℕ) = max #R ℵ₀
tactic: rw [AddMonoidAlgebra, mk_finsupp_lift_of_infinite, lift_uzero, max_comm]
state_before: R : Type u
inst✝¹ : Semiring R
inst✝ : Nontrivial R
⊢ max (#R) (lift.{u, 0} #ℕ) = max #R ℵ₀
state_after: no goals
tactic: rfl
Theorem: Zsqrtd.le_antisymm
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

Proof steps:
state_before: d : ℕ
dnsq : Nonsquare d
a b : ℤ√↑d
ab : a ≤ b
ba : b ≤ a
⊢ (-(a - b)).Nonneg
state_after: no goals
tactic: rwa [neg_sub]
Theorem: Polynomial.degree_mul_le
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝¹ p✝ q✝ : R[X]
ι : Type u_1
p q : R[X]
⊢ (p * q).degree ≤ p.degree + q.degree
state_after: no goals
tactic: simpa only [degree, ← support_toFinsupp, toFinsupp_mul]
    using AddMonoidAlgebra.sup_support_mul_le (WithBot.coe_add _ _).le _ _
Theorem: min_sub_sub_right
File: Mathlib/Algebra/Order/Group/MinMax.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroup α
a✝ b✝ c✝ a b c : α
⊢ min (a / c) (b / c) = min a b / c
state_after: no goals
tactic: simpa only [div_eq_mul_inv] using min_mul_mul_right a b c⁻¹
Theorem: Submodule.FG.pow
File: Mathlib/RingTheory/Finiteness.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
M N : Submodule R A
h : M.FG
n : ℕ
⊢ span R ↑{1} = M ^ Nat.zero
state_after: no goals
tactic: simp [one_eq_span]
state_before: R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
M N : Submodule R A
h : M.FG
n✝ n : ℕ
ih : (M ^ n).FG
⊢ (M ^ n.succ).FG
state_after: no goals
tactic: simpa [pow_succ] using ih.mul h
Theorem: isCoprime_of_gcd_eq_one_of_FLT
File: Mathlib/NumberTheory/FLT/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Semiring α
inst✝ : NoZeroDivisors α
m n✝ n : ℕ
a b c : ℤ
Hgcd : {a, b, c}.gcd id = 1
HF : a ^ n + b ^ n + c ^ n = 0
⊢ IsCoprime a b
state_after: case inl
α : Type u_1
inst✝¹ : Semiring α
inst✝ : NoZeroDivisors α
m n : ℕ
a b c : ℤ
Hgcd : {a, b, c}.gcd id = 1
HF : a ^ 0 + b ^ 0 + c ^ 0 = 0
⊢ IsCoprime a b

case inr
α : Type u_1
inst✝¹ : Semiring α
inst✝ : NoZeroDivisors α
m n✝ n : ℕ
a b c : ℤ
Hgcd : {a, b, c}.gcd id = 1
HF : a ^ n + b ^ n + c ^ n = 0
hn : n ≠ 0
⊢ IsCoprime a b
tactic: rcases eq_or_ne n 0 with rfl | hn
state_before: case inr
α : Type u_1
inst✝¹ : Semiring α
inst✝ : NoZeroDivisors α
m n✝ n : ℕ
a b c : ℤ
Hgcd : {a, b, c}.gcd id = 1
HF : a ^ n + b ^ n + c ^ n = 0
hn : n ≠ 0
⊢ IsCoprime a b
state_after: case inr.refine_1
α : Type u_1
inst✝¹ : Semiring α
inst✝ : NoZeroDivisors α
m n✝ n : ℕ
a b c : ℤ
Hgcd : {a, b, c}.gcd id = 1
HF : a ^ n + b ^ n + c ^ n = 0
hn : n ≠ 0
⊢ ¬(a = 0 ∧ b = 0)

case inr.refine_2
α : Type u_1
inst✝¹ : Semiring α
inst✝ : NoZeroDivisors α
m n✝ n : ℕ
a b c : ℤ
Hgcd : {a, b, c}.gcd id = 1
HF : a ^ n + b ^ n + c ^ n = 0
hn : n ≠ 0
p : ℤ
hp : Prime p
hpa : p ∣ a
hpb : p ∣ b
⊢ p ∣ 1
tactic: refine isCoprime_of_prime_dvd  ?_ <| (fun p hp hpa hpb ↦ hp.not_dvd_one ?_)
Theorem: Filter.pmap_res
File: Mathlib/Order/Filter/Partial.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
l : Filter α
s : Set α
f : α → β
⊢ pmap (PFun.res f s) l = map f (l ⊓ 𝓟 s)
state_after: case h
α : Type u
β : Type v
γ : Type w
l : Filter α
s : Set α
f : α → β
t : Set β
⊢ t ∈ pmap (PFun.res f s) l ↔ t ∈ map f (l ⊓ 𝓟 s)
tactic: ext t
state_before: case h
α : Type u
β : Type v
γ : Type w
l : Filter α
s : Set α
f : α → β
t : Set β
⊢ t ∈ pmap (PFun.res f s) l ↔ t ∈ map f (l ⊓ 𝓟 s)
state_after: case h
α : Type u
β : Type v
γ : Type w
l : Filter α
s : Set α
f : α → β
t : Set β
⊢ sᶜ ∪ f ⁻¹' t ∈ l ↔ {x | x ∉ s ∨ x ∈ f ⁻¹' t} ∈ l
tactic: simp only [PFun.core_res, mem_pmap, mem_map, mem_inf_principal, imp_iff_not_or]
state_before: case h
α : Type u
β : Type v
γ : Type w
l : Filter α
s : Set α
f : α → β
t : Set β
⊢ sᶜ ∪ f ⁻¹' t ∈ l ↔ {x | x ∉ s ∨ x ∈ f ⁻¹' t} ∈ l
state_after: no goals
tactic: rfl
Theorem: CoxeterSystem.length_leftInvSeq
File: Mathlib/GroupTheory/Coxeter/Inversion.lean

Proof steps:
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
⊢ (cs.leftInvSeq ω).length = ω.length
state_after: no goals
tactic: simp [leftInvSeq_eq_reverse_rightInvSeq_reverse]
Theorem: SimpleGraph.eq_singletonSubgraph_iff_verts_eq
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : SimpleGraph W
H : G.Subgraph
v : V
⊢ H = G.singletonSubgraph v ↔ H.verts = {v}
state_after: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : SimpleGraph W
H : G.Subgraph
v : V
h : H.verts = {v}
⊢ H = G.singletonSubgraph v
tactic: refine ⟨fun h ↦ by rw [h, singletonSubgraph_verts], fun h ↦ ?_⟩
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : SimpleGraph W
H : G.Subgraph
v : V
h : H.verts = {v}
⊢ H = G.singletonSubgraph v
state_after: case verts.h
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : SimpleGraph W
H : G.Subgraph
v : V
h : H.verts = {v}
x✝ : V
⊢ x✝ ∈ H.verts ↔ x✝ ∈ (G.singletonSubgraph v).verts

case Adj.h.h.a
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : SimpleGraph W
H : G.Subgraph
v : V
h : H.verts = {v}
x✝¹ x✝ : V
⊢ H.Adj x✝¹ x✝ ↔ (G.singletonSubgraph v).Adj x✝¹ x✝
tactic: ext
Theorem: Asymptotics.isBigO_fst_prod'
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹³ : Norm E
inst✝¹² : Norm F
inst✝¹¹ : Norm G
inst✝¹⁰ : SeminormedAddCommGroup E'
inst✝⁹ : SeminormedAddCommGroup F'
inst✝⁸ : SeminormedAddCommGroup G'
inst✝⁷ : NormedAddCommGroup E''
inst✝⁶ : NormedAddCommGroup F''
inst✝⁵ : NormedAddCommGroup G''
inst✝⁴ : SeminormedRing R
inst✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f'✝ : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
f' : α → E' × F'
⊢ (fun x => (f' x).1) =O[l] f'
state_after: no goals
tactic: simpa [IsBigO_def, IsBigOWith_def] using isBigO_fst_prod (E' := E') (F' := F')
Theorem: MeasureTheory.lintegral_div_right_eq_self
File: Mathlib/MeasureTheory/Group/LIntegral.lean

Proof steps:
state_before: G : Type u_1
inst✝³ : MeasurableSpace G
μ : Measure G
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : μ.IsMulRightInvariant
f : G → ℝ≥0∞
g : G
⊢ ∫⁻ (x : G), f (x / g) ∂μ = ∫⁻ (x : G), f x ∂μ
state_after: no goals
tactic: simp_rw [div_eq_mul_inv, lintegral_mul_right_eq_self f g⁻¹]
Theorem: UpperSet.mem_iInf₂_iff
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : LE α
S : Set (UpperSet α)
s t : UpperSet α
a : α
f : (i : ι) → κ i → UpperSet α
⊢ a ∈ ⨅ i, ⨅ j, f i j ↔ ∃ i j, a ∈ f i j
state_after: no goals
tactic: simp_rw [mem_iInf_iff]
Theorem: Set.Subsingleton.equitableOn
File: Mathlib/Data/Set/Equitable.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : OrderedSemiring β
s : Set α
hs : s.Subsingleton
f : α → β
i j : α
hi : i ∈ s
hj : j ∈ s
⊢ f i ≤ f j + 1
state_after: α : Type u_1
β : Type u_2
inst✝ : OrderedSemiring β
s : Set α
hs : s.Subsingleton
f : α → β
i j : α
hi : i ∈ s
hj : j ∈ s
⊢ f j ≤ f j + 1
tactic: rw [hs hi hj]
state_before: α : Type u_1
β : Type u_2
inst✝ : OrderedSemiring β
s : Set α
hs : s.Subsingleton
f : α → β
i j : α
hi : i ∈ s
hj : j ∈ s
⊢ f j ≤ f j + 1
state_after: no goals
tactic: exact le_add_of_nonneg_right zero_le_one
Theorem: Real.Angle.toReal_le_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: θ : Angle
⊢ θ.toReal ≤ π
state_after: case h
x✝ : ℝ
⊢ (↑x✝).toReal ≤ π
tactic: induction θ using Real.Angle.induction_on
state_before: case h
x✝ : ℝ
⊢ (↑x✝).toReal ≤ π
state_after: case h.e'_4
x✝ : ℝ
⊢ π = -π + 2 * π
tactic: convert toIocMod_le_right two_pi_pos _ _
state_before: case h.e'_4
x✝ : ℝ
⊢ π = -π + 2 * π
state_after: no goals
tactic: ring
Theorem: concaveOn_of_hasDerivWithinAt2_nonpos
File: Mathlib/Analysis/Convex/Deriv.lean

Proof steps:
state_before: D : Set ℝ
hD : Convex ℝ D
f f' f'' : ℝ → ℝ
hf : ContinuousOn f D
hf' : ∀ x ∈ interior D, HasDerivWithinAt f (f' x) (interior D) x
hf'' : ∀ x ∈ interior D, HasDerivWithinAt f' (f'' x) (interior D) x
hf''₀ : ∀ x ∈ interior D, f'' x ≤ 0
⊢ ConcaveOn ℝ D f
state_after: D : Set ℝ
hD : Convex ℝ D
f f' f'' : ℝ → ℝ
hf : ContinuousOn f D
hf' : ∀ x ∈ interior D, HasDerivWithinAt f (f' x) (interior D) x
hf'' : ∀ x ∈ interior D, HasDerivWithinAt f' (f'' x) (interior D) x
hf''₀ : ∀ x ∈ interior D, f'' x ≤ 0
this : EqOn (deriv f) f' (interior D)
⊢ ConcaveOn ℝ D f
tactic: have : (interior D).EqOn (deriv f) f' := deriv_eqOn isOpen_interior hf'
state_before: D : Set ℝ
hD : Convex ℝ D
f f' f'' : ℝ → ℝ
hf : ContinuousOn f D
hf' : ∀ x ∈ interior D, HasDerivWithinAt f (f' x) (interior D) x
hf'' : ∀ x ∈ interior D, HasDerivWithinAt f' (f'' x) (interior D) x
hf''₀ : ∀ x ∈ interior D, f'' x ≤ 0
this : EqOn (deriv f) f' (interior D)
⊢ ConcaveOn ℝ D f
state_after: case refine_1
D : Set ℝ
hD : Convex ℝ D
f f' f'' : ℝ → ℝ
hf : ContinuousOn f D
hf' : ∀ x ∈ interior D, HasDerivWithinAt f (f' x) (interior D) x
hf'' : ∀ x ∈ interior D, HasDerivWithinAt f' (f'' x) (interior D) x
hf''₀ : ∀ x ∈ interior D, f'' x ≤ 0
this : EqOn (deriv f) f' (interior D)
⊢ DifferentiableOn ℝ (deriv f) (interior D)

case refine_2
D : Set ℝ
hD : Convex ℝ D
f f' f'' : ℝ → ℝ
hf : ContinuousOn f D
hf' : ∀ x ∈ interior D, HasDerivWithinAt f (f' x) (interior D) x
hf'' : ∀ x ∈ interior D, HasDerivWithinAt f' (f'' x) (interior D) x
hf''₀ : ∀ x ∈ interior D, f'' x ≤ 0
this : EqOn (deriv f) f' (interior D)
⊢ ∀ x ∈ interior D, deriv^[2] f x ≤ 0
tactic: refine concaveOn_of_deriv2_nonpos hD hf (fun x hx ↦ (hf' _ hx).differentiableWithinAt) ?_ ?_
Theorem: Matrix.J_inv
File: Mathlib/LinearAlgebra/SymplecticGroup.lean

Proof steps:
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : CommRing R
inst✝ : Fintype l
⊢ (J l R)⁻¹ = -J l R
state_after: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : CommRing R
inst✝ : Fintype l
⊢ J l R * -J l R = 1
tactic: refine Matrix.inv_eq_right_inv ?_
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : CommRing R
inst✝ : Fintype l
⊢ J l R * -J l R = 1
state_after: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : CommRing R
inst✝ : Fintype l
⊢ - -1 = 1
tactic: rw [Matrix.mul_neg, J_squared]
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : CommRing R
inst✝ : Fintype l
⊢ - -1 = 1
state_after: no goals
tactic: exact neg_neg 1
Theorem: Multiset.lcm_eq_zero_iff
File: Mathlib/Algebra/GCDMonoid/Multiset.lean

Proof steps:
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : Nontrivial α
s : Multiset α
⊢ s.lcm = 0 ↔ 0 ∈ s
state_after: case empty
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : Nontrivial α
⊢ lcm 0 = 0 ↔ 0 ∈ 0

case cons
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : Nontrivial α
a : α
s : Multiset α
ihs : s.lcm = 0 ↔ 0 ∈ s
⊢ (a ::ₘ s).lcm = 0 ↔ 0 ∈ a ::ₘ s
tactic: induction' s using Multiset.induction_on with a s ihs
Theorem: ModularForm.is_invariant_const
File: Mathlib/NumberTheory/ModularForms/SlashActions.lean

Proof steps:
state_before: Γ : Subgroup SL(2, ℤ)
k : ℤ
f : ℍ → ℂ
A : SL(2, ℤ)
x : ℂ
⊢ Function.const ℍ x ∣[0] A = Function.const ℍ x
state_after: Γ : Subgroup SL(2, ℤ)
k : ℤ
f : ℍ → ℂ
A : SL(2, ℤ)
x : ℂ
this : (↑↑↑A).det = 1
⊢ Function.const ℍ x ∣[0] A = Function.const ℍ x
tactic: have : ((↑ₘ(A : GL(2, ℝ)⁺)).det : ℝ) = 1 := det_coe'
state_before: Γ : Subgroup SL(2, ℤ)
k : ℤ
f : ℍ → ℂ
A : SL(2, ℤ)
x : ℂ
this : (↑↑↑A).det = 1
⊢ Function.const ℍ x ∣[0] A = Function.const ℍ x
state_after: case h
Γ : Subgroup SL(2, ℤ)
k : ℤ
f : ℍ → ℂ
A : SL(2, ℤ)
x : ℂ
this : (↑↑↑A).det = 1
x✝ : ℍ
⊢ (Function.const ℍ x ∣[0] A) x✝ = Function.const ℍ x x✝
tactic: funext
state_before: case h
Γ : Subgroup SL(2, ℤ)
k : ℤ
f : ℍ → ℂ
A : SL(2, ℤ)
x : ℂ
this : (↑↑↑A).det = 1
x✝ : ℍ
⊢ (Function.const ℍ x ∣[0] A) x✝ = Function.const ℍ x x✝
state_after: case h
Γ : Subgroup SL(2, ℤ)
k : ℤ
f : ℍ → ℂ
A : SL(2, ℤ)
x : ℂ
this : (↑↑↑A).det = 1
x✝ : ℍ
⊢ Function.const ℍ x (↑A • x✝) * ↑1 ^ (-1) * denom (↑A) x✝ ^ (-0) = Function.const ℍ x x✝
tactic: rw [SL_slash, slash_def, slash, zero_sub, this]
state_before: case h
Γ : Subgroup SL(2, ℤ)
k : ℤ
f : ℍ → ℂ
A : SL(2, ℤ)
x : ℂ
this : (↑↑↑A).det = 1
x✝ : ℍ
⊢ Function.const ℍ x (↑A • x✝) * ↑1 ^ (-1) * denom (↑A) x✝ ^ (-0) = Function.const ℍ x x✝
state_after: no goals
tactic: simp
Theorem: Filter.seq_pure
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
f : Filter (α → β)
a : α
⊢ f.seq (pure a) = map (fun g => g a) f
state_after: case refine_1
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
f : Filter (α → β)
a : α
s : Set (α → β)
hs : s ∈ f
⊢ (fun g => g a) '' s ∈ f.seq (pure a)

case refine_2
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
f : Filter (α → β)
a : α
s : Set (α → β)
hs : s ∈ f
t : Set α
ht : t ∈ pure a
⊢ s.seq t ∈ map (fun g => g a) f
tactic: refine le_antisymm (le_map fun s hs => ?_) (le_seq fun s hs t ht => ?_)
Theorem: Submodule.lTensorOne'_one_tmul
File: Mathlib/LinearAlgebra/TensorProduct/Submodule.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
M N : Submodule R S
n : ↥N
⊢ N.lTensorOne' (1 ⊗ₜ[R] n) = n
state_after: no goals
tactic: simpa using lTensorOne'_tmul 1 n
Theorem: ContDiffAt.iteratedFDeriv_right
File: Mathlib/Analysis/Calculus/ContDiff/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
i : ℕ
hf : ContDiffAt 𝕜 n f x₀
hmn : m + ↑i ≤ n
⊢ ContDiffAt 𝕜 m (iteratedFDeriv 𝕜 i f) x₀
state_after: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
i : ℕ
hf : ContDiffWithinAt 𝕜 n f univ x₀
hmn : m + ↑i ≤ n
⊢ ContDiffWithinAt 𝕜 m (iteratedFDerivWithin 𝕜 i f univ) univ x₀
tactic: rw [← iteratedFDerivWithin_univ, ← contDiffWithinAt_univ] at *
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
i : ℕ
hf : ContDiffWithinAt 𝕜 n f univ x₀
hmn : m + ↑i ≤ n
⊢ ContDiffWithinAt 𝕜 m (iteratedFDerivWithin 𝕜 i f univ) univ x₀
state_after: no goals
tactic: exact hf.iteratedFderivWithin_right uniqueDiffOn_univ hmn trivial
Theorem: Real.cosh_arsinh
File: Mathlib/Analysis/SpecialFunctions/Arsinh.lean

Proof steps:
state_before: x✝ y x : ℝ
⊢ cosh (arsinh x) = √(1 + x ^ 2)
state_after: no goals
tactic: rw [← sqrt_sq (cosh_pos _).le, cosh_sq', sinh_arsinh]