tasksource/leandojo huggingface dataset:
Theorem: Nat.findGreatest_spec
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: by_cases h : Nat.findGreatest P n = 0
state_before: m n k l : ℕ
P Q : ℕ → Prop
inst✝ : DecidablePred P
hmb : m ≤ n
hm : P m
⊢ P (Nat.findGreatest P n)

tactic: cases m
state_before: case pos
m n k l : ℕ
P Q : ℕ → Prop
inst✝ : DecidablePred P
hmb : m ≤ n
hm : P m
h : Nat.findGreatest P n = 0
⊢ P (Nat.findGreatest P n)

tactic: exact ((findGreatest_eq_zero_iff.1 h) (zero_lt_succ _) hmb hm).elim
state_before: case pos.succ
n k l : ℕ
P Q : ℕ → Prop
inst✝ : DecidablePred P
h : Nat.findGreatest P n = 0
n✝ : ℕ
hmb : succ n✝ ≤ n
hm : P (succ n✝)
⊢ P (Nat.findGreatest P n)

tactic: rwa [h]
state_before: case pos.zero
n k l : ℕ
P Q : ℕ → Prop
inst✝ : DecidablePred P
h : Nat.findGreatest P n = 0
hmb : zero ≤ n
hm : P zero
⊢ P (Nat.findGreatest P n)

tactic: exact (findGreatest_eq_iff.1 rfl).2.1 h
state_before: case neg
m n k l : ℕ
P Q : ℕ → Prop
inst✝ : DecidablePred P
hmb : m ≤ n
hm : P m
h : ¬Nat.findGreatest P n = 0
⊢ P (Nat.findGreatest P n)
Theorem: map_extChartAt_nhdsWithin_eq_image'
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: rwa [← extChartAt_source I]
state_before: 𝕜 : Type u_3
E : Type u_2
M : Type u_1
H : Type u_4
E' : Type ?u.209241
M' : Type ?u.209244
H' : Type ?u.209247
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : TopologicalSpace H
inst✝⁶ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝⁵ : NormedAddCommGroup E'
inst✝⁴ : NormedSpace 𝕜 E'
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x : M
s t : Set M
inst✝¹ : ChartedSpace H M
inst✝ : ChartedSpace H' M'
y : M
hy : y ∈ (extChartAt I x).source
⊢ y ∈ (chartAt H x).toLocalEquiv.source
Theorem: RegularExpression.char_rmatch_iff
File: Mathlib/Computability/RegularExpressions.lean

tactic: cases' x with _ x
state_before: α : Type u_1
β : Type ?u.34271
γ : Type ?u.34274
dec : DecidableEq α
a✝ b a : α
x : List α
⊢ rmatch (char a) x = true ↔ x = [a]

tactic: cases' x with head tail
state_before: case cons
α : Type u_1
β : Type ?u.34271
γ : Type ?u.34274
dec : DecidableEq α
a✝ b a head✝ : α
x : List α
⊢ rmatch (char a) (head✝ :: x) = true ↔ head✝ :: x = [a]

tactic: exact of_decide_eq_true rfl
state_before: case nil
α : Type u_1
β : Type ?u.34271
γ : Type ?u.34274
dec : DecidableEq α
a✝ b a : α
⊢ rmatch (char a) [] = true ↔ [] = [a]

tactic: rw [rmatch, deriv]
state_before: case cons.nil
α : Type u_1
β : Type ?u.34271
γ : Type ?u.34274
dec : DecidableEq α
a✝ b a head✝ : α
⊢ rmatch (char a) [head✝] = true ↔ [head✝] = [a]

tactic: split_ifs
state_before: case cons.nil
α : Type u_1
β : Type ?u.34271
γ : Type ?u.34274
dec : DecidableEq α
a✝ b a head✝ : α
⊢ rmatch (if a = head✝ then 1 else 0) [] = true ↔ [head✝] = [a]

tactic: tauto
state_before: case cons.nil.inl
α : Type u_1
β : Type ?u.34271
γ : Type ?u.34274
dec : DecidableEq α
a✝ b a head✝ : α
h✝ : a = head✝
⊢ rmatch 1 [] = true ↔ [head✝] = [a]

tactic: simp [List.singleton_inj]
state_before: case cons.nil.inr
α : Type u_1
β : Type ?u.34271
γ : Type ?u.34274
dec : DecidableEq α
a✝ b a head✝ : α
h✝ : ¬a = head✝
⊢ rmatch 0 [] = true ↔ [head✝] = [a]

tactic: tauto
state_before: case cons.nil.inr
α : Type u_1
β : Type ?u.34271
γ : Type ?u.34274
dec : DecidableEq α
a✝ b a head✝ : α
h✝ : ¬a = head✝
⊢ ¬head✝ = a

tactic: rw [rmatch, rmatch, deriv]
state_before: case cons.cons
α : Type u_1
β : Type ?u.34271
γ : Type ?u.34274
dec : DecidableEq α
a✝ b a head✝ head : α
tail : List α
⊢ rmatch (char a) (head✝ :: head :: tail) = true ↔ head✝ :: head :: tail = [a]

tactic: split_ifs with h
state_before: case cons.cons
α : Type u_1
β : Type ?u.34271
γ : Type ?u.34274
dec : DecidableEq α
a✝ b a head✝ head : α
tail : List α
⊢ rmatch (deriv (if a = head✝ then 1 else 0) head) tail = true ↔ head✝ :: head :: tail = [a]

tactic: simp only [deriv_one, zero_rmatch, cons.injEq, and_false]
state_before: case cons.cons.inl
α : Type u_1
β : Type ?u.34271
γ : Type ?u.34274
dec : DecidableEq α
a✝ b a head✝ head : α
tail : List α
h : a = head✝
⊢ rmatch (deriv 1 head) tail = true ↔ head✝ :: head :: tail = [a]

tactic: simp only [deriv_zero, zero_rmatch, cons.injEq, and_false]
state_before: case cons.cons.inr
α : Type u_1
β : Type ?u.34271
γ : Type ?u.34274
dec : DecidableEq α
a✝ b a head✝ head : α
tail : List α
h : ¬a = head✝
⊢ rmatch (deriv 0 head) tail = true ↔ head✝ :: head :: tail = [a]
Theorem: List.foldl_append
File: Std/Data/List/Init/Lemmas.lean

tactic: simp [foldl_eq_foldlM]
state_before: α : Type u_1
β : Type u_2
f : β → α → β
b : β
l l' : List α
⊢ foldl f b (l ++ l') = foldl f (foldl f b l) l'
Theorem: Nat.sub_add_eq
File: src/lean/Init/Data/Nat/Basic.lean

tactic: induction c with
| zero => simp
| succ c ih => simp [Nat.add_succ, Nat.sub_succ, ih]
state_before: a b c : Nat
⊢ a - (b + c) = a - b - c

tactic: simp
state_before: case zero
a b : Nat
⊢ a - (b + zero) = a - b - zero

tactic: simp [Nat.add_succ, Nat.sub_succ, ih]
state_before: case succ
a b c : Nat
ih : a - (b + c) = a - b - c
⊢ a - (b + succ c) = a - b - succ c
Theorem: Stream'.nth_succ_iterate
File: Mathlib/Data/Stream/Init.lean

tactic: rw [nth_succ, tail_iterate]
state_before: α : Type u
β : Type v
δ : Type w
n : ℕ
f : α → α
a : α
⊢ nth (iterate f a) (succ n) = nth (iterate f (f a)) n
Theorem: Real.tendsto_comp_exp_atTop
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

tactic: simp_rw [←comp_apply (g := exp), ← tendsto_map'_iff, map_exp_atTop]
state_before: α : Type u_1
x y z : ℝ
l : Filter α
f : ℝ → α
⊢ Tendsto (fun x => f (exp x)) atTop l ↔ Tendsto f atTop l
Theorem: PowerSeries.X_pow_dvd_iff
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: convert@MvPowerSeries.X_pow_dvd_iff Unit R _ () n φ
state_before: R : Type u_1
inst✝ : Semiring R
n : ℕ
φ : PowerSeries R
⊢ X ^ n ∣ φ ↔ ∀ (m : ℕ), m < n → ↑(coeff R m) φ = 0

tactic: constructor <;> intro h m hm
state_before: case h.e'_2.a
R : Type u_1
inst✝ : Semiring R
n : ℕ
φ : PowerSeries R
⊢ (∀ (m : ℕ), m < n → ↑(coeff R m) φ = 0) ↔ ∀ (m : Unit →₀ ℕ), ↑m () < n → ↑(MvPowerSeries.coeff R m) φ = 0

tactic: rw [Finsupp.unique_single m]
state_before: case h.e'_2.a.mp
R : Type u_1
inst✝ : Semiring R
n : ℕ
φ : PowerSeries R
h : ∀ (m : ℕ), m < n → ↑(coeff R m) φ = 0
m : Unit →₀ ℕ
hm : ↑m () < n
⊢ ↑(MvPowerSeries.coeff R m) φ = 0

tactic: convert h _ hm
state_before: case h.e'_2.a.mp
R : Type u_1
inst✝ : Semiring R
n : ℕ
φ : PowerSeries R
h : ∀ (m : ℕ), m < n → ↑(coeff R m) φ = 0
m : Unit →₀ ℕ
hm : ↑m () < n
⊢ ↑(MvPowerSeries.coeff R (single default (↑m default))) φ = 0

tactic: apply h
state_before: case h.e'_2.a.mpr
R : Type u_1
inst✝ : Semiring R
n : ℕ
φ : PowerSeries R
h : ∀ (m : Unit →₀ ℕ), ↑m () < n → ↑(MvPowerSeries.coeff R m) φ = 0
m : ℕ
hm : m < n
⊢ ↑(coeff R m) φ = 0

tactic: simpa only [Finsupp.single_eq_same] using hm
state_before: case h.e'_2.a.mpr.a
R : Type u_1
inst✝ : Semiring R
n : ℕ
φ : PowerSeries R
h : ∀ (m : Unit →₀ ℕ), ↑m () < n → ↑(MvPowerSeries.coeff R m) φ = 0
m : ℕ
hm : m < n
⊢ ↑(single () m) () < n
Theorem: Ideal.IsMaximal.exists_inv
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: cases' isMaximal_iff.1 hI with H₁ H₂
state_before: α : Type u
β : Type v
inst✝ : Semiring α
I✝ : Ideal α
a b : α
I : Ideal α
hI : IsMaximal I
x : α
hx : ¬x ∈ I
⊢ ∃ y i, i ∈ I ∧ y * x + i = 1

tactic: rcases mem_span_insert.1
    (H₂ (span (insert x I)) x (Set.Subset.trans (subset_insert _ _) subset_span) hx
      (subset_span (mem_insert _ _))) with
  ⟨y, z, hz, hy⟩
state_before: case intro
α : Type u
β : Type v
inst✝ : Semiring α
I✝ : Ideal α
a b : α
I : Ideal α
hI : IsMaximal I
x : α
hx : ¬x ∈ I
H₁ : ¬1 ∈ I
H₂ : ∀ (J : Ideal α) (x : α), I ≤ J → ¬x ∈ I → x ∈ J → 1 ∈ J
⊢ ∃ y i, i ∈ I ∧ y * x + i = 1

tactic: refine' ⟨y, z, _, hy.symm⟩
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
inst✝ : Semiring α
I✝ : Ideal α
a b : α
I : Ideal α
hI : IsMaximal I
x : α
hx : ¬x ∈ I
H₁ : ¬1 ∈ I
H₂ : ∀ (J : Ideal α) (x : α), I ≤ J → ¬x ∈ I → x ∈ J → 1 ∈ J
y z : α
hz : z ∈ span ↑I
hy : 1 = y * x + z
⊢ ∃ y i, i ∈ I ∧ y * x + i = 1

tactic: rwa [← span_eq I]
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
inst✝ : Semiring α
I✝ : Ideal α
a b : α
I : Ideal α
hI : IsMaximal I
x : α
hx : ¬x ∈ I
H₁ : ¬1 ∈ I
H₂ : ∀ (J : Ideal α) (x : α), I ≤ J → ¬x ∈ I → x ∈ J → 1 ∈ J
y z : α
hz : z ∈ span ↑I
hy : 1 = y * x + z
⊢ z ∈ I
Theorem: List.nthLe_mapIdx
File: Mathlib/Data/List/Indexes.lean

tactic: simp [mapIdx_eq_enum_map, enum_eq_zip_range]
state_before: α✝ : Type u
β✝ : Type v
α : Type u_1
β : Type u_2
l : List α
f : ℕ → α → β
i : ℕ
h : i < length l
h' : optParam (i < length (mapIdx f l)) (_ : i < length (mapIdx f l))
⊢ nthLe (mapIdx f l) i h' = f i (nthLe l i h)
Theorem: CategoryTheory.Localization.Construction.natTransExtension_hcomp
File: Mathlib/CategoryTheory/Localization/Construction.lean

tactic: aesop_cat
state_before: C : Type u_1
inst✝¹ : Category C
W : MorphismProperty C
D : Type u_4
inst✝ : Category D
G✝ : C ⥤ D
hG : MorphismProperty.IsInvertedBy W G✝
F G : MorphismProperty.Localization W ⥤ D
τ : MorphismProperty.Q W ⋙ F ⟶ MorphismProperty.Q W ⋙ G
⊢ 𝟙 (MorphismProperty.Q W) ◫ natTransExtension τ = τ
Theorem: Finset.filter_singleton
File: Mathlib/Data/Finset/Basic.lean

tactic: classical
  ext x
  simp
  split_ifs with h <;> by_cases h' : x = a <;> simp [h, h']
state_before: α : Type u_1
β : Type ?u.331102
γ : Type ?u.331105
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
a : α
⊢ filter p {a} = if p a then {a} else ∅

tactic: ext x
state_before: α : Type u_1
β : Type ?u.331102
γ : Type ?u.331105
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
a : α
⊢ filter p {a} = if p a then {a} else ∅

tactic: simp
state_before: case a
α : Type u_1
β : Type ?u.331102
γ : Type ?u.331105
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
a x : α
⊢ x ∈ filter p {a} ↔ x ∈ if p a then {a} else ∅

tactic: split_ifs with h <;> by_cases h' : x = a <;> simp [h, h']
state_before: case a
α : Type u_1
β : Type ?u.331102
γ : Type ?u.331105
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
a x : α
⊢ x = a ∧ p x ↔ x ∈ if p a then {a} else ∅
Theorem: Decidable.not_exists_not
File: Mathlib/Logic/Basic.lean

tactic: simp only [not_exists, Decidable.not_not]
state_before: ι : Sort ?u.13788
α : Sort u_1
κ : ι → Sort ?u.13790
p q : α → Prop
inst✝ : (x : α) → Decidable (p x)
⊢ (¬∃ x, ¬p x) ↔ ∀ (x : α), p x
Theorem: Odd.nat_add_dvd_pow_add_pow
File: Mathlib/Algebra/GeomSum.lean

tactic: exact_mod_cast Odd.add_dvd_pow_add_pow (x : ℤ) (↑y) h
state_before: α : Type u
x y n : ℕ
h : Odd n
⊢ x + y ∣ x ^ n + y ^ n
Theorem: Nat.factors_unique
File: Mathlib/Data/Nat/Factors.lean

tactic: refine' perm_of_prod_eq_prod _ _ _
state_before: n : ℕ
l : List ℕ
h₁ : prod l = n
h₂ : ∀ (p : ℕ), p ∈ l → Prime p
⊢ l ~ factors n

tactic: rw [h₁]
state_before: case refine'_1
n : ℕ
l : List ℕ
h₁ : prod l = n
h₂ : ∀ (p : ℕ), p ∈ l → Prime p
⊢ prod l = prod (factors n)

tactic: refine' (prod_factors _).symm
state_before: case refine'_1
n : ℕ
l : List ℕ
h₁ : prod l = n
h₂ : ∀ (p : ℕ), p ∈ l → Prime p
⊢ n = prod (factors n)

tactic: rintro rfl
state_before: case refine'_1
n : ℕ
l : List ℕ
h₁ : prod l = n
h₂ : ∀ (p : ℕ), p ∈ l → Prime p
⊢ n ≠ 0

tactic: rw [prod_eq_zero_iff] at h₁
state_before: case refine'_1
l : List ℕ
h₂ : ∀ (p : ℕ), p ∈ l → Prime p
h₁ : prod l = 0
⊢ False

tactic: exact Prime.ne_zero (h₂ 0 h₁) rfl
state_before: case refine'_1
l : List ℕ
h₂ : ∀ (p : ℕ), p ∈ l → Prime p
h₁ : 0 ∈ l
⊢ False

tactic: simp_rw [← prime_iff]
state_before: case refine'_2
n : ℕ
l : List ℕ
h₁ : prod l = n
h₂ : ∀ (p : ℕ), p ∈ l → Prime p
⊢ ∀ (p : ℕ), p ∈ l → _root_.Prime p

tactic: exact h₂
state_before: case refine'_2
n : ℕ
l : List ℕ
h₁ : prod l = n
h₂ : ∀ (p : ℕ), p ∈ l → Prime p
⊢ ∀ (p : ℕ), p ∈ l → Prime p

tactic: simp_rw [← prime_iff]
state_before: case refine'_3
n : ℕ
l : List ℕ
h₁ : prod l = n
h₂ : ∀ (p : ℕ), p ∈ l → Prime p
⊢ ∀ (p : ℕ), p ∈ factors n → _root_.Prime p

tactic: exact fun p => prime_of_mem_factors
state_before: case refine'_3
n : ℕ
l : List ℕ
h₁ : prod l = n
h₂ : ∀ (p : ℕ), p ∈ l → Prime p
⊢ ∀ (p : ℕ), p ∈ factors n → Prime p
Theorem: MeasureTheory.SimpleFunc.bind_const
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.64948
δ : Type ?u.64951
inst✝ : MeasurableSpace α
f : α →ₛ β
⊢ bind f (const α) = f

tactic: simp
state_before: case H
α : Type u_1
β : Type u_2
γ : Type ?u.64948
δ : Type ?u.64951
inst✝ : MeasurableSpace α
f : α →ₛ β
a✝ : α
⊢ ↑(bind f (const α)) a✝ = ↑f a✝
Theorem: mul_cancel_right_mem_nonZeroDivisors
File: Mathlib/RingTheory/NonZeroDivisors.lean

tactic: rw [← sub_eq_zero, ← mul_right_mem_nonZeroDivisors_eq_zero_iff hr, sub_mul, h, sub_self]
state_before: M : Type ?u.15454
M' : Type ?u.15457
M₁ : Type ?u.15460
R : Type u_1
R' : Type ?u.15466
F : Type ?u.15469
inst✝⁴ : MonoidWithZero M
inst✝³ : MonoidWithZero M'
inst✝² : CommMonoidWithZero M₁
inst✝¹ : Ring R
inst✝ : CommRing R'
x y r : R
hr : r ∈ R⁰
h : x * r = y * r
⊢ x = y
Theorem: Function.Injective.noZeroDivisors
File: Mathlib/Algebra/GroupWithZero/InjSurj.lean

tactic: rw [← mul, H, zero]
state_before: M₀ : Type u_1
G₀ : Type ?u.1682
M₀' : Type u_2
G₀' : Type ?u.1688
inst✝⁴ : Mul M₀
inst✝³ : Zero M₀
inst✝² : Mul M₀'
inst✝¹ : Zero M₀'
inst✝ : NoZeroDivisors M₀'
f : M₀ → M₀'
hf : Injective f
zero : f 0 = 0
mul : ∀ (x y : M₀), f (x * y) = f x * f y
a✝ b✝ : M₀
H : a✝ * b✝ = 0
⊢ f (?m.2148 f hf zero mul H) * f (?m.2149 f hf zero mul H) = 0

tactic: rwa [zero]
state_before: M₀ : Type u_1
G₀ : Type ?u.1682
M₀' : Type u_2
G₀' : Type ?u.1688
inst✝⁴ : Mul M₀
inst✝³ : Zero M₀
inst✝² : Mul M₀'
inst✝¹ : Zero M₀'
inst✝ : NoZeroDivisors M₀'
f : M₀ → M₀'
hf : Injective f
zero : f 0 = 0
mul : ∀ (x y : M₀), f (x * y) = f x * f y
a✝ b✝ : M₀
H✝ : a✝ * b✝ = 0
this : f a✝ * f b✝ = 0
H : f a✝ = 0
⊢ f a✝ = f 0

tactic: rwa [zero]
state_before: M₀ : Type u_1
G₀ : Type ?u.1682
M₀' : Type u_2
G₀' : Type ?u.1688
inst✝⁴ : Mul M₀
inst✝³ : Zero M₀
inst✝² : Mul M₀'
inst✝¹ : Zero M₀'
inst✝ : NoZeroDivisors M₀'
f : M₀ → M₀'
hf : Injective f
zero : f 0 = 0
mul : ∀ (x y : M₀), f (x * y) = f x * f y
a✝ b✝ : M₀
H✝ : a✝ * b✝ = 0
this : f a✝ * f b✝ = 0
H : f b✝ = 0
⊢ f b✝ = f 0
Theorem: EMetric.secondCountable_of_almost_dense_set
File: Mathlib/Topology/MetricSpace/EMetricSpace.lean

tactic: suffices SeparableSpace α from UniformSpace.secondCountable_of_separable α
state_before: α : Type u
β : Type v
X : Type ?u.281603
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t : Set α
hs : ∀ (ε : ℝ≥0∞), ε > 0 → ∃ t, Set.Countable t ∧ (⋃ (x : α) (_ : x ∈ t), closedBall x ε) = univ
⊢ SecondCountableTopology α

tactic: have : ∀ ε > 0, ∃ t : Set α, Set.Countable t ∧ univ ⊆ ⋃ x ∈ t, closedBall x ε
state_before: α : Type u
β : Type v
X : Type ?u.281603
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t : Set α
hs : ∀ (ε : ℝ≥0∞), ε > 0 → ∃ t, Set.Countable t ∧ (⋃ (x : α) (_ : x ∈ t), closedBall x ε) = univ
⊢ SeparableSpace α

tactic: rcases subset_countable_closure_of_almost_dense_set (univ : Set α) this with ⟨t, -, htc, ht⟩
state_before: α : Type u
β : Type v
X : Type ?u.281603
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t : Set α
hs : ∀ (ε : ℝ≥0∞), ε > 0 → ∃ t, Set.Countable t ∧ (⋃ (x : α) (_ : x ∈ t), closedBall x ε) = univ
this : ∀ (ε : ℝ≥0∞), ε > 0 → ∃ t, Set.Countable t ∧ univ ⊆ ⋃ (x : α) (_ : x ∈ t), closedBall x ε
⊢ SeparableSpace α

tactic: exact ⟨⟨t, htc, fun x => ht (mem_univ x)⟩⟩
state_before: case intro.intro.intro
α : Type u
β : Type v
X : Type ?u.281603
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t✝ : Set α
hs : ∀ (ε : ℝ≥0∞), ε > 0 → ∃ t, Set.Countable t ∧ (⋃ (x : α) (_ : x ∈ t), closedBall x ε) = univ
this : ∀ (ε : ℝ≥0∞), ε > 0 → ∃ t, Set.Countable t ∧ univ ⊆ ⋃ (x : α) (_ : x ∈ t), closedBall x ε
t : Set α
htc : Set.Countable t
ht : univ ⊆ closure t
⊢ SeparableSpace α

tactic: simpa only [univ_subset_iff] using hs
state_before: case this
α : Type u
β : Type v
X : Type ?u.281603
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t : Set α
hs : ∀ (ε : ℝ≥0∞), ε > 0 → ∃ t, Set.Countable t ∧ (⋃ (x : α) (_ : x ∈ t), closedBall x ε) = univ
⊢ ∀ (ε : ℝ≥0∞), ε > 0 → ∃ t, Set.Countable t ∧ univ ⊆ ⋃ (x : α) (_ : x ∈ t), closedBall x ε
Theorem: List.suffix_iff_eq_append
File: Mathlib/Data/List/Infix.lean

tactic: rintro ⟨r, rfl⟩
state_before: α : Type u_1
β : Type ?u.3302
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
⊢ l₁ <:+ l₂ → take (length l₂ - length l₁) l₂ ++ l₁ = l₂

tactic: simp only [length_append, add_tsub_cancel_right, take_left]
state_before: case intro
α : Type u_1
β : Type ?u.3302
l l₁ l₃ : List α
a b : α
m n : ℕ
r : List α
⊢ take (length (r ++ l₁) - length l₁) (r ++ l₁) ++ l₁ = r ++ l₁
Theorem: Nat.add_sub_add_left
File: src/lean/Init/Data/Nat/Basic.lean

tactic: rw [Nat.add_comm k n, Nat.add_comm k m, Nat.add_sub_add_right]
state_before: k n m : Nat
⊢ k + n - (k + m) = n - m
Theorem: min_le_of_mul_le_sq
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: simpa using min_le_max_of_mul_le_mul (h.trans_eq <| pow_two _)
state_before: β : Type ?u.169935
A : Type ?u.169938
G : Type ?u.169941
M : Type u_1
R : Type ?u.169947
inst✝³ : Monoid M
inst✝² : LinearOrder M
inst✝¹ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass M M (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : M
h : a * b ≤ c ^ 2
⊢ min a b ≤ c
Theorem: MeasureTheory.SimpleFunc.tendsto_approxOn_range_L1_nnnorm
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

tactic: simp
state_before: α : Type ?u.941082
β : Type ?u.941085
ι : Type ?u.941088
E : Type ?u.941091
F : Type ?u.941094
𝕜 : Type ?u.941097
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace E
inst✝² : NormedAddCommGroup E
inst✝¹ : OpensMeasurableSpace E
f : β → E
μ : Measure β
inst✝ : SeparableSpace ↑(Set.range f ∪ {0})
fmeas : Measurable f
hf : Integrable f
n : ℕ
x : β
⊢ 0 ∈ Set.range f ∪ {0}

tactic: apply tendsto_approxOn_L1_nnnorm fmeas
state_before: α : Type ?u.941082
β : Type u_2
ι : Type ?u.941088
E : Type u_1
F : Type ?u.941094
𝕜 : Type ?u.941097
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace E
inst✝² : NormedAddCommGroup E
inst✝¹ : OpensMeasurableSpace E
f : β → E
μ : Measure β
inst✝ : SeparableSpace ↑(Set.range f ∪ {0})
fmeas : Measurable f
hf : Integrable f
⊢ Tendsto (fun n => ∫⁻ (x : β), ↑‖↑(approxOn f fmeas (Set.range f ∪ {0}) 0 (_ : 0 ∈ Set.range f ∪ {0}) n) x - f x‖₊ ∂μ)
    atTop (𝓝 0)

tactic: apply eventually_of_forall
state_before: case hμ
α : Type ?u.941082
β : Type u_2
ι : Type ?u.941088
E : Type u_1
F : Type ?u.941094
𝕜 : Type ?u.941097
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace E
inst✝² : NormedAddCommGroup E
inst✝¹ : OpensMeasurableSpace E
f : β → E
μ : Measure β
inst✝ : SeparableSpace ↑(Set.range f ∪ {0})
fmeas : Measurable f
hf : Integrable f
⊢ ∀ᵐ (x : β) ∂μ, f x ∈ closure (Set.range f ∪ {0})

tactic: intro x
state_before: case hμ.hp
α : Type ?u.941082
β : Type u_2
ι : Type ?u.941088
E : Type u_1
F : Type ?u.941094
𝕜 : Type ?u.941097
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace E
inst✝² : NormedAddCommGroup E
inst✝¹ : OpensMeasurableSpace E
f : β → E
μ : Measure β
inst✝ : SeparableSpace ↑(Set.range f ∪ {0})
fmeas : Measurable f
hf : Integrable f
⊢ ∀ (x : β), f x ∈ closure (Set.range f ∪ {0})

tactic: apply subset_closure
state_before: case hμ.hp
α : Type ?u.941082
β : Type u_2
ι : Type ?u.941088
E : Type u_1
F : Type ?u.941094
𝕜 : Type ?u.941097
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace E
inst✝² : NormedAddCommGroup E
inst✝¹ : OpensMeasurableSpace E
f : β → E
μ : Measure β
inst✝ : SeparableSpace ↑(Set.range f ∪ {0})
fmeas : Measurable f
hf : Integrable f
x : β
⊢ f x ∈ closure (Set.range f ∪ {0})

tactic: simp
state_before: case hμ.hp.a
α : Type ?u.941082
β : Type u_2
ι : Type ?u.941088
E : Type u_1
F : Type ?u.941094
𝕜 : Type ?u.941097
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace E
inst✝² : NormedAddCommGroup E
inst✝¹ : OpensMeasurableSpace E
f : β → E
μ : Measure β
inst✝ : SeparableSpace ↑(Set.range f ∪ {0})
fmeas : Measurable f
hf : Integrable f
x : β
⊢ f x ∈ Set.range f ∪ {0}

tactic: simpa using hf.2
state_before: case hi
α : Type ?u.941082
β : Type u_2
ι : Type ?u.941088
E : Type u_1
F : Type ?u.941094
𝕜 : Type ?u.941097
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace E
inst✝² : NormedAddCommGroup E
inst✝¹ : OpensMeasurableSpace E
f : β → E
μ : Measure β
inst✝ : SeparableSpace ↑(Set.range f ∪ {0})
fmeas : Measurable f
hf : Integrable f
⊢ HasFiniteIntegral fun x => f x - 0
Theorem: MonoidAlgebra.mul_apply
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: rw [mul_def, Finsupp.sum_apply]
state_before: k : Type u₁
G : Type u₂
R : Type ?u.354844
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f g : MonoidAlgebra k G
x : G
⊢ ↑(f * g) x = sum f fun a₁ b₁ => sum g fun a₂ b₂ => if a₁ * a₂ = x then b₁ * b₂ else 0

tactic: congr
state_before: k : Type u₁
G : Type u₂
R : Type ?u.354844
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f g : MonoidAlgebra k G
x : G
⊢ (sum f fun a₁ b => ↑(sum g fun a₂ b₂ => single (a₁ * a₂) (b * b₂)) x) =
    sum f fun a₁ b₁ => sum g fun a₂ b₂ => if a₁ * a₂ = x then b₁ * b₂ else 0

tactic: ext
state_before: case e_g
k : Type u₁
G : Type u₂
R : Type ?u.354844
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f g : MonoidAlgebra k G
x : G
⊢ (fun a₁ b => ↑(sum g fun a₂ b₂ => single (a₁ * a₂) (b * b₂)) x) = fun a₁ b₁ =>
    sum g fun a₂ b₂ => if a₁ * a₂ = x then b₁ * b₂ else 0

tactic: rw [Finsupp.sum_apply]
state_before: case e_g.h.h
k : Type u₁
G : Type u₂
R : Type ?u.354844
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f g : MonoidAlgebra k G
x x✝¹ : G
x✝ : k
⊢ ↑(sum g fun a₂ b₂ => single (x✝¹ * a₂) (x✝ * b₂)) x = sum g fun a₂ b₂ => if x✝¹ * a₂ = x then x✝ * b₂ else 0

tactic: congr
state_before: case e_g.h.h
k : Type u₁
G : Type u₂
R : Type ?u.354844
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f g : MonoidAlgebra k G
x x✝¹ : G
x✝ : k
⊢ (sum g fun a₁ b => ↑(single (x✝¹ * a₁) (x✝ * b)) x) = sum g fun a₂ b₂ => if x✝¹ * a₂ = x then x✝ * b₂ else 0

tactic: ext
state_before: case e_g.h.h.e_g
k : Type u₁
G : Type u₂
R : Type ?u.354844
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f g : MonoidAlgebra k G
x x✝¹ : G
x✝ : k
⊢ (fun a₁ b => ↑(single (x✝¹ * a₁) (x✝ * b)) x) = fun a₂ b₂ => if x✝¹ * a₂ = x then x✝ * b₂ else 0

tactic: apply single_apply
state_before: case e_g.h.h.e_g.h.h
k : Type u₁
G : Type u₂
R : Type ?u.354844
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f g : MonoidAlgebra k G
x x✝³ : G
x✝² : k
x✝¹ : G
x✝ : k
⊢ ↑(single (x✝³ * x✝¹) (x✝² * x✝)) x = if x✝³ * x✝¹ = x then x✝² * x✝ else 0
Theorem: Polynomial.toFinsupp_erase
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rcases p with ⟨⟩
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p✝ q p : R[X]
n : ℕ
⊢ (erase n p).toFinsupp = Finsupp.erase n p.toFinsupp

tactic: simp only [erase_def]
state_before: case ofFinsupp
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ (erase n { toFinsupp := toFinsupp✝ }).toFinsupp = Finsupp.erase n { toFinsupp := toFinsupp✝ }.toFinsupp
Theorem: Rat.zero_mul
File: Std/Data/Rat/Lemmas.lean

tactic: simp [mul_def]
state_before: a : Rat
⊢ 0 * a = 0