ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Nat.succ_mul_choose_eq
File: Mathlib/Data/Nat/Choose/Basic.lean

Proof steps:
state_before: ⊢ succ 0 * choose 0 0 = (succ 0).choose (succ 0) * succ 0
state_after: no goals
tactic: decide
state_before: k : ℕ
⊢ succ 0 * choose 0 (k + 1) = (succ 0).choose (k + 1).succ * (k + 1).succ
state_after: no goals
tactic: simp [choose]
state_before: n : ℕ
⊢ (n + 1).succ * (n + 1).choose 0 = (n + 1).succ.choose (succ 0) * succ 0
state_after: no goals
tactic: simp [choose, mul_succ, Nat.add_comm]
state_before: n k : ℕ
⊢ (n + 1).succ * (n + 1).choose (k + 1) = (n + 1).succ.choose (k + 1).succ * (k + 1).succ
state_after: no goals
tactic: rw [choose_succ_succ (succ n) (succ k), Nat.add_mul, ← succ_mul_choose_eq n, mul_succ, ←
      succ_mul_choose_eq n, Nat.add_right_comm, ← Nat.mul_add, ← choose_succ_succ, ← succ_mul]
Theorem: Nat.even_sub
File: Mathlib/Algebra/Group/Nat.lean

Proof steps:
state_before: m n : ℕ
h : n ≤ m
⊢ Even (m - n) ↔ (Even m ↔ Even n)
state_after: m n : ℕ
h : n ≤ m
⊢ Even (m - n) ↔ ((Even (m - n) ↔ Even n) ↔ Even n)
tactic: conv_rhs => rw [← Nat.sub_add_cancel h, even_add]
state_before: m n : ℕ
h : n ≤ m
⊢ Even (m - n) ↔ ((Even (m - n) ↔ Even n) ↔ Even n)
state_after: no goals
tactic: by_cases h : Even n <;> simp [h]
Theorem: Real.toNNReal_lt_iff_lt_coe
File: Mathlib/Data/NNReal/Basic.lean

