ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CoxeterSystem.wordProd_surjective
File: Mathlib/GroupTheory/Coxeter/Basic.lean

Proof steps:
state_before: B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
⊢ Surjective cs.wordProd
state_after: B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
⊢ ∃ a, cs.wordProd a = w
tactic: intro w
state_before: B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
⊢ ∃ a, cs.wordProd a = w
state_after: case one
B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
⊢ ∃ a, cs.wordProd a = 1

case mul_simple_left
B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
⊢ ∀ (w : W) (i : B), (∃ a, cs.wordProd a = w) → ∃ a, cs.wordProd a = cs.simple i * w
tactic: apply cs.simple_induction_left w
Theorem: lowerClosure_prod
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✝¹ : Preorder α
inst✝ : Preorder β
s : Set α
t : Set β
⊢ lowerClosure (s ×ˢ t) = lowerClosure s ×ˢ lowerClosure t
state_after: case a.h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set α
t : Set β
x✝ : α × β
⊢ x✝ ∈ ↑(lowerClosure (s ×ˢ t)) ↔ x✝ ∈ ↑(lowerClosure s ×ˢ lowerClosure t)
tactic: ext
state_before: case a.h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set α
t : Set β
x✝ : α × β
⊢ x✝ ∈ ↑(lowerClosure (s ×ˢ t)) ↔ x✝ ∈ ↑(lowerClosure s ×ˢ lowerClosure t)
state_after: no goals
tactic: simp [Prod.le_def, @and_and_and_comm _ (_ ∈ t)]
Theorem: ApplicativeTransformation.preserves_map'
File: Mathlib/Control/Traversable/Basic.lean

Proof steps:
state_before: F : Type u → Type v
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
G : Type u → Type w
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α β : Type u
x : α → β
⊢ (fun {α} => η.app α) ∘ Functor.map x = Functor.map x ∘ fun {α} => η.app α
state_after: case h
F : Type u → Type v
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
G : Type u → Type w
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α β : Type u
x : α → β
y : F α
⊢ ((fun {α} => η.app α) ∘ Functor.map x) y = (Functor.map x ∘ fun {α} => η.app α) y
tactic: ext y
state_before: case h
F : Type u → Type v
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
G : Type u → Type w
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α β : Type u
x : α → β
y : F α
⊢ ((fun {α} => η.app α) ∘ Functor.map x) y = (Functor.map x ∘ fun {α} => η.app α) y
state_after: no goals
tactic: exact preserves_map η x y
Theorem: FractionalIdeal.isFractional_of_le
File: Mathlib/RingTheory/FractionalIdeal/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
J : FractionalIdeal S P
hIJ : I ≤ ↑J
⊢ IsFractional S I
state_after: case intro.intro
R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
J : FractionalIdeal S P
hIJ : I ≤ ↑J
a : R
a_mem : a ∈ S
ha : ∀ b ∈ ↑J, IsInteger R (a • b)
⊢ IsFractional S I
tactic: obtain ⟨a, a_mem, ha⟩ := J.isFractional
state_before: case intro.intro
R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
J : FractionalIdeal S P
hIJ : I ≤ ↑J
a : R
a_mem : a ∈ S
ha : ∀ b ∈ ↑J, IsInteger R (a • b)
⊢ IsFractional S I
state_after: case right
R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
J : FractionalIdeal S P
hIJ : I ≤ ↑J
a : R
a_mem : a ∈ S
ha : ∀ b ∈ ↑J, IsInteger R (a • b)
⊢ ∀ b ∈ I, IsInteger R (a • b)
tactic: use a, a_mem
state_before: case right
R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
J : FractionalIdeal S P
hIJ : I ≤ ↑J
a : R
a_mem : a ∈ S
ha : ∀ b ∈ ↑J, IsInteger R (a • b)
⊢ ∀ b ∈ I, IsInteger R (a • b)
state_after: case right
R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
J : FractionalIdeal S P
hIJ : I ≤ ↑J
a : R
a_mem : a ∈ S
ha : ∀ b ∈ ↑J, IsInteger R (a • b)
b : P
b_mem : b ∈ I
⊢ IsInteger R (a • b)
tactic: intro b b_mem
state_before: case right
R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
J : FractionalIdeal S P
hIJ : I ≤ ↑J
a : R
a_mem : a ∈ S
ha : ∀ b ∈ ↑J, IsInteger R (a • b)
b : P
b_mem : b ∈ I
⊢ IsInteger R (a • b)
state_after: no goals
tactic: exact ha b (hIJ b_mem)
Theorem: Nat.multichoose_zero_right
File: Mathlib/Data/Nat/Choose/Basic.lean

Proof steps:
state_before: n : ℕ
⊢ n.multichoose 0 = 1
state_after: no goals
tactic: cases n <;> simp [multichoose]
Theorem: Polynomial.sum_add_index
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a b : R
m n : ℕ
inst✝¹ : Semiring R
p✝ q✝ : R[X]
S : Type u_1
inst✝ : AddCommMonoid S
p q : R[X]
f : ℕ → R → S
hf : ∀ (i : ℕ), f i 0 = 0
h_add : ∀ (a : ℕ) (b₁ b₂ : R), f a (b₁ + b₂) = f a b₁ + f a b₂
⊢ (p + q).sum f = p.sum f + q.sum f
state_after: R : Type u
a b : R
m n : ℕ
inst✝¹ : Semiring R
p✝ q✝ : R[X]
S : Type u_1
inst✝ : AddCommMonoid S
p q : R[X]
f : ℕ → R → S
hf : ∀ (i : ℕ), f i 0 = 0
h_add : ∀ (a : ℕ) (b₁ b₂ : R), f a (b₁ + b₂) = f a b₁ + f a b₂
⊢ { toFinsupp := p.toFinsupp + q.toFinsupp }.sum f = p.sum f + q.sum f
tactic: rw [show p + q = ⟨p.toFinsupp + q.toFinsupp⟩ from add_def p q]
state_before: R : Type u
a b : R
m n : ℕ
inst✝¹ : Semiring R
p✝ q✝ : R[X]
S : Type u_1
inst✝ : AddCommMonoid S
p q : R[X]
f : ℕ → R → S
hf : ∀ (i : ℕ), f i 0 = 0
h_add : ∀ (a : ℕ) (b₁ b₂ : R), f a (b₁ + b₂) = f a b₁ + f a b₂
⊢ { toFinsupp := p.toFinsupp + q.toFinsupp }.sum f = p.sum f + q.sum f
state_after: no goals
tactic: exact Finsupp.sum_add_index (fun i _ ↦ hf i) (fun a _ b₁ b₂ ↦ h_add a b₁ b₂)
Theorem: Filter.Tendsto.atBot_mul_atBot
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : OrderedRing α
l : Filter β
f g : β → α
hf : Tendsto f l atBot
hg : Tendsto g l atBot
⊢ Tendsto (fun x => f x * g x) l atTop
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : OrderedRing α
l : Filter β
f g : β → α
hf : Tendsto f l atBot
hg : Tendsto g l atBot
this : Tendsto (fun x => -f x * -g x) l atTop
⊢ Tendsto (fun x => f x * g x) l atTop
tactic: have : Tendsto (fun x => -f x * -g x) l atTop :=
    (tendsto_neg_atBot_atTop.comp hf).atTop_mul_atTop (tendsto_neg_atBot_atTop.comp hg)
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : OrderedRing α
l : Filter β
f g : β → α
hf : Tendsto f l atBot
hg : Tendsto g l atBot
this : Tendsto (fun x => -f x * -g x) l atTop
⊢ Tendsto (fun x => f x * g x) l atTop
state_after: no goals
tactic: simpa only [neg_mul_neg] using this
Theorem: MvPolynomial.nonTorsionWeight_of
File: Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
σ : Type u_3
inst✝¹ : CanonicallyOrderedAddCommMonoid M
w : σ → M
φ : MvPolynomial σ R
inst✝ : NoZeroSMulDivisors ℕ M
hw : ∀ (i : σ), w i ≠ 0
⊢ NonTorsionWeight w
state_after: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
σ : Type u_3
inst✝¹ : CanonicallyOrderedAddCommMonoid M
w : σ → M
φ : MvPolynomial σ R
inst✝ : NoZeroSMulDivisors ℕ M
hw : ∀ (i : σ), w i ≠ 0
n : ℕ
x : σ
⊢ n • w x = 0 → n = 0
tactic: intro n x
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
σ : Type u_3
inst✝¹ : CanonicallyOrderedAddCommMonoid M
w : σ → M
φ : MvPolynomial σ R
inst✝ : NoZeroSMulDivisors ℕ M
hw : ∀ (i : σ), w i ≠ 0
n : ℕ
x : σ
⊢ n • w x = 0 → n = 0
state_after: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
σ : Type u_3
inst✝¹ : CanonicallyOrderedAddCommMonoid M
w : σ → M
φ : MvPolynomial σ R
inst✝ : NoZeroSMulDivisors ℕ M
hw : ∀ (i : σ), w i ≠ 0
n : ℕ
x : σ
⊢ n = 0 ∨ w x = 0 → n = 0
tactic: rw [smul_eq_zero]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
σ : Type u_3
inst✝¹ : CanonicallyOrderedAddCommMonoid M
w : σ → M
φ : MvPolynomial σ R
inst✝ : NoZeroSMulDivisors ℕ M
hw : ∀ (i : σ), w i ≠ 0
n : ℕ
x : σ
⊢ n = 0 ∨ w x = 0 → n = 0
state_after: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
σ : Type u_3
inst✝¹ : CanonicallyOrderedAddCommMonoid M
w : σ → M
φ : MvPolynomial σ R
inst✝ : NoZeroSMulDivisors ℕ M
hw : ∀ (i : σ), w i ≠ 0
n : ℕ
x : σ
hnx : n = 0 ∨ w x = 0
⊢ n = 0
tactic: intro hnx
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
σ : Type u_3
inst✝¹ : CanonicallyOrderedAddCommMonoid M
w : σ → M
φ : MvPolynomial σ R
inst✝ : NoZeroSMulDivisors ℕ M
hw : ∀ (i : σ), w i ≠ 0
n : ℕ
x : σ
hnx : n = 0 ∨ w x = 0
⊢ n = 0
state_after: case inl
R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
σ : Type u_3
inst✝¹ : CanonicallyOrderedAddCommMonoid M
w : σ → M
φ : MvPolynomial σ R
inst✝ : NoZeroSMulDivisors ℕ M
hw : ∀ (i : σ), w i ≠ 0
n : ℕ
x : σ
hn : n = 0
⊢ n = 0

case inr
R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
σ : Type u_3
inst✝¹ : CanonicallyOrderedAddCommMonoid M
w : σ → M
φ : MvPolynomial σ R
inst✝ : NoZeroSMulDivisors ℕ M
hw : ∀ (i : σ), w i ≠ 0
n : ℕ
x : σ
hx : w x = 0
⊢ n = 0
tactic: cases' hnx with hn hx
Theorem: ContinuousMap.continuousMap_mem_subalgebra_closure_of_separatesPoints
File: Mathlib/Topology/ContinuousFunction/StoneWeierstrass.lean

Proof steps:
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
w : A.SeparatesPoints
f : C(X, ℝ)
⊢ f ∈ A.topologicalClosure
state_after: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
w : A.SeparatesPoints
f : C(X, ℝ)
⊢ f ∈ ⊤
tactic: rw [subalgebra_topologicalClosure_eq_top_of_separatesPoints A w]
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
w : A.SeparatesPoints
f : C(X, ℝ)
⊢ f ∈ ⊤
state_after: no goals
tactic: simp
Theorem: Cardinal.lift_sSup
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
s : Set Cardinal.{u_1}
hs : BddAbove s
⊢ lift.{u, u_1} (sSup s) = sSup (lift.{u, u_1} '' s)
state_after: α β : Type u
s : Set Cardinal.{u_1}
hs : BddAbove s
⊢ ∀ c ∈ upperBounds (lift.{u, u_1} '' s), lift.{u, u_1} (sSup s) ≤ c

α β : Type u
s : Set Cardinal.{u_1}
hs : BddAbove s
⊢ lift.{u, u_1} (sSup s) ∈ upperBounds (lift.{u, u_1} '' s)
tactic: apply ((le_csSup_iff' (bddAbove_image.{_,u} _ hs)).2 fun c hc => _).antisymm (csSup_le' _)
Theorem: WeierstrassCurve.Projective.nonsingular_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Projective.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W : Projective R
inst✝ : Nontrivial R
⊢ W.a₁ * ![0, 1, 0] 1 * ![0, 1, 0] 2 ≠
      3 * ![0, 1, 0] 0 ^ 2 + 2 * W.a₂ * ![0, 1, 0] 0 * ![0, 1, 0] 2 + W.a₄ * ![0, 1, 0] 2 ^ 2 ∨
    ![0, 1, 0] 1 * ![0, 1, 0] 2 ≠
        -![0, 1, 0] 1 * ![0, 1, 0] 2 - W.a₁ * ![0, 1, 0] 0 * ![0, 1, 0] 2 - W.a₃ * ![0, 1, 0] 2 ^ 2 ∨
      ![0, 1, 0] 1 ^ 2 + W.a₁ * ![0, 1, 0] 0 * ![0, 1, 0] 1 + 2 * W.a₃ * ![0, 1, 0] 1 * ![0, 1, 0] 2 ≠
        W.a₂ * ![0, 1, 0] 0 ^ 2 + 2 * W.a₄ * ![0, 1, 0] 0 * ![0, 1, 0] 2 + 3 * W.a₆ * ![0, 1, 0] 2 ^ 2
state_after: no goals
tactic: simp
Theorem: CoxeterSystem.not_isReduced_alternatingWord
File: Mathlib/GroupTheory/Coxeter/Length.lean

Proof steps:
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i i' : B
m : ℕ
hM : M.M i i' ≠ 0
hm : m > M.M i i'
⊢ ¬cs.IsReduced (alternatingWord i i' m)
state_after: case refl
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i i' : B
m : ℕ
hM : M.M i i' ≠ 0
⊢ ¬cs.IsReduced (alternatingWord i i' (M.M i i').succ)

case step
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i i' : B
m✝ : ℕ
hM : M.M i i' ≠ 0
m : ℕ
a✝ : (M.M i i').succ.le m
ih : ¬cs.IsReduced (alternatingWord i i' m)
⊢ ¬cs.IsReduced (alternatingWord i i' m.succ)
tactic: induction' hm with m _ ih
Theorem: Metric.thickening_biUnion
File: Mathlib/Topology/MetricSpace/Thickening.lean

Proof steps:
state_before: ι✝ : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x : α
ι : Type u_2
δ : ℝ
f : ι → Set α
I : Set ι
⊢ thickening δ (⋃ i ∈ I, f i) = ⋃ i ∈ I, thickening δ (f i)
state_after: no goals
tactic: simp only [thickening_iUnion]
Theorem: CategoryTheory.Limits.Multifork.ofι_π_app
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
I✝ : MulticospanIndex C
K : Multifork I✝
I : MulticospanIndex C
P : C
ι : (a : I.L) → P ⟶ I.left a
w : ∀ (b : I.R), ι (I.fstTo b) ≫ I.fst b = ι (I.sndTo b) ≫ I.snd b
⊢ ∀ ⦃X Y : WalkingMulticospan I.fstTo I.sndTo⦄ (f : X ⟶ Y),
    ((Functor.const (WalkingMulticospan I.fstTo I.sndTo)).obj P).map f ≫
        (fun x =>
            match x with
            | WalkingMulticospan.left a => ι a
            | WalkingMulticospan.right b => ι (I.fstTo b) ≫ I.fst b)
          Y =
      (fun x =>
            match x with
            | WalkingMulticospan.left a => ι a
            | WalkingMulticospan.right b => ι (I.fstTo b) ≫ I.fst b)
          X ≫
        I.multicospan.map f
state_after: case left.right.snd
C : Type u
inst✝ : Category.{v, u} C
I✝ : MulticospanIndex C
K : Multifork I✝
I : MulticospanIndex C
P : C
ι : (a : I.L) → P ⟶ I.left a
w : ∀ (b : I.R), ι (I.fstTo b) ≫ I.fst b = ι (I.sndTo b) ≫ I.snd b
a✝ : I.R
⊢ ι (I.fstTo a✝) ≫ I.fst a✝ = ι (I.sndTo a✝) ≫ I.snd a✝
tactic: rintro (_ | _) (_ | _) (_ | _ | _) <;>
          dsimp <;> simp
state_before: case left.right.snd
C : Type u
inst✝ : Category.{v, u} C
I✝ : MulticospanIndex C
K : Multifork I✝
I : MulticospanIndex C
P : C
ι : (a : I.L) → P ⟶ I.left a
w : ∀ (b : I.R), ι (I.fstTo b) ≫ I.fst b = ι (I.sndTo b) ≫ I.snd b
a✝ : I.R
⊢ ι (I.fstTo a✝) ≫ I.fst a✝ = ι (I.sndTo a✝) ≫ I.snd a✝
state_after: no goals
tactic: apply w
Theorem: Submodule.prodEquivOfIsCompl_symm_apply_right
File: Mathlib/LinearAlgebra/Projection.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
p q : Submodule R E
S : Type u_5
inst✝² : Semiring S
M : Type u_6
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
h : IsCompl p q
x : ↥q
⊢ ↑x = (p.prodEquivOfIsCompl q h) (0, x)
state_after: no goals
tactic: simp
Theorem: ContDiffAt.real_of_complex
File: Mathlib/Analysis/Complex/RealDeriv.lean

Proof steps:
state_before: e : ℂ → ℂ
e' : ℂ
z : ℝ
n : ℕ∞
h : ContDiffAt ℂ n e ↑z
⊢ ContDiffAt ℝ n (fun x => (e ↑x).re) z
state_after: e : ℂ → ℂ
e' : ℂ
z : ℝ
n : ℕ∞
h : ContDiffAt ℂ n e ↑z
A : ContDiffAt ℝ n ofReal' z
⊢ ContDiffAt ℝ n (fun x => (e ↑x).re) z
tactic: have A : ContDiffAt ℝ n ((↑) : ℝ → ℂ) z := ofRealCLM.contDiff.contDiffAt
state_before: e : ℂ → ℂ
e' : ℂ
z : ℝ
n : ℕ∞
h : ContDiffAt ℂ n e ↑z
A : ContDiffAt ℝ n ofReal' z
⊢ ContDiffAt ℝ n (fun x => (e ↑x).re) z
state_after: e : ℂ → ℂ
e' : ℂ
z : ℝ
n : ℕ∞
h : ContDiffAt ℂ n e ↑z
A : ContDiffAt ℝ n ofReal' z
B : ContDiffAt ℝ n e ↑z
⊢ ContDiffAt ℝ n (fun x => (e ↑x).re) z
tactic: have B : ContDiffAt ℝ n e z := h.restrict_scalars ℝ
state_before: e : ℂ → ℂ
e' : ℂ
z : ℝ
n : ℕ∞
h : ContDiffAt ℂ n e ↑z
A : ContDiffAt ℝ n ofReal' z
B : ContDiffAt ℝ n e ↑z
⊢ ContDiffAt ℝ n (fun x => (e ↑x).re) z
state_after: e : ℂ → ℂ
e' : ℂ
z : ℝ
n : ℕ∞
h : ContDiffAt ℂ n e ↑z
A : ContDiffAt ℝ n ofReal' z
B : ContDiffAt ℝ n e ↑z
C : ContDiffAt ℝ n re (e ↑z)
⊢ ContDiffAt ℝ n (fun x => (e ↑x).re) z
tactic: have C : ContDiffAt ℝ n re (e z) := reCLM.contDiff.contDiffAt
state_before: e : ℂ → ℂ
e' : ℂ
z : ℝ
n : ℕ∞
h : ContDiffAt ℂ n e ↑z
A : ContDiffAt ℝ n ofReal' z
B : ContDiffAt ℝ n e ↑z
C : ContDiffAt ℝ n re (e ↑z)
⊢ ContDiffAt ℝ n (fun x => (e ↑x).re) z
state_after: no goals
tactic: exact C.comp z (B.comp z A)
Theorem: LinearMap.polyCharpoly_coeff_eq_zero_iff_of_basis
File: Mathlib/Algebra/Module/LinearMap/Polynomial.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
M : Type u_3
n : Type u_4
ι : Type u_5
ι' : Type u_6
ιM : Type u_7
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup L
inst✝⁹ : Module R L
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
φ : L →ₗ[R] Module.End R M
inst✝⁶ : Fintype ι
inst✝⁵ : Fintype ι'
inst✝⁴ : Fintype ιM
inst✝³ : DecidableEq ι
inst✝² : DecidableEq ι'
inst✝¹ : Module.Free R M
inst✝ : Module.Finite R M
b✝ b : Basis ι R L
b' : Basis ι' R L
k : ℕ
⊢ (φ.polyCharpoly b).coeff k = 0 ↔ (φ.polyCharpoly b').coeff k = 0
state_after: no goals
tactic: constructor <;> apply polyCharpoly_coeff_eq_zero_of_basis
Theorem: neg_le_iff_add_nonneg
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ a⁻¹ * a ≤ b * a ↔ 1 ≤ b * a
state_after: no goals
tactic: rw [inv_mul_self]
Theorem: EMetric.preimage_mul_right_ball
File: Mathlib/Topology/MetricSpace/IsometricSMul.lean

Proof steps:
state_before: M : Type u
G : Type v
X : Type w
inst✝⁵ : PseudoEMetricSpace X
inst✝⁴ : Group G
inst✝³ : MulAction G X
inst✝² : IsometricSMul G X
inst✝¹ : PseudoEMetricSpace G
inst✝ : IsometricSMul Gᵐᵒᵖ G
a b : G
r : ℝ≥0∞
⊢ (fun x => x * a) ⁻¹' ball b r = ball (b / a) r
state_after: M : Type u
G : Type v
X : Type w
inst✝⁵ : PseudoEMetricSpace X
inst✝⁴ : Group G
inst✝³ : MulAction G X
inst✝² : IsometricSMul G X
inst✝¹ : PseudoEMetricSpace G
inst✝ : IsometricSMul Gᵐᵒᵖ G
a b : G
r : ℝ≥0∞
⊢ (fun x => x * a) ⁻¹' ball b r = ball (b * a⁻¹) r
tactic: rw [div_eq_mul_inv]
state_before: M : Type u
G : Type v
X : Type w
inst✝⁵ : PseudoEMetricSpace X
inst✝⁴ : Group G
inst✝³ : MulAction G X
inst✝² : IsometricSMul G X
inst✝¹ : PseudoEMetricSpace G
inst✝ : IsometricSMul Gᵐᵒᵖ G
a b : G
r : ℝ≥0∞
⊢ (fun x => x * a) ⁻¹' ball b r = ball (b * a⁻¹) r
state_after: no goals
tactic: exact preimage_smul_ball (MulOpposite.op a) b r
Theorem: groupCohomology.resolution.diagonalSucc_inv_single_left
File: Mathlib/RepresentationTheory/GroupCohomology/Resolution.lean

Proof steps:
state_before: k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Group G
g : G
f : (Fin n → G) →₀ k
r : k
⊢ (diagonalSucc k G n).inv.hom (single g r ⊗ₜ[k] f) =
    ((Finsupp.lift ((Fin (n + 1) → G) →₀ k) k (Fin n → G)) fun f => single (g • partialProd f) r) f
state_after: case refine_1
k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Group G
g : G
f : (Fin n → G) →₀ k
r : k
⊢ (diagonalSucc k G n).inv.hom (single g r ⊗ₜ[k] 0) =
    ((Finsupp.lift ((Fin (n + 1) → G) →₀ k) k (Fin n → G)) fun f => single (g • partialProd f) r) 0

case refine_2
k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Group G
g : G
f : (Fin n → G) →₀ k
r : k
⊢ ∀ (a : Fin n → G) (b : k) (f : (Fin n → G) →₀ k),
    a ∉ f.support →
      b ≠ 0 →
        (diagonalSucc k G n).inv.hom (single g r ⊗ₜ[k] f) =
            ((Finsupp.lift ((Fin (n + 1) → G) →₀ k) k (Fin n → G)) fun f => single (g • partialProd f) r) f →
          (diagonalSucc k G n).inv.hom (single g r ⊗ₜ[k] (single a b + f)) =
            ((Finsupp.lift ((Fin (n + 1) → G) →₀ k) k (Fin n → G)) fun f => single (g • partialProd f) r)
              (single a b + f)
tactic: refine f.induction ?_ ?_
Theorem: LowerSet.coe_iInf
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 (LowerSet α)
s t : LowerSet α
a : α
f : ι → LowerSet α
⊢ ↑(⨅ i, f i) = ⋂ i, ↑(f i)
state_after: no goals
tactic: simp_rw [iInf, coe_sInf, mem_range, iInter_exists, iInter_iInter_eq']
Theorem: IsPiSystem.pi
File: Mathlib/MeasureTheory/Constructions/Pi.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
C : (i : ι) → Set (Set (α i))
hC : ∀ (i : ι), IsPiSystem (C i)
⊢ IsPiSystem (univ.pi '' univ.pi C)
state_after: case intro.intro.intro.intro
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
C : (i : ι) → Set (Set (α i))
hC : ∀ (i : ι), IsPiSystem (C i)
s₁ : (i : ι) → Set (α i)
hs₁ : s₁ ∈ univ.pi C
s₂ : (i : ι) → Set (α i)
hs₂ : s₂ ∈ univ.pi C
hst : (univ.pi s₁ ∩ univ.pi s₂).Nonempty
⊢ univ.pi s₁ ∩ univ.pi s₂ ∈ univ.pi '' univ.pi C
tactic: rintro _ ⟨s₁, hs₁, rfl⟩ _ ⟨s₂, hs₂, rfl⟩ hst
state_before: case intro.intro.intro.intro
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
C : (i : ι) → Set (Set (α i))
hC : ∀ (i : ι), IsPiSystem (C i)
s₁ : (i : ι) → Set (α i)
hs₁ : s₁ ∈ univ.pi C
s₂ : (i : ι) → Set (α i)
hs₂ : s₂ ∈ univ.pi C
hst : (univ.pi s₁ ∩ univ.pi s₂).Nonempty
⊢ univ.pi s₁ ∩ univ.pi s₂ ∈ univ.pi '' univ.pi C
state_after: case intro.intro.intro.intro
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
C : (i : ι) → Set (Set (α i))
hC : ∀ (i : ι), IsPiSystem (C i)
s₁ : (i : ι) → Set (α i)
hs₁ : s₁ ∈ univ.pi C
s₂ : (i : ι) → Set (α i)
hs₂ : s₂ ∈ univ.pi C
hst : (univ.pi fun i => s₁ i ∩ s₂ i).Nonempty
⊢ (univ.pi fun i => s₁ i ∩ s₂ i) ∈ univ.pi '' univ.pi C
tactic: rw [← pi_inter_distrib] at hst ⊢
state_before: case intro.intro.intro.intro
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
C : (i : ι) → Set (Set (α i))
hC : ∀ (i : ι), IsPiSystem (C i)
s₁ : (i : ι) → Set (α i)
hs₁ : s₁ ∈ univ.pi C
s₂ : (i : ι) → Set (α i)
hs₂ : s₂ ∈ univ.pi C
hst : (univ.pi fun i => s₁ i ∩ s₂ i).Nonempty
⊢ (univ.pi fun i => s₁ i ∩ s₂ i) ∈ univ.pi '' univ.pi C
state_after: case intro.intro.intro.intro
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
C : (i : ι) → Set (Set (α i))
hC : ∀ (i : ι), IsPiSystem (C i)
s₁ : (i : ι) → Set (α i)
hs₁ : s₁ ∈ univ.pi C
s₂ : (i : ι) → Set (α i)
hs₂ : s₂ ∈ univ.pi C
hst : ∀ (i : ι), (s₁ i ∩ s₂ i).Nonempty
⊢ (univ.pi fun i => s₁ i ∩ s₂ i) ∈ univ.pi '' univ.pi C
tactic: rw [univ_pi_nonempty_iff] at hst
state_before: case intro.intro.intro.intro
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
C : (i : ι) → Set (Set (α i))
hC : ∀ (i : ι), IsPiSystem (C i)
s₁ : (i : ι) → Set (α i)
hs₁ : s₁ ∈ univ.pi C
s₂ : (i : ι) → Set (α i)
hs₂ : s₂ ∈ univ.pi C
hst : ∀ (i : ι), (s₁ i ∩ s₂ i).Nonempty
⊢ (univ.pi fun i => s₁ i ∩ s₂ i) ∈ univ.pi '' univ.pi C
state_after: no goals
tactic: exact mem_image_of_mem _ fun i _ => hC i _ (hs₁ i (mem_univ i)) _ (hs₂ i (mem_univ i)) (hst i)
Theorem: Filter.tendsto_pow_atTop_iff
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : LinearOrderedSemiring α
l : Filter β
f : β → α
n : ℕ
h : Tendsto (fun x => x ^ n) atTop atTop
hn : n = 0
⊢ False
state_after: no goals
tactic: simp only [hn, pow_zero, not_tendsto_const_atTop] at h
Theorem: MeasureTheory.Measure.rnDeriv_withDensity₀
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν✝ ν : Measure α
inst✝ : SigmaFinite ν
f : α → ℝ≥0∞
hf : AEMeasurable f ν
⊢ ν.withDensity f = 0 + ν.withDensity f
state_after: no goals
tactic: rw [zero_add]
Theorem: CategoryTheory.Subobject.ofMkLEMk_refl
File: Mathlib/CategoryTheory/Subobject/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
B A₁ : C
f : A₁ ⟶ B
inst✝ : Mono f
⊢ ofMkLEMk f f ⋯ = 𝟙 A₁
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
B A₁ : C
f : A₁ ⟶ B
inst✝ : Mono f
⊢ ofMkLEMk f f ⋯ ≫ f = 𝟙 A₁ ≫ f
tactic: apply (cancel_mono f).mp
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
B A₁ : C
f : A₁ ⟶ B
inst✝ : Mono f
⊢ ofMkLEMk f f ⋯ ≫ f = 𝟙 A₁ ≫ f
state_after: no goals
tactic: simp