ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Kleisli.Adjunction.fromKleisli_map
File: Mathlib/CategoryTheory/Monad/Kleisli.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
T : Monad C
X Y Z : Kleisli T
f : X ⟶ Y
g : Y ⟶ Z
⊢ { obj := fun X => T.obj X, map := fun {x Y} f => T.map f ≫ T.μ.app Y }.map (f ≫ g) =
    { obj := fun X => T.obj X, map := fun {x Y} f => T.map f ≫ T.μ.app Y }.map f ≫
      { obj := fun X => T.obj X, map := fun {x Y} f => T.map f ≫ T.μ.app Y }.map g
state_after: C : Type u
inst✝ : Category.{v, u} C
T : Monad C
X Y Z : Kleisli T
f : X ⟶ Y
g : Y ⟶ Z
⊢ T.map (f ≫ T.map g ≫ T.μ.app Z) ≫ T.μ.app Z =
    { obj := fun X => T.obj X, map := fun {x Y} f => T.map f ≫ T.μ.app Y }.map f ≫
      { obj := fun X => T.obj X, map := fun {x Y} f => T.map f ≫ T.μ.app Y }.map g
tactic: change T.map (f ≫ T.map g ≫ T.μ.app Z) ≫ T.μ.app Z = _
state_before: C : Type u
inst✝ : Category.{v, u} C
T : Monad C
X Y Z : Kleisli T
f : X ⟶ Y
g : Y ⟶ Z
⊢ T.map (f ≫ T.map g ≫ T.μ.app Z) ≫ T.μ.app Z =
    { obj := fun X => T.obj X, map := fun {x Y} f => T.map f ≫ T.μ.app Y }.map f ≫
      { obj := fun X => T.obj X, map := fun {x Y} f => T.map f ≫ T.μ.app Y }.map g
state_after: C : Type u
inst✝ : Category.{v, u} C
T : Monad C
X Y Z : Kleisli T
f : X ⟶ Y
g : Y ⟶ Z
⊢ T.map f ≫ T.map (T.map g) ≫ T.map (T.μ.app Z) ≫ T.μ.app Z = T.map f ≫ T.μ.app Y ≫ T.map g ≫ T.μ.app Z
tactic: simp only [Functor.map_comp, Category.assoc]
state_before: C : Type u
inst✝ : Category.{v, u} C
T : Monad C
X Y Z : Kleisli T
f : X ⟶ Y
g : Y ⟶ Z
⊢ T.map f ≫ T.map (T.map g) ≫ T.map (T.μ.app Z) ≫ T.μ.app Z = T.map f ≫ T.μ.app Y ≫ T.map g ≫ T.μ.app Z
state_after: C : Type u
inst✝ : Category.{v, u} C
T : Monad C
X Y Z : Kleisli T
f : X ⟶ Y
g : Y ⟶ Z
⊢ T.map f ≫ T.map (T.map g) ≫ T.μ.app (T.obj Z) ≫ T.μ.app Z =
    T.map f ≫ (T.toFunctor ⋙ T.toFunctor).map g ≫ T.μ.app (T.obj Z) ≫ T.μ.app Z
tactic: erw [← T.μ.naturality_assoc g, T.assoc]
state_before: C : Type u
inst✝ : Category.{v, u} C
T : Monad C
X Y Z : Kleisli T
f : X ⟶ Y
g : Y ⟶ Z
⊢ T.map f ≫ T.map (T.map g) ≫ T.μ.app (T.obj Z) ≫ T.μ.app Z =
    T.map f ≫ (T.toFunctor ⋙ T.toFunctor).map g ≫ T.μ.app (T.obj Z) ≫ T.μ.app Z
state_after: no goals
tactic: rfl
Theorem: Nat.ofDigits_monotone
File: Mathlib/Data/Nat/Digits.lean

Proof steps:
state_before: n p q : ℕ
L : List ℕ
h : p ≤ q
⊢ ofDigits p L ≤ ofDigits q L
state_after: case nil
n p q : ℕ
h : p ≤ q
⊢ ofDigits p [] ≤ ofDigits q []

case cons
n p q : ℕ
h : p ≤ q
head✝ : ℕ
tail✝ : List ℕ
hi : ofDigits p tail✝ ≤ ofDigits q tail✝
⊢ ofDigits p (head✝ :: tail✝) ≤ ofDigits q (head✝ :: tail✝)
tactic: induction' L with _ _ hi
Theorem: LinearPMap.sup_h_of_disjoint
File: Mathlib/LinearAlgebra/LinearPMap.lean

Proof steps:
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : Disjoint f.domain g.domain
x : ↥f.domain
y : ↥g.domain
hxy : ↑x = ↑y
⊢ ↑f x = ↑g y
state_after: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ x ∈ f.domain, x ∈ g.domain → x = 0
x : ↥f.domain
y : ↥g.domain
hxy : ↑x = ↑y
⊢ ↑f x = ↑g y
tactic: rw [disjoint_def] at h
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ x ∈ f.domain, x ∈ g.domain → x = 0
x : ↥f.domain
y : ↥g.domain
hxy : ↑x = ↑y
⊢ ↑f x = ↑g y
state_after: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ x ∈ f.domain, x ∈ g.domain → x = 0
x : ↥f.domain
y : ↥g.domain
hxy : ↑x = ↑y
hy : y = 0
⊢ ↑f x = ↑g y
tactic: have hy : y = 0 := Subtype.eq (h y (hxy ▸ x.2) y.2)
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ x ∈ f.domain, x ∈ g.domain → x = 0
x : ↥f.domain
y : ↥g.domain
hxy : ↑x = ↑y
hy : y = 0
⊢ ↑f x = ↑g y
state_after: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ x ∈ f.domain, x ∈ g.domain → x = 0
x : ↥f.domain
y : ↥g.domain
hxy : ↑x = ↑y
hy : y = 0
hx : x = 0
⊢ ↑f x = ↑g y
tactic: have hx : x = 0 := Subtype.eq (hxy.trans <| congr_arg _ hy)
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ x ∈ f.domain, x ∈ g.domain → x = 0
x : ↥f.domain
y : ↥g.domain
hxy : ↑x = ↑y
hy : y = 0
hx : x = 0
⊢ ↑f x = ↑g y
state_after: no goals
tactic: simp [*]
Theorem: IsLocalization.Away.sec_spec
File: Mathlib/RingTheory/Localization/Away/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
x : R
inst✝ : Away x S
s : S
⊢ s * (algebraMap R S) (x ^ (sec x s).2) = (algebraMap R S) (sec x s).1
state_after: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
x : R
inst✝ : Away x S
s : S
⊢ s * (algebraMap R S) (x ^ Exists.choose ⋯) = s * (algebraMap R S) ↑(IsLocalization.sec (Submonoid.powers x) s).2
tactic: simp only [IsLocalization.Away.sec, ← IsLocalization.sec_spec]
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
x : R
inst✝ : Away x S
s : S
⊢ s * (algebraMap R S) (x ^ Exists.choose ⋯) = s * (algebraMap R S) ↑(IsLocalization.sec (Submonoid.powers x) s).2
state_after: case e_a.h.e_6.h
R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
x : R
inst✝ : Away x S
s : S
⊢ x ^ Exists.choose ⋯ = ↑(IsLocalization.sec (Submonoid.powers x) s).2
tactic: congr
state_before: case e_a.h.e_6.h
R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
x : R
inst✝ : Away x S
s : S
⊢ x ^ Exists.choose ⋯ = ↑(IsLocalization.sec (Submonoid.powers x) s).2
state_after: no goals
tactic: exact (IsLocalization.sec (Submonoid.powers x) s).2.property.choose_spec
Theorem: Isometry.preimage_setOf_dist
File: Mathlib/Topology/MetricSpace/Isometry.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
f : α → β
hf : Isometry f
x : α
p : ℝ → Prop
⊢ f ⁻¹' {y | p (dist y (f x))} = {y | p (dist y x)}
state_after: case h
ι : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
f : α → β
hf : Isometry f
x : α
p : ℝ → Prop
y : α
⊢ y ∈ f ⁻¹' {y | p (dist y (f x))} ↔ y ∈ {y | p (dist y x)}
tactic: ext y
state_before: case h
ι : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
f : α → β
hf : Isometry f
x : α
p : ℝ → Prop
y : α
⊢ y ∈ f ⁻¹' {y | p (dist y (f x))} ↔ y ∈ {y | p (dist y x)}
state_after: no goals
tactic: simp [hf.dist_eq]
Theorem: dist_sub_eq_dist_add_left
File: Mathlib/Analysis/Normed/Group/Uniform.lean