Proof steps:
state_before: r : ℝ
p : ℝ≥0
ha : 0 ≤ r
⊢ r.toNNReal < p ↔ r < ↑p
state_after: no goals
tactic: rw [← NNReal.coe_lt_coe, Real.coe_toNNReal r ha]
Theorem: Filter.tendsto_lift'
File: Mathlib/Order/Filter/Lift.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f f₁ f₂ : Filter α
h h₁ h₂ : Set α → Set β
m : γ → β
l : Filter γ
⊢ Tendsto m l (f.lift' h) ↔ ∀ s ∈ f, ∀ᶠ (a : γ) in l, m a ∈ h s
state_after: no goals
tactic: simp only [Filter.lift', tendsto_lift, tendsto_principal, comp]
Theorem: Submonoid.mem_sSup_of_directedOn
File: Mathlib/Algebra/Group/Submonoid/Membership.lean

Proof steps:
state_before: M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : MulOneClass M
S : Set (Submonoid M)
Sne : S.Nonempty
hS : DirectedOn (fun x x_1 => x ≤ x_1) S
x : M
⊢ x ∈ sSup S ↔ ∃ s ∈ S, x ∈ s
state_after: M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : MulOneClass M
S : Set (Submonoid M)
Sne : S.Nonempty
hS : DirectedOn (fun x x_1 => x ≤ x_1) S
x : M
this : Nonempty ↑S
⊢ x ∈ sSup S ↔ ∃ s ∈ S, x ∈ s
tactic: haveI : Nonempty S := Sne.to_subtype
state_before: M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : MulOneClass M
S : Set (Submonoid M)
Sne : S.Nonempty
hS : DirectedOn (fun x x_1 => x ≤ x_1) S
x : M
this : Nonempty ↑S
⊢ x ∈ sSup S ↔ ∃ s ∈ S, x ∈ s
state_after: no goals
tactic: simp [sSup_eq_iSup', mem_iSup_of_directed hS.directed_val, SetCoe.exists, Subtype.coe_mk]
Theorem: Asymptotics.isLittleO_norm_left
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 α
u v : α → ℝ
⊢ (fun x => ‖f' x‖) =o[l] g ↔ f' =o[l] g
state_after: α : 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 α
u v : α → ℝ
⊢ (∀ ⦃c : ℝ⦄, 0 < c → IsBigOWith c l (fun x => ‖f' x‖) g) ↔ ∀ ⦃c : ℝ⦄, 0 < c → IsBigOWith c l f' g
tactic: simp only [IsLittleO_def]
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 α
u v : α → ℝ
⊢ (∀ ⦃c : ℝ⦄, 0 < c → IsBigOWith c l (fun x => ‖f' x‖) g) ↔ ∀ ⦃c : ℝ⦄, 0 < c → IsBigOWith c l f' g
state_after: no goals
tactic: exact forall₂_congr fun _ _ => isBigOWith_norm_left
Theorem: Matrix.vecHead_vecAlt1
File: Mathlib/Data/Fin/VecNotation.lean

Proof steps:
state_before: α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
hm : m + 2 = n + 1 + (n + 1)
v : Fin (m + 2) → α
⊢ vecHead (vecAlt1 hm v) = v 1
state_after: no goals
tactic: simp [vecHead, vecAlt1]
Theorem: Nat.mod_mul_mod
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a✝ b✝ c✝ d m n k : ℕ
p q : ℕ → Prop
a b c : ℕ
⊢ a % c * b % c = a * b % c
state_after: no goals
tactic: rw [mul_mod, mod_mod, ← mul_mod]
Theorem: MeasureTheory.Integrable.edist_toL1_zero
File: Mathlib/MeasureTheory/Function/L1Space.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
hf : Integrable f μ
⊢ edist (toL1 f hf) 0 = ∫⁻ (a : α), edist (f a) 0 ∂μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
hf : Integrable f μ
⊢ (if 1 = ⊤ then eLpNormEssSup f μ else ∫⁻ (a : α), ↑‖f a‖₊ ∂μ) = ∫⁻ (a : α), edist (f a) 0 ∂μ
tactic: simp only [toL1, Lp.edist_toLp_zero, eLpNorm, one_ne_zero, eLpNorm', one_toReal, ENNReal.rpow_one,
    ne_eq, not_false_eq_true, div_self, ite_false]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
hf : Integrable f μ
⊢ (if 1 = ⊤ then eLpNormEssSup f μ else ∫⁻ (a : α), ↑‖f a‖₊ ∂μ) = ∫⁻ (a : α), edist (f a) 0 ∂μ
state_after: no goals
tactic: simp [edist_eq_coe_nnnorm]
Theorem: Set.EqOn.of_subset_closure
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : FirstCountableTopology X
Z : Type u_3
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : T2Space Y
s t : Set X
f g : X → Y
h : EqOn f g s
hf : ContinuousOn f t
hg : ContinuousOn g t
hst : s ⊆ t
hts : t ⊆ closure s
⊢ EqOn f g t
state_after: X : Type u_1
Y : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : FirstCountableTopology X
Z : Type u_3
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : T2Space Y
s t : Set X
f g : X → Y
h : EqOn f g s
hf : ContinuousOn f t
hg : ContinuousOn g t
hst : s ⊆ t
hts : t ⊆ closure s
x : X
hx : x ∈ t
⊢ f x = g x
tactic: intro x hx
state_before: X : Type u_1
Y : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : FirstCountableTopology X
Z : Type u_3
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : T2Space Y
s t : Set X
f g : X → Y
h : EqOn f g s
hf : ContinuousOn f t
hg : ContinuousOn g t
hst : s ⊆ t
hts : t ⊆ closure s
x : X
hx : x ∈ t
⊢ f x = g x
state_after: X : Type u_1
Y : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : FirstCountableTopology X
Z : Type u_3
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : T2Space Y
s t : Set X
f g : X → Y
h : EqOn f g s
hf : ContinuousOn f t
hg : ContinuousOn g t
hst : s ⊆ t
hts : t ⊆ closure s
x : X
hx : x ∈ t
this : (𝓝[s] x).NeBot
⊢ f x = g x
tactic: have : (𝓝[s] x).NeBot := mem_closure_iff_clusterPt.mp (hts hx)
state_before: X : Type u_1
Y : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : FirstCountableTopology X
Z : Type u_3
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : T2Space Y
s t : Set X
f g : X → Y
h : EqOn f g s
hf : ContinuousOn f t
hg : ContinuousOn g t
hst : s ⊆ t
hts : t ⊆ closure s
x : X
hx : x ∈ t
this : (𝓝[s] x).NeBot
⊢ f x = g x
state_after: no goals
tactic: exact
    tendsto_nhds_unique_of_eventuallyEq ((hf x hx).mono_left <| nhdsWithin_mono _ hst)
      ((hg x hx).mono_left <| nhdsWithin_mono _ hst) (h.eventuallyEq_of_mem self_mem_nhdsWithin)
Theorem: nhdsWithin_inter
File: Mathlib/Topology/ContinuousOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : TopologicalSpace α
a : α
s t : Set α
⊢ 𝓝[s ∩ t] a = 𝓝[s] a ⊓ 𝓝[t] a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : TopologicalSpace α
a : α
s t : Set α
⊢ 𝓝 a ⊓ 𝓟 (s ∩ t) = 𝓝 a ⊓ 𝓟 s ⊓ (𝓝 a ⊓ 𝓟 t)
tactic: delta nhdsWithin
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : TopologicalSpace α
a : α
s t : Set α
⊢ 𝓝 a ⊓ 𝓟 (s ∩ t) = 𝓝 a ⊓ 𝓟 s ⊓ (𝓝 a ⊓ 𝓟 t)
state_after: no goals
tactic: rw [inf_left_comm, inf_assoc, inf_principal, ← inf_assoc, inf_idem]
Theorem: Multiset.pow_count
File: Mathlib/Algebra/BigOperators/Group/Multiset.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
s t : Multiset α
a✝ : α
m : Multiset ι
f g : ι → α
inst✝ : DecidableEq α
a : α
⊢ a ^ count a s = (filter (Eq a) s).prod
state_after: no goals
tactic: rw [filter_eq, prod_replicate]
Theorem: List.unzip_zip_left
File: Mathlib/Data/List/Zip.lean

Proof steps:
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
l₁ : List α
h : l₁.length ≤ [].length
⊢ (l₁.zip []).unzip.1 = l₁
state_after: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
l₁ : List α
h : l₁.length ≤ [].length
⊢ ([].zip []).unzip.1 = []
tactic: rw [eq_nil_of_length_eq_zero (Nat.eq_zero_of_le_zero h)]
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
l₁ : List α
h : l₁.length ≤ [].length
⊢ ([].zip []).unzip.1 = []
state_after: no goals
tactic: rfl
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
a : α
l₁ : List α
b : β
l₂ : List β
h : (a :: l₁).length ≤ (b :: l₂).length
⊢ ((a :: l₁).zip (b :: l₂)).unzip.1 = a :: l₁
state_after: no goals
tactic: simp only [zip_cons_cons, unzip_cons, unzip_zip_left (le_of_succ_le_succ h)]
Theorem: fermatLastTheoremThree
File: Mathlib/NumberTheory/FLT/Three.lean

Proof steps:
state_before: ⊢ FermatLastTheoremFor 3
state_after: no goals
tactic: classical
  let K := CyclotomicField 3 ℚ
  let hζ := IsCyclotomicExtension.zeta_spec 3 ℚ K
  have : NumberField K := IsCyclotomicExtension.numberField {3} ℚ _
  apply FermatLastTheoremForThree_of_FermatLastTheoremThreeGen hζ
  intro a b c u hc ha hb hcdvd coprime H
  let S' : FermatLastTheoremForThreeGen.Solution' hζ :=
  { a := a
    b := b
    c := c
    u := u
    ha := ha
    hb := hb
    hc := hc
    coprime := coprime
    hcdvd := hcdvd
    H := H }
  obtain ⟨S, -⟩ := FermatLastTheoremForThreeGen.exists_Solution_of_Solution' S'
  obtain ⟨Smin, hSmin⟩ := S.exists_minimal
  obtain ⟨Sfin, hSfin⟩ := Smin.exists_Solution_multiplicity_lt
  linarith [hSmin Sfin]
Theorem: FreeAddMonoid.count_of
File: Mathlib/Algebra/FreeMonoid/Count.lean

Proof steps:
state_before: α : Type u_1
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidableEq α
x y : α
⊢ (count x) (of y) = Pi.single x 1 y
state_after: no goals
tactic: simp [Pi.single, Function.update, count, countP, List.countP, List.countP.go,
    Bool.beq_eq_decide_eq]
Theorem: AddMonoid.nsmul_eq_mod_exponent
File: Mathlib/GroupTheory/Exponent.lean

Proof steps:
state_before: G : Type u
inst✝ : Monoid G
n : ℕ
g : G
⊢ g ^ n = g ^ (n % exponent G + exponent G * (n / exponent G))
state_after: no goals
tactic: rw [Nat.mod_add_div]
state_before: G : Type u
inst✝ : Monoid G
n : ℕ
g : G
⊢ g ^ (n % exponent G + exponent G * (n / exponent G)) = g ^ (n % exponent G)
state_after: no goals
tactic: simp [pow_add, pow_mul, pow_exponent_eq_one]
Theorem: FirstOrder.Language.card_eq_card_functions_add_card_relations
File: Mathlib/ModelTheory/Basic.lean

Proof steps:
state_before: L : Language
L' : Language
⊢ L.card = (sum fun l => lift.{v, u} #(L.Functions l)) + sum fun l => lift.{u, v} #(L.Relations l)
state_after: no goals
tactic: simp [card, Symbols]
Theorem: Nat.factorization_eq_zero_of_remainder
File: Mathlib/Data/Nat/Factorization/Defs.lean

Proof steps:
state_before: a b m n p✝ p r i : ℕ
hr : ¬p ∣ r
⊢ (p * i + r).factorization p = 0
state_after: case h
a b m n p✝ p r i : ℕ
hr : ¬p ∣ r
⊢ ¬p ∣ p * i + r
tactic: apply factorization_eq_zero_of_not_dvd
state_before: case h
a b m n p✝ p r i : ℕ
hr : ¬p ∣ r
⊢ ¬p ∣ p * i + r
state_after: no goals
tactic: rwa [← Nat.dvd_add_iff_right (Dvd.intro i rfl)]
Theorem: CategoryTheory.Under.UnderMorphism.ext
File: Mathlib/CategoryTheory/Comma/Over.lean

Proof steps:
state_before: T : Type u₁
inst✝ : Category.{v₁, u₁} T
X✝ X : T
U V : Under X
f g : U ⟶ V
h : f.right = g.right
⊢ f = g
state_after: T : Type u₁
inst✝ : Category.{v₁, u₁} T
X✝ X : T
U V : Under X
f g : U ⟶ V
left✝ : U.left ⟶ V.left
b : U.right ⟶ V.right
w✝ : (Functor.fromPUnit X).map left✝ ≫ V.hom = U.hom ≫ (𝟭 T).map b
h : { left := left✝, right := b, w := w✝ }.right = g.right
⊢ { left := left✝, right := b, w := w✝ } = g
tactic: let ⟨_,b,_⟩ := f
state_before: T : Type u₁
inst✝ : Category.{v₁, u₁} T
X✝ X : T
U V : Under X
f g : U ⟶ V
left✝ : U.left ⟶ V.left
b : U.right ⟶ V.right
w✝ : (Functor.fromPUnit X).map left✝ ≫ V.hom = U.hom ≫ (𝟭 T).map b
h : { left := left✝, right := b, w := w✝ }.right = g.right
⊢ { left := left✝, right := b, w := w✝ } = g
state_after: T : Type u₁
inst✝ : Category.{v₁, u₁} T
X✝ X : T
U V : Under X
f g : U ⟶ V
left✝¹ : U.left ⟶ V.left
b : U.right ⟶ V.right
w✝¹ : (Functor.fromPUnit X).map left✝¹ ≫ V.hom = U.hom ≫ (𝟭 T).map b
left✝ : U.left ⟶ V.left
e : U.right ⟶ V.right
w✝ : (Functor.fromPUnit X).map left✝ ≫ V.hom = U.hom ≫ (𝟭 T).map e
h : { left := left✝¹, right := b, w := w✝¹ }.right = { left := left✝, right := e, w := w✝ }.right
⊢ { left := left✝¹, right := b, w := w✝¹ } = { left := left✝, right := e, w := w✝ }
tactic: let ⟨_,e,_⟩ := g
state_before: T : Type u₁
inst✝ : Category.{v₁, u₁} T
X✝ X : T
U V : Under X
f g : U ⟶ V
left✝¹ : U.left ⟶ V.left
b : U.right ⟶ V.right
w✝¹ : (Functor.fromPUnit X).map left✝¹ ≫ V.hom = U.hom ≫ (𝟭 T).map b
left✝ : U.left ⟶ V.left
e : U.right ⟶ V.right
w✝ : (Functor.fromPUnit X).map left✝ ≫ V.hom = U.hom ≫ (𝟭 T).map e
h : { left := left✝¹, right := b, w := w✝¹ }.right = { left := left✝, right := e, w := w✝ }.right
⊢ { left := left✝¹, right := b, w := w✝¹ } = { left := left✝, right := e, w := w✝ }
state_after: case e_left
T : Type u₁
inst✝ : Category.{v₁, u₁} T
X✝ X : T
U V : Under X
f g : U ⟶ V
left✝¹ : U.left ⟶ V.left
b : U.right ⟶ V.right
w✝¹ : (Functor.fromPUnit X).map left✝¹ ≫ V.hom = U.hom ≫ (𝟭 T).map b
left✝ : U.left ⟶ V.left
e : U.right ⟶ V.right
w✝ : (Functor.fromPUnit X).map left✝ ≫ V.hom = U.hom ≫ (𝟭 T).map e
h : { left := left✝¹, right := b, w := w✝¹ }.right = { left := left✝, right := e, w := w✝ }.right
⊢ left✝¹ = left✝
tactic: congr
state_before: case e_left
T : Type u₁
inst✝ : Category.{v₁, u₁} T
X✝ X : T
U V : Under X
f g : U ⟶ V
left✝¹ : U.left ⟶ V.left
b : U.right ⟶ V.right
w✝¹ : (Functor.fromPUnit X).map left✝¹ ≫ V.hom = U.hom ≫ (𝟭 T).map b
left✝ : U.left ⟶ V.left
e : U.right ⟶ V.right
w✝ : (Functor.fromPUnit X).map left✝ ≫ V.hom = U.hom ≫ (𝟭 T).map e
h : { left := left✝¹, right := b, w := w✝¹ }.right = { left := left✝, right := e, w := w✝ }.right
⊢ left✝¹ = left✝
state_after: no goals
tactic: simp only [eq_iff_true_of_subsingleton]
Theorem: ContinuousMap.tendsto_of_tendstoLocallyUniformly
File: Mathlib/Topology/UniformSpace/CompactConvergence.lean

Proof steps:
state_before: α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
ι : Type u₃
p : Filter ι
F : ι → C(α, β)
h : TendstoLocallyUniformly (fun i a => (F i) a) (⇑f) p
⊢ Tendsto F p (𝓝 f)
state_after: α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
ι : Type u₃
p : Filter ι
F : ι → C(α, β)
h : TendstoLocallyUniformly (fun i a => (F i) a) (⇑f) p
⊢ ∀ (K : Set α), IsCompact K → TendstoUniformlyOn (fun i a => (F i) a) (⇑f) p K
tactic: rw [tendsto_iff_forall_compact_tendstoUniformlyOn]
state_before: α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
ι : Type u₃
p : Filter ι
F : ι → C(α, β)
h : TendstoLocallyUniformly (fun i a => (F i) a) (⇑f) p
⊢ ∀ (K : Set α), IsCompact K → TendstoUniformlyOn (fun i a => (F i) a) (⇑f) p K
state_after: α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K✝ : Set α
V : Set (β × β)
f : C(α, β)
ι : Type u₃
p : Filter ι
F : ι → C(α, β)
h : TendstoLocallyUniformly (fun i a => (F i) a) (⇑f) p
K : Set α
hK : IsCompact K
⊢ TendstoUniformlyOn (fun i a => (F i) a) (⇑f) p K
tactic: intro K hK
state_before: α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K✝ : Set α
V : Set (β × β)
f : C(α, β)
ι : Type u₃
p : Filter ι
F : ι → C(α, β)
h : TendstoLocallyUniformly (fun i a => (F i) a) (⇑f) p
K : Set α
hK : IsCompact K
⊢ TendstoUniformlyOn (fun i a => (F i) a) (⇑f) p K
state_after: α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K✝ : Set α
V : Set (β × β)
f : C(α, β)
ι : Type u₃
p : Filter ι
F : ι → C(α, β)
h : TendstoLocallyUniformly (fun i a => (F i) a) (⇑f) p
K : Set α
hK : IsCompact K
⊢ TendstoLocallyUniformlyOn (fun i a => (F i) a) (⇑f) p K
tactic: rw [← tendstoLocallyUniformlyOn_iff_tendstoUniformlyOn_of_compact hK]
state_before: α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K✝ : Set α
V : Set (β × β)
f : C(α, β)
ι : Type u₃
p : Filter ι
F : ι → C(α, β)
h : TendstoLocallyUniformly (fun i a => (F i) a) (⇑f) p
K : Set α
hK : IsCompact K
⊢ TendstoLocallyUniformlyOn (fun i a => (F i) a) (⇑f) p K
state_after: no goals
tactic: exact h.tendstoLocallyUniformlyOn
Theorem: FiniteDimensional.finrank_eq_zero_of_rank_eq_zero
File: Mathlib/LinearAlgebra/Dimension/Finite.lean

Proof steps:
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : Nontrivial R
inst✝ : NoZeroSMulDivisors R M
h : Module.rank R M = 0
⊢ finrank R M = 0
state_after: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : Nontrivial R
inst✝ : NoZeroSMulDivisors R M
h : Module.rank R M = 0
⊢ toNat (Module.rank R M) = 0
tactic: delta finrank
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : Nontrivial R
inst✝ : NoZeroSMulDivisors R M
h : Module.rank R M = 0
⊢ toNat (Module.rank R M) = 0
state_after: no goals
tactic: rw [h, zero_toNat]
Theorem: Set.OrdConnected.image_ennreal_ofReal
File: Mathlib/Data/ENNReal/Basic.lean

Proof steps:
state_before: α : Type u_1
s : Set ℝ
t : Set ℝ≥0
u : Set ℝ≥0∞
h : s.OrdConnected
⊢ (ENNReal.ofReal '' s).OrdConnected
state_after: no goals
tactic: simpa only [image_image] using h.image_real_toNNReal.image_coe_nnreal_ennreal
Theorem: Finset.univ_fin2
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

Proof steps:
state_before: ⊢ univ = {0, 1}
state_after: case a
x : Fin 2
⊢ x ∈ univ ↔ x ∈ {0, 1}
tactic: ext x
state_before: case a
x : Fin 2
⊢ x ∈ univ ↔ x ∈ {0, 1}
state_after: no goals
tactic: fin_cases x <;> simp
Theorem: Set.indicator_smul_apply_left
File: Mathlib/Algebra/Module/Basic.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
M : Type u_3
M₂ : Type u_4
inst✝² : Zero R
inst✝¹ : Zero M
inst✝ : SMulWithZero R M
s : Set α
r : α → R
f : α → M
a : α
⊢ s.indicator (fun a => r a • f a) a = s.indicator r a • f a
state_after: α : Type u_1
R : Type u_2
M : Type u_3
M₂ : Type u_4
inst✝² : Zero R
inst✝¹ : Zero M
inst✝ : SMulWithZero R M
s : Set α
r : α → R
f : α → M
a : α
⊢ (if a ∈ s then r a • f a else 0) = (if a ∈ s then r a else 0) • f a
tactic: dsimp only [indicator]
state_before: α : Type u_1
R : Type u_2
M : Type u_3
M₂ : Type u_4
inst✝² : Zero R
inst✝¹ : Zero M
inst✝ : SMulWithZero R M
s : Set α
r : α → R
f : α → M
a : α
⊢ (if a ∈ s then r a • f a else 0) = (if a ∈ s then r a else 0) • f a
state_after: case pos
α : Type u_1
R : Type u_2
M : Type u_3
M₂ : Type u_4
inst✝² : Zero R
inst✝¹ : Zero M
inst✝ : SMulWithZero R M
s : Set α
r : α → R
f : α → M
a : α
h✝ : a ∈ s
⊢ r a • f a = r a • f a

case neg
α : Type u_1
R : Type u_2
M : Type u_3
M₂ : Type u_4
inst✝² : Zero R
inst✝¹ : Zero M
inst✝ : SMulWithZero R M
s : Set α
r : α → R
f : α → M
a : α
h✝ : a ∉ s
⊢ 0 = 0 • f a
tactic: split_ifs
state_before: case pos
α : Type u_1
R : Type u_2
M : Type u_3
M₂ : Type u_4
inst✝² : Zero R
inst✝¹ : Zero M
inst✝ : SMulWithZero R M
s : Set α
r : α → R
f : α → M
a : α
h✝ : a ∈ s
⊢ r a • f a = r a • f a

case neg
α : Type u_1
R : Type u_2
M : Type u_3
M₂ : Type u_4
inst✝² : Zero R
inst✝¹ : Zero M
inst✝ : SMulWithZero R M
s : Set α
r : α → R
f : α → M
a : α
h✝ : a ∉ s
⊢ 0 = 0 • f a
state_after: no goals
tactic: exacts [rfl, (zero_smul _ (f a)).symm]