Proof steps:
state_before: 𝓕 : Type u_1
α : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : SeminormedGroup E
inst✝ : SeminormedGroup F
s : Set E
a✝ a₁ a₂ b✝ b₁ b₂ : E
r r₁ r₂ : ℝ
a b c : E
⊢ dist (a / b) c = dist a (c * b)
state_after: no goals
tactic: rw [← dist_mul_right _ _ b, div_mul_cancel]
Theorem: CategoryTheory.ofTypeMonad_obj
File: Mathlib/CategoryTheory/Monad/Types.lean

Proof steps:
state_before: m : Type u → Type u
inst✝¹ : _root_.Monad m
inst✝ : LawfulMonad m
α β : Type u
f : α → β
a : (ofTypeFunctor m ⋙ ofTypeFunctor m).obj α
⊢ ((ofTypeFunctor m ⋙ ofTypeFunctor m).map f ≫ joinM) a = (joinM ≫ (ofTypeFunctor m).map f) a
state_after: no goals
tactic: apply joinM_map_map
state_before: m : Type u → Type u
inst✝¹ : _root_.Monad m
inst✝ : LawfulMonad m
α : Type u
a : (ofTypeFunctor m).obj ((ofTypeFunctor m ⋙ ofTypeFunctor m).obj α)
⊢ ((ofTypeFunctor m).map ({ app := @joinM m inst✝¹, naturality := ⋯ }.app α) ≫
        { app := @joinM m inst✝¹, naturality := ⋯ }.app α)
      a =
    ({ app := @joinM m inst✝¹, naturality := ⋯ }.app ((ofTypeFunctor m).obj α) ≫
        { app := @joinM m inst✝¹, naturality := ⋯ }.app α)
      a
state_after: no goals
tactic: apply joinM_map_joinM
state_before: m : Type u → Type u
inst✝¹ : _root_.Monad m
inst✝ : LawfulMonad m
α : Type u
a : (𝟭 (Type u)).obj ((ofTypeFunctor m).obj α)
⊢ ({ app := @pure m Applicative.toPure, naturality := ⋯ }.app ((ofTypeFunctor m).obj α) ≫
        { app := @joinM m inst✝¹, naturality := ⋯ }.app α)
      a =
    𝟙 ((𝟭 (Type u)).obj ((ofTypeFunctor m).obj α)) a
state_after: no goals
tactic: apply joinM_pure
state_before: m : Type u → Type u
inst✝¹ : _root_.Monad m
inst✝ : LawfulMonad m
α : Type u
a : (ofTypeFunctor m).obj ((𝟭 (Type u)).obj α)
⊢ ((ofTypeFunctor m).map ({ app := @pure m Applicative.toPure, naturality := ⋯ }.app α) ≫
        { app := @joinM m inst✝¹, naturality := ⋯ }.app α)
      a =
    𝟙 ((ofTypeFunctor m).obj ((𝟭 (Type u)).obj α)) a
state_after: no goals
tactic: apply joinM_map_pure
Theorem: Derivation.eqOn_adjoin
File: Mathlib/RingTheory/Derivation/Basic.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
B : Type u_3
M : Type u_4
inst✝⁸ : CommSemiring R
inst✝⁷ : CommSemiring A
inst✝⁶ : CommSemiring B
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Algebra R A
inst✝³ : Algebra R B
inst✝² : Module A M
inst✝¹ : Module B M
inst✝ : Module R M
D D1 D2 : Derivation R A M
r : R
a b : A
s : Set A
h : Set.EqOn (⇑D1) (⇑D2) s
x✝ : A
hx✝ : x✝ ∈ ↑(adjoin R s)
x y : A
hx : D1 x = D2 x
hy : D1 y = D2 y
⊢ D1 (x + y) = D2 (x + y)
state_after: no goals
tactic: simp only [map_add, *]
state_before: R : Type u_1
A : Type u_2
B : Type u_3
M : Type u_4
inst✝⁸ : CommSemiring R
inst✝⁷ : CommSemiring A
inst✝⁶ : CommSemiring B
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Algebra R A
inst✝³ : Algebra R B
inst✝² : Module A M
inst✝¹ : Module B M
inst✝ : Module R M
D D1 D2 : Derivation R A M
r : R
a b : A
s : Set A
h : Set.EqOn (⇑D1) (⇑D2) s
x✝ : A
hx✝ : x✝ ∈ ↑(adjoin R s)
x y : A
hx : D1 x = D2 x
hy : D1 y = D2 y
⊢ D1 (x * y) = D2 (x * y)
state_after: no goals
tactic: simp only [leibniz, *]
Theorem: mem_perfectClosure_iff_natSepDegree_eq_one
File: Mathlib/FieldTheory/PurelyInseparable.lean

Proof steps:
state_before: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
x : E
⊢ x ∈ perfectClosure F E ↔ (minpoly F x).natSepDegree = 1
state_after: no goals
tactic: rw [mem_perfectClosure_iff, minpoly.natSepDegree_eq_one_iff_pow_mem (ringExpChar F)]
Theorem: Polynomial.revAt_add
File: Mathlib/Algebra/Polynomial/Reverse.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
N O n o : ℕ
hn : n ≤ N
ho : o ≤ O
⊢ (revAt (N + O)) (n + o) = (revAt N) n + (revAt O) o
state_after: case intro
R : Type u_1
inst✝ : Semiring R
f : R[X]
O n o : ℕ
ho : o ≤ O
n' : ℕ
hn : n ≤ n + n'
⊢ (revAt (n + n' + O)) (n + o) = (revAt (n + n')) n + (revAt O) o
tactic: rcases Nat.le.dest hn with ⟨n', rfl⟩
state_before: case intro
R : Type u_1
inst✝ : Semiring R
f : R[X]
O n o : ℕ
ho : o ≤ O
n' : ℕ
hn : n ≤ n + n'
⊢ (revAt (n + n' + O)) (n + o) = (revAt (n + n')) n + (revAt O) o
state_after: case intro.intro
R : Type u_1
inst✝ : Semiring R
f : R[X]
n o n' : ℕ
hn : n ≤ n + n'
o' : ℕ
ho : o ≤ o + o'
⊢ (revAt (n + n' + (o + o'))) (n + o) = (revAt (n + n')) n + (revAt (o + o')) o
tactic: rcases Nat.le.dest ho with ⟨o', rfl⟩
state_before: case intro.intro
R : Type u_1
inst✝ : Semiring R
f : R[X]
n o n' : ℕ
hn : n ≤ n + n'
o' : ℕ
ho : o ≤ o + o'
⊢ (revAt (n + n' + (o + o'))) (n + o) = (revAt (n + n')) n + (revAt (o + o')) o
state_after: case intro.intro
R : Type u_1
inst✝ : Semiring R
f : R[X]
n o n' : ℕ
hn : n ≤ n + n'
o' : ℕ
ho : o ≤ o + o'
⊢ (revAt (n + n' + (o + o'))) (n + o) = n + n' - n + (o + o' - o)
tactic: repeat' rw [revAt_le (le_add_right rfl.le)]
state_before: case intro.intro
R : Type u_1
inst✝ : Semiring R
f : R[X]
n o n' : ℕ
hn : n ≤ n + n'
o' : ℕ
ho : o ≤ o + o'
⊢ (revAt (n + n' + (o + o'))) (n + o) = n + n' - n + (o + o' - o)
state_after: case intro.intro
R : Type u_1
inst✝ : Semiring R
f : R[X]
n o n' : ℕ
hn : n ≤ n + n'
o' : ℕ
ho : o ≤ o + o'
⊢ n + o + (n' + o') - (n + o) = n + n' - n + (o + o' - o)
tactic: rw [add_assoc, add_left_comm n' o, ← add_assoc, revAt_le (le_add_right rfl.le)]
state_before: case intro.intro
R : Type u_1
inst✝ : Semiring R
f : R[X]
n o n' : ℕ
hn : n ≤ n + n'
o' : ℕ
ho : o ≤ o + o'
⊢ n + o + (n' + o') - (n + o) = n + n' - n + (o + o' - o)
state_after: no goals
tactic: repeat' rw [add_tsub_cancel_left]
Theorem: Finset.powerset_insert
File: Mathlib/Data/Finset/Powerset.lean

Proof steps:
state_before: α : Type u_1
s✝ t : Finset α
inst✝ : DecidableEq α
s : Finset α
a : α
⊢ (insert a s).powerset = s.powerset ∪ image (insert a) s.powerset
state_after: case a
α : Type u_1
s✝ t✝ : Finset α
inst✝ : DecidableEq α
s : Finset α
a : α
t : Finset α
⊢ t ∈ (insert a s).powerset ↔ t ∈ s.powerset ∪ image (insert a) s.powerset
tactic: ext t
state_before: case a
α : Type u_1
s✝ t✝ : Finset α
inst✝ : DecidableEq α
s : Finset α
a : α
t : Finset α
⊢ t ∈ (insert a s).powerset ↔ t ∈ s.powerset ∪ image (insert a) s.powerset
state_after: case a
α : Type u_1
s✝ t✝ : Finset α
inst✝ : DecidableEq α
s : Finset α
a : α
t : Finset α
⊢ t.erase a ⊆ s ↔ t ⊆ s ∨ ∃ a_1 ⊆ s, insert a a_1 = t
tactic: simp only [exists_prop, mem_powerset, mem_image, mem_union, subset_insert_iff]
state_before: case a
α : Type u_1
s✝ t✝ : Finset α
inst✝ : DecidableEq α
s : Finset α
a : α
t : Finset α
⊢ t.erase a ⊆ s ↔ t ⊆ s ∨ ∃ a_1 ⊆ s, insert a a_1 = t
state_after: case pos
α : Type u_1
s✝ t✝ : Finset α
inst✝ : DecidableEq α
s : Finset α
a : α
t : Finset α
h : a ∈ t
⊢ t.erase a ⊆ s ↔ t ⊆ s ∨ ∃ a_1 ⊆ s, insert a a_1 = t

case neg
α : Type u_1
s✝ t✝ : Finset α
inst✝ : DecidableEq α
s : Finset α
a : α
t : Finset α
h : a ∉ t
⊢ t.erase a ⊆ s ↔ t ⊆ s ∨ ∃ a_1 ⊆ s, insert a a_1 = t
tactic: by_cases h : a ∈ t
Theorem: Finset.image_singleton
File: Mathlib/Data/Finset/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq β
f✝ g : α → β
s : Finset α
t : Finset β
a✝ : α
b c : β
f : α → β
a : α
x : β
⊢ x ∈ image f {a} ↔ x ∈ {f a}
state_after: no goals
tactic: simpa only [mem_image, exists_prop, mem_singleton, exists_eq_left] using eq_comm
Theorem: isClosed_derivedSet
File: Mathlib/Topology/DerivedSet.lean

Proof steps:
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
A : Set X
⊢ IsClosed (derivedSet A)
state_after: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
A : Set X
⊢ derivedSet (derivedSet (closure A)) ⊆ derivedSet (closure A)
tactic: rw [← derivedSet_closure, isClosed_iff_derivedSet_subset]
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
A : Set X
⊢ derivedSet (derivedSet (closure A)) ⊆ derivedSet (closure A)
state_after: case h
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
A : Set X
⊢ derivedSet (closure A) ⊆ closure A
tactic: apply derivedSet_mono
state_before: case h
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
A : Set X
⊢ derivedSet (closure A) ⊆ closure A
state_after: no goals
tactic: simp [← isClosed_iff_derivedSet_subset]
Theorem: ConcaveOn.slope_le_of_hasDerivWithinAt_Ioi
File: Mathlib/Analysis/Convex/Deriv.lean

Proof steps:
state_before: S : Set ℝ
f : ℝ → ℝ
x y f' : ℝ
hfc : ConcaveOn ℝ S f
hx : x ∈ S
hy : y ∈ S
hxy : x < y
hf' : HasDerivWithinAt f f' (Ioi x) x
⊢ slope f x y ≤ f'
state_after: no goals
tactic: simpa only [Pi.neg_def, slope_neg, neg_neg] using
    neg_le_neg (hfc.neg.le_slope_of_hasDerivWithinAt_Ioi hx hy hxy hf'.neg)
Theorem: ContinuousLinearMap.opNorm_le_of_lipschitz
File: Mathlib/Analysis/NormedSpace/OperatorNorm/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹⁵ : SeminormedAddCommGroup E
inst✝¹⁴ : SeminormedAddCommGroup Eₗ
inst✝¹³ : SeminormedAddCommGroup F
inst✝¹² : SeminormedAddCommGroup Fₗ
inst✝¹¹ : SeminormedAddCommGroup G
inst✝¹⁰ : SeminormedAddCommGroup Gₗ
inst✝⁹ : NontriviallyNormedField 𝕜
inst✝⁸ : NontriviallyNormedField 𝕜₂
inst✝⁷ : NontriviallyNormedField 𝕜₃
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜 Eₗ
inst✝⁴ : NormedSpace 𝕜₂ F
inst✝³ : NormedSpace 𝕜 Fₗ
inst✝² : NormedSpace 𝕜₃ G
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝¹ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝ : FunLike 𝓕 E F
f : E →SL[σ₁₂] F
K : ℝ≥0
hf : LipschitzWith K ⇑f
x : E
⊢ ‖f x‖ ≤ ↑K * ‖x‖
state_after: no goals
tactic: simpa only [dist_zero_right, f.map_zero] using hf.dist_le_mul x 0
Theorem: CategoryTheory.Over.ConstructProducts.conesEquivFunctor_obj_pt
File: Mathlib/CategoryTheory/Limits/Constructions/Over/Products.lean

Proof steps:
state_before: J✝ : Type w
C : Type u
inst✝ : Category.{v, u} C
X✝ B : C
J : Type w
F : Discrete J ⥤ Over B
c : Cone (widePullbackDiagramOfDiagramOver B F)
x✝² x✝¹ : Discrete J
X Y : J
x✝ : { as := X } ⟶ { as := Y }
f : { as := X }.as = { as := Y }.as
⊢ ((Functor.const (Discrete J)).obj (mk (c.π.app none))).map { down := { down := f } } ≫
      (fun x =>
          match x with
          | { as := j } => homMk (c.π.app (some j)) ⋯)
        { as := Y } =
    (fun x =>
          match x with
          | { as := j } => homMk (c.π.app (some j)) ⋯)
        { as := X } ≫
      F.map { down := { down := f } }
state_after: J✝ : Type w
C : Type u
inst✝ : Category.{v, u} C
X✝ B : C
J : Type w
F : Discrete J ⥤ Over B
c : Cone (widePullbackDiagramOfDiagramOver B F)
x✝² x✝¹ : Discrete J
X Y : J
x✝ : { as := X } ⟶ { as := Y }
f : X = Y
⊢ 𝟙 (mk (c.π.app none)) ≫ homMk (c.π.app (some Y)) ⋯ = homMk (c.π.app (some X)) ⋯ ≫ F.map { down := { down := f } }
tactic: dsimp at f ⊢
state_before: J✝ : Type w
C : Type u
inst✝ : Category.{v, u} C
X✝ B : C
J : Type w
F : Discrete J ⥤ Over B
c : Cone (widePullbackDiagramOfDiagramOver B F)
x✝² x✝¹ : Discrete J
X Y : J
x✝ : { as := X } ⟶ { as := Y }
f : X = Y
⊢ 𝟙 (mk (c.π.app none)) ≫ homMk (c.π.app (some Y)) ⋯ = homMk (c.π.app (some X)) ⋯ ≫ F.map { down := { down := f } }
state_after: no goals
tactic: aesop_cat
Theorem: AkraBazziRecurrence.GrowsPolynomially.norm
File: Mathlib/Computability/AkraBazzi/GrowsPolynomially.lean

Proof steps:
state_before: f : ℝ → ℝ
hf : GrowsPolynomially f
⊢ GrowsPolynomially fun x => ‖f x‖
state_after: f : ℝ → ℝ
hf : GrowsPolynomially f
⊢ GrowsPolynomially fun x => |f x|
tactic: simp only [norm_eq_abs]
state_before: f : ℝ → ℝ
hf : GrowsPolynomially f
⊢ GrowsPolynomially fun x => |f x|
state_after: no goals
tactic: exact hf.abs
Theorem: Matrix.diagonal_updateRow_single
File: Mathlib/Data/Matrix/RowCol.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i✝ : m
j : n
b : n → α
c : m → α
inst✝¹ : DecidableEq n
inst✝ : Zero α
v : n → α
i : n
x : α
⊢ (diagonal v).updateRow i (Pi.single i x) = diagonal (Function.update v i x)
state_after: no goals
tactic: rw [← diagonal_transpose, updateRow_transpose, diagonal_updateColumn_single, diagonal_transpose]
Theorem: UniformCauchySeqOn.mul
File: Mathlib/Topology/Algebra/UniformGroup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : UniformSpace α
inst✝¹ : Group α
inst✝ : UniformGroup α
ι : Type u_3
l : Filter ι
l' : Filter β
f f' : ι → β → α
g g' : β → α
s : Set β
hf : UniformCauchySeqOn f l s
hf' : UniformCauchySeqOn f' l s
u : Set (α × α)
hu : u ∈ 𝓤 α
⊢ ∀ᶠ (m : ι × ι) in l ×ˢ l, ∀ x ∈ s, ((f * f') m.1 x, (f * f') m.2 x) ∈ u
state_after: no goals
tactic: simpa using (uniformContinuous_mul.comp_uniformCauchySeqOn (hf.prod' hf')) u hu
Theorem: Complex.exp_re
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℂ
⊢ (cexp x).re = Real.exp x.re * Real.cos x.im
state_after: x y : ℂ
⊢ (cexp ↑x.re * (cos ↑x.im + sin ↑x.im * I)).re = Real.exp x.re * Real.cos x.im
tactic: rw [exp_eq_exp_re_mul_sin_add_cos]
state_before: x y : ℂ
⊢ (cexp ↑x.re * (cos ↑x.im + sin ↑x.im * I)).re = Real.exp x.re * Real.cos x.im
state_after: no goals
tactic: simp [exp_ofReal_re, cos_ofReal_re]
Theorem: Set.indicator_union_add_inter_apply
File: Mathlib/Algebra/Group/Indicator.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝ : MulOneClass M
s✝ t✝ : Set α
f✝ g : α → M
a✝ : α
f : α → M
s t : Set α
a : α
⊢ (s ∪ t).mulIndicator f a * (s ∩ t).mulIndicator f a = s.mulIndicator f a * t.mulIndicator f a
state_after: no goals
tactic: by_cases hs : a ∈ s <;> by_cases ht : a ∈ t <;> simp [*]
Theorem: dite_apply
File: Mathlib/Logic/Basic.lean

Proof steps:
state_before: α : Sort u_1
σ : α → Sort u_2
P Q R : Prop
inst✝¹ : Decidable P
inst✝ : Decidable Q
a✝ b c : α
A : P → α
B : ¬P → α
f : P → (a : α) → σ a
g : ¬P → (a : α) → σ a
a : α
⊢ dite P f g a = if h : P then f h a else g h a
state_after: no goals
tactic: by_cases h : P <;> simp [h]
Theorem: LaurentPolynomial.degree_C_mul_T_ite
File: Mathlib/Algebra/Polynomial/Laurent.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : Semiring R
inst✝ : DecidableEq R
n : ℤ
a : R
⊢ (C a * T n).degree = if a = 0 then ⊥ else ↑n
state_after: no goals
tactic: split_ifs with h <;>
    simp only [h, map_zero, zero_mul, degree_zero, degree_C_mul_T, Ne,
      not_false_iff]
Theorem: List.chain_append_singleton_iff_forall₂
File: Mathlib/Data/List/Chain.lean

Proof steps:
state_before: α : Type u
β : Type v
R r : α → α → Prop
l l₁ l₂ : List α
a b : α
⊢ Chain R a (l ++ [b]) ↔ Forall₂ R (a :: l) (l ++ [b])
state_after: no goals
tactic: simp [chain_iff_forall₂]
Theorem: CategoryTheory.Pi.equivalenceOfEquiv_counitIso
File: Mathlib/CategoryTheory/Pi/Basic.lean

Proof steps:
state_before: I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝ : (i : I) → Category.{v₁, u₁} (C i)
e : J ≃ I
i : I
⊢ e (e.symm i) = i
state_after: no goals
tactic: simp
Theorem: MeasureTheory.Lp.dist_def
File: Mathlib/MeasureTheory/Function/LpSpace.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f g : ↥(Lp E p μ)
⊢ dist f g = (eLpNorm (↑↑f - ↑↑g) p μ).toReal
state_after: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f g : ↥(Lp E p μ)
⊢ (eLpNorm (↑↑(f - g)) p μ).toReal = (eLpNorm (↑↑f - ↑↑g) p μ).toReal
tactic: simp_rw [dist, norm_def]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f g : ↥(Lp E p μ)
⊢ (eLpNorm (↑↑(f - g)) p μ).toReal = (eLpNorm (↑↑f - ↑↑g) p μ).toReal
state_after: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f g : ↥(Lp E p μ)
⊢ eLpNorm (↑↑(f - g)) p μ = eLpNorm (↑↑f - ↑↑g) p μ
tactic: refine congr_arg _ ?_
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f g : ↥(Lp E p μ)
⊢ eLpNorm (↑↑(f - g)) p μ = eLpNorm (↑↑f - ↑↑g) p μ
state_after: no goals
tactic: apply eLpNorm_congr_ae (coeFn_sub _ _)