tasksource/leandojo huggingface dataset:
Theorem: Ordinal.aleph0_le_cof
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rcases zero_or_succ_or_limit o with (rfl | ⟨o, rfl⟩ | l)
state_before: α : Type ?u.100268
r : α → α → Prop
o : Ordinal
⊢ ℵ₀ ≤ cof o ↔ IsLimit o

tactic: simp [not_zero_isLimit, Cardinal.aleph0_ne_zero]
state_before: case inl
α : Type ?u.100268
r : α → α → Prop
⊢ ℵ₀ ≤ cof 0 ↔ IsLimit 0

tactic: simp [not_succ_isLimit, Cardinal.one_lt_aleph0]
state_before: case inr.inl.intro
α : Type ?u.100268
r : α → α → Prop
o : Ordinal
⊢ ℵ₀ ≤ cof (succ o) ↔ IsLimit (succ o)

tactic: simp [l]
state_before: case inr.inr
α : Type ?u.100268
r : α → α → Prop
o : Ordinal
l : IsLimit o
⊢ ℵ₀ ≤ cof o ↔ IsLimit o

tactic: refine' le_of_not_lt fun h => _
state_before: case inr.inr
α : Type ?u.100268
r : α → α → Prop
o : Ordinal
l : IsLimit o
⊢ ℵ₀ ≤ cof o

tactic: cases' Cardinal.lt_aleph0.1 h with n e
state_before: case inr.inr
α : Type ?u.100268
r : α → α → Prop
o : Ordinal
l : IsLimit o
h : cof o < ℵ₀
⊢ False

tactic: have := cof_cof o
state_before: case inr.inr.intro
α : Type ?u.100268
r : α → α → Prop
o : Ordinal
l : IsLimit o
h : cof o < ℵ₀
n : ℕ
e : cof o = ↑n
⊢ False

tactic: rw [e, ord_nat] at this
state_before: case inr.inr.intro
α : Type ?u.100268
r : α → α → Prop
o : Ordinal
l : IsLimit o
h : cof o < ℵ₀
n : ℕ
e : cof o = ↑n
this : cof (ord (cof o)) = cof o
⊢ False

tactic: cases n
state_before: case inr.inr.intro
α : Type ?u.100268
r : α → α → Prop
o : Ordinal
l : IsLimit o
h : cof o < ℵ₀
n : ℕ
e : cof o = ↑n
this : cof ↑n = ↑n
⊢ False

tactic: simp at e
state_before: case inr.inr.intro.zero
α : Type ?u.100268
r : α → α → Prop
o : Ordinal
l : IsLimit o
h : cof o < ℵ₀
e : cof o = ↑Nat.zero
this : cof ↑Nat.zero = ↑Nat.zero
⊢ False

tactic: simp [e, not_zero_isLimit] at l
state_before: case inr.inr.intro.zero
α : Type ?u.100268
r : α → α → Prop
o : Ordinal
l : IsLimit o
h : cof o < ℵ₀
this : cof ↑Nat.zero = ↑Nat.zero
e : o = 0
⊢ False

tactic: rw [nat_cast_succ, cof_succ] at this
state_before: case inr.inr.intro.succ
α : Type ?u.100268
r : α → α → Prop
o : Ordinal
l : IsLimit o
h : cof o < ℵ₀
n✝ : ℕ
e : cof o = ↑(Nat.succ n✝)
this : cof ↑(Nat.succ n✝) = ↑(Nat.succ n✝)
⊢ False

tactic: rw [← this, cof_eq_one_iff_is_succ] at e
state_before: case inr.inr.intro.succ
α : Type ?u.100268
r : α → α → Prop
o : Ordinal
l : IsLimit o
h : cof o < ℵ₀
n✝ : ℕ
e : cof o = ↑(Nat.succ n✝)
this : 1 = ↑(Nat.succ n✝)
⊢ False

tactic: rcases e with ⟨a, rfl⟩
state_before: case inr.inr.intro.succ
α : Type ?u.100268
r : α → α → Prop
o : Ordinal
l : IsLimit o
h : cof o < ℵ₀
n✝ : ℕ
e : ∃ a, o = succ a
this : 1 = ↑(Nat.succ n✝)
⊢ False

tactic: exact not_succ_isLimit _ l
state_before: case inr.inr.intro.succ.intro
α : Type ?u.100268
r : α → α → Prop
n✝ : ℕ
this : 1 = ↑(Nat.succ n✝)
a : Ordinal
l : IsLimit (succ a)
h : cof (succ a) < ℵ₀
⊢ False
Theorem: lp.norm_zero
File: Mathlib/Analysis/NormedSpace/lpSpace.lean

tactic: rcases p.trichotomy with (rfl | rfl | hp)
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
⊢ ‖0‖ = 0

tactic: simp [lp.norm_eq_card_dsupport]
state_before: case inl
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
⊢ ‖0‖ = 0

tactic: simp [lp.norm_eq_ciSup]
state_before: case inr.inl
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
⊢ ‖0‖ = 0

tactic: rw [lp.norm_eq_tsum_rpow hp]
state_before: case inr.inr
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < ENNReal.toReal p
⊢ ‖0‖ = 0

tactic: have hp' : 1 / p.toReal ≠ 0 := one_div_ne_zero hp.ne'
state_before: case inr.inr
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < ENNReal.toReal p
⊢ (∑' (i : α), ‖↑0 i‖ ^ ENNReal.toReal p) ^ (1 / ENNReal.toReal p) = 0

tactic: simpa [Real.zero_rpow hp.ne'] using Real.zero_rpow hp'
state_before: case inr.inr
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < ENNReal.toReal p
hp' : 1 / ENNReal.toReal p ≠ 0
⊢ (∑' (i : α), ‖↑0 i‖ ^ ENNReal.toReal p) ^ (1 / ENNReal.toReal p) = 0
Theorem: Complex.cos_three_mul
File: Mathlib/Data/Complex/Exponential.lean

tactic: have h1 : x + 2 * x = 3 * x := by ring
state_before: x y : ℂ
⊢ cos (3 * x) = 4 * cos x ^ 3 - 3 * cos x

tactic: rw [← h1, cos_add x (2 * x)]
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cos (3 * x) = 4 * cos x ^ 3 - 3 * cos x

tactic: simp only [cos_two_mul, sin_two_mul, mul_add, mul_sub, mul_one, sq]
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cos x * cos (2 * x) - sin x * sin (2 * x) = 4 * cos x ^ 3 - 3 * cos x

tactic: have h2 : 4 * cos x ^ 3 = 2 * cos x * cos x * cos x + 2 * cos x * cos x ^ 2 := by ring
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cos x * (2 * (cos x * cos x)) - cos x - sin x * (2 * sin x * cos x) = 4 * cos x ^ 3 - 3 * cos x

tactic: rw [h2, cos_sq']
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
h2 : 4 * cos x ^ 3 = 2 * cos x * cos x * cos x + 2 * cos x * cos x ^ 2
⊢ cos x * (2 * (cos x * cos x)) - cos x - sin x * (2 * sin x * cos x) = 4 * cos x ^ 3 - 3 * cos x

tactic: ring
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
h2 : 4 * cos x ^ 3 = 2 * cos x * cos x * cos x + 2 * cos x * cos x ^ 2
⊢ cos x * (2 * (cos x * cos x)) - cos x - sin x * (2 * sin x * cos x) =
    2 * cos x * cos x * cos x + 2 * cos x * (1 - sin x ^ 2) - 3 * cos x

tactic: ring
state_before: x y : ℂ
⊢ x + 2 * x = 3 * x

tactic: ring
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ 4 * cos x ^ 3 = 2 * cos x * cos x * cos x + 2 * cos x * cos x ^ 2
Theorem: List.TProd.elim_of_ne
File: Mathlib/Data/Prod/TProd.lean

tactic: simp [TProd.elim, hji]
state_before: ι : Type u
α : ι → Type v
i j : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
hj : j ∈ i :: l
hji : j ≠ i
v : TProd α (i :: l)
⊢ TProd.elim v hj = TProd.elim v.snd (_ : j ∈ l)
Theorem: pow_dvd_pow_of_dvd
File: Mathlib/Algebra/Divisibility/Basic.lean

tactic: rw [pow_zero, pow_zero]
state_before: α : Type u_1
inst✝ : CommMonoid α
a✝ b✝ a b : α
h : a ∣ b
⊢ a ^ 0 ∣ b ^ 0

tactic: rw [pow_succ, pow_succ]
state_before: α : Type u_1
inst✝ : CommMonoid α
a✝ b✝ a b : α
h : a ∣ b
n : ℕ
⊢ a ^ (n + 1) ∣ b ^ (n + 1)

tactic: exact mul_dvd_mul h (pow_dvd_pow_of_dvd h n)
state_before: α : Type u_1
inst✝ : CommMonoid α
a✝ b✝ a b : α
h : a ∣ b
n : ℕ
⊢ a * a ^ n ∣ b * b ^ n
Theorem: Algebraic.cardinal_mk_lift_le_max
File: Mathlib/Algebra/AlgebraicCard.lean

tactic: simp
state_before: R : Type u
A : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing A
inst✝² : IsDomain A
inst✝¹ : Algebra R A
inst✝ : NoZeroSMulDivisors R A
⊢ lift (max (#R) ℵ₀) * ℵ₀ ≤ max (lift (#R)) ℵ₀
Theorem: CategoryTheory.Limits.Types.limit_ext
File: Mathlib/CategoryTheory/Limits/Types.lean

tactic: apply (limitEquivSections.{v, u} F).injective
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TypeMax
x y : limit F
w : ∀ (j : J), limit.π F j x = limit.π F j y
⊢ x = y

tactic: ext j
state_before: case a
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TypeMax
x y : limit F
w : ∀ (j : J), limit.π F j x = limit.π F j y
⊢ ↑(limitEquivSections F) x = ↑(limitEquivSections F) y

tactic: simp [w j]
state_before: case a.a.h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TypeMax
x y : limit F
w : ∀ (j : J), limit.π F j x = limit.π F j y
j : J
⊢ ↑(↑(limitEquivSections F) x) j = ↑(↑(limitEquivSections F) y) j
Theorem: Std.RBNode.Any_def
File: Std/Data/RBMap/Lemmas.lean

tactic: induction t <;> simp [or_and_right, exists_or, *]
state_before: α : Type u_1
p : α → Prop
t : RBNode α
⊢ Any p t ↔ ∃ x, x ∈ t ∧ p x
Theorem: gcd_eq_of_dvd_sub_left
File: Mathlib/Algebra/GCDMonoid/Basic.lean

tactic: rw [gcd_comm _ a, gcd_comm _ a, gcd_eq_of_dvd_sub_right h]
state_before: α : Type u_1
inst✝² : CommRing α
inst✝¹ : IsDomain α
inst✝ : NormalizedGCDMonoid α
a b c : α
h : a ∣ b - c
⊢ gcd b a = gcd c a
Theorem: Equiv.Set.sumCompl_symm_apply_of_mem
File: Mathlib/Logic/Equiv/Set.lean

tactic: have : ((⟨x, Or.inl hx⟩ : (s ∪ sᶜ : Set α)) : α) ∈ s := hx
state_before: α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
x : α
hx : x ∈ s
⊢ ↑(Set.sumCompl s).symm x = Sum.inl { val := x, property := hx }

tactic: rw [Equiv.Set.sumCompl]
state_before: α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
x : α
hx : x ∈ s
this : ↑{ val := x, property := (_ : x ∈ s ∨ x ∈ sᶜ) } ∈ s
⊢ ↑(Set.sumCompl s).symm x = Sum.inl { val := x, property := hx }

tactic: simpa using Set.union_apply_left (by simp) this
state_before: α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
x : α
hx : x ∈ s
this : ↑{ val := x, property := (_ : x ∈ s ∨ x ∈ sᶜ) } ∈ s
⊢ ↑(Trans.trans (Trans.trans (Set.union (_ : s ∩ sᶜ ⊆ ∅)).symm (Set.ofEq (_ : s ∪ sᶜ = univ))) (Set.univ α)).symm x =
    Sum.inl { val := x, property := hx }

tactic: simp
state_before: α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
x : α
hx : x ∈ s
this : ↑{ val := x, property := (_ : x ∈ s ∨ x ∈ sᶜ) } ∈ s
⊢ s ∩ sᶜ ⊆ ∅
Theorem: Complex.sinh_sq
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← cosh_sq_sub_sinh_sq x]
state_before: x y : ℂ
⊢ sinh x ^ 2 = cosh x ^ 2 - 1

tactic: ring
state_before: x y : ℂ
⊢ sinh x ^ 2 = cosh x ^ 2 - (cosh x ^ 2 - sinh x ^ 2)
Theorem: mulRothNumber_spec
File: Mathlib/Combinatorics/Additive/SalemSpencer.lean

tactic: norm_cast
state_before: F : Type ?u.131282
α : Type u_1
β : Type ?u.131288
𝕜 : Type ?u.131291
E : Type ?u.131294
inst✝³ : DecidableEq α
inst✝² : Monoid α
inst✝¹ : DecidableEq β
inst✝ : Monoid β
s t : Finset α
⊢ MulSalemSpencer ↑∅

tactic: exact mulSalemSpencer_empty
state_before: F : Type ?u.131282
α : Type u_1
β : Type ?u.131288
𝕜 : Type ?u.131291
E : Type ?u.131294
inst✝³ : DecidableEq α
inst✝² : Monoid α
inst✝¹ : DecidableEq β
inst✝ : Monoid β
s t : Finset α
⊢ MulSalemSpencer ∅
Theorem: Real.rpow_neg
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: simp only [rpow_def_of_nonneg hx]
state_before: x✝ y✝ z x : ℝ
hx : 0 ≤ x
y : ℝ
⊢ x ^ (-y) = (x ^ y)⁻¹

tactic: split_ifs <;> simp_all [exp_neg]
state_before: x✝ y✝ z x : ℝ
hx : 0 ≤ x
y : ℝ
⊢ (if x = 0 then if -y = 0 then 1 else 0 else exp (log x * -y)) =
    (if x = 0 then if y = 0 then 1 else 0 else exp (log x * y))⁻¹
Theorem: Set.IsPwo.submonoid_closure
File: Mathlib/GroupTheory/Submonoid/Pointwise.lean

tactic: rw [Submonoid.closure_eq_image_prod]
state_before: α : Type u_1
G : Type ?u.364481
M : Type ?u.364484
R : Type ?u.364487
A : Type ?u.364490
inst✝² : Monoid M
inst✝¹ : AddMonoid A
inst✝ : OrderedCancelCommMonoid α
s : Set α
hpos : ∀ (x : α), x ∈ s → 1 ≤ x
h : IsPwo s
⊢ IsPwo ↑(Submonoid.closure s)

tactic: exact fun l1 _ l2 hl2 h12 => h12.prod_le_prod' fun x hx => hpos x <| hl2 x hx
state_before: α : Type u_1
G : Type ?u.364481
M : Type ?u.364484
R : Type ?u.364487
A : Type ?u.364490
inst✝² : Monoid M
inst✝¹ : AddMonoid A
inst✝ : OrderedCancelCommMonoid α
s : Set α
hpos : ∀ (x : α), x ∈ s → 1 ≤ x
h : IsPwo s
⊢ ∀ (a₁ : List α),
    a₁ ∈ {l | ∀ (x : α), x ∈ l → x ∈ s} →
      ∀ (a₂ : List α),
        a₂ ∈ {l | ∀ (x : α), x ∈ l → x ∈ s} →
          List.SublistForall₂ (fun x x_1 => x ≤ x_1) a₁ a₂ → List.prod a₁ ≤ List.prod a₂
Theorem: Metric.ball_subset
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [← add_sub_cancel'_right ε₁ ε₂]
state_before: α : Type u
β : Type v
X : Type ?u.43836
ι : Type ?u.43839
inst✝ : PseudoMetricSpace α
x y z✝ : α
δ ε ε₁ ε₂ : ℝ
s : Set α
h : dist x y ≤ ε₂ - ε₁
z : α
zx : z ∈ ball x ε₁
⊢ z ∈ ball y ε₂

tactic: exact lt_of_le_of_lt (dist_triangle z x y) (add_lt_add_of_lt_of_le zx h)
state_before: α : Type u
β : Type v
X : Type ?u.43836
ι : Type ?u.43839
inst✝ : PseudoMetricSpace α
x y z✝ : α
δ ε ε₁ ε₂ : ℝ
s : Set α
h : dist x y ≤ ε₂ - ε₁
z : α
zx : z ∈ ball x ε₁
⊢ z ∈ ball y (ε₁ + (ε₂ - ε₁))
Theorem: hammingDist_eq_zero
File: Mathlib/InformationTheory/Hamming.lean

tactic: rw [H]
state_before: α : Type ?u.9836
ι : Type u_1
β : ι → Type u_2
inst✝² : Fintype ι
inst✝¹ : (i : ι) → DecidableEq (β i)
γ : ι → Type ?u.9868
inst✝ : (i : ι) → DecidableEq (γ i)
x y : (i : ι) → β i
H : x = y
⊢ hammingDist x y = 0

tactic: exact hammingDist_self _
state_before: α : Type ?u.9836
ι : Type u_1
β : ι → Type u_2
inst✝² : Fintype ι
inst✝¹ : (i : ι) → DecidableEq (β i)
γ : ι → Type ?u.9868
inst✝ : (i : ι) → DecidableEq (γ i)
x y : (i : ι) → β i
H : x = y
⊢ hammingDist y y = 0
Theorem: one_add_mul_self_le_rpow_one_add
File: Mathlib/Analysis/Convex/SpecificFunctions/Basic.lean

tactic: rcases eq_or_lt_of_le hp with (rfl | hp)
state_before: s : ℝ
hs : -1 ≤ s
p : ℝ
hp : 1 ≤ p
⊢ 1 + p * s ≤ (1 + s) ^ p

tactic: by_cases hs' : s = 0
state_before: case inr
s : ℝ
hs : -1 ≤ s
p : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
⊢ 1 + p * s ≤ (1 + s) ^ p

tactic: exact (one_add_mul_self_lt_rpow_one_add hs hs' hp).le
state_before: case neg
s : ℝ
hs : -1 ≤ s
p : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
hs' : ¬s = 0
⊢ 1 + p * s ≤ (1 + s) ^ p

tactic: simp
state_before: case inl
s : ℝ
hs : -1 ≤ s
hp : 1 ≤ 1
⊢ 1 + 1 * s ≤ (1 + s) ^ 1

tactic: simp [hs']
state_before: case pos
s : ℝ
hs : -1 ≤ s
p : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
hs' : s = 0
⊢ 1 + p * s ≤ (1 + s) ^ p
Theorem: Set.image_inter_nonempty_iff
File: Mathlib/Data/Set/Image.lean

tactic: rw [← image_inter_preimage, nonempty_image_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.52785
ι : Sort ?u.52788
ι' : Sort ?u.52791
f✝ : α → β
s✝ t✝ : Set α
f : α → β
s : Set α
t : Set β
⊢ Set.Nonempty (f '' s ∩ t) ↔ Set.Nonempty (s ∩ f ⁻¹' t)
Theorem: Set.swap_mem_mulAntidiagonal_aux
File: Mathlib/Data/Set/MulAntidiagonal.lean

tactic: simp [mul_comm, and_left_comm]
state_before: α : Type u_1
inst✝ : CommSemigroup α
s t : Set α
a : α
x : α × α
⊢ x.snd ∈ s ∧ x.fst ∈ t ∧ x.snd * x.fst = a ↔ x ∈ mulAntidiagonal t s a
Theorem: IsHilbertSum.mk
File: Mathlib/Analysis/InnerProductSpace/l2Space.lean

tactic: rw [← LinearIsometry.coe_toLinearMap]
state_before: ι : Type u_4
𝕜 : Type u_2
inst✝⁵ : IsROrC 𝕜
E : Type u_3
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type u_1
inst✝² : (i : ι) → NormedAddCommGroup (G i)
inst✝¹ : (i : ι) → InnerProductSpace 𝕜 (G i)
V : (i : ι) → G i →ₗᵢ[𝕜] E
F : ι → Submodule 𝕜 E
inst✝ : ∀ (i : ι), CompleteSpace (G i)
hVortho : OrthogonalFamily 𝕜 G V
hVtotal : ⊤ ≤ topologicalClosure (⨆ (i : ι), LinearMap.range (V i).toLinearMap)
⊢ Function.Surjective ↑(OrthogonalFamily.linearIsometry hVortho)

tactic: exact LinearMap.range_eq_top.mp
  (eq_top_iff.mpr <| hVtotal.trans_eq hVortho.range_linearIsometry.symm)
state_before: ι : Type u_4
𝕜 : Type u_2
inst✝⁵ : IsROrC 𝕜
E : Type u_3
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type u_1
inst✝² : (i : ι) → NormedAddCommGroup (G i)
inst✝¹ : (i : ι) → InnerProductSpace 𝕜 (G i)
V : (i : ι) → G i →ₗᵢ[𝕜] E
F : ι → Submodule 𝕜 E
inst✝ : ∀ (i : ι), CompleteSpace (G i)
hVortho : OrthogonalFamily 𝕜 G V
hVtotal : ⊤ ≤ topologicalClosure (⨆ (i : ι), LinearMap.range (V i).toLinearMap)
⊢ Function.Surjective ↑(OrthogonalFamily.linearIsometry hVortho).toLinearMap
Theorem: MeasurableSet.measurableSet_bliminf
File: Mathlib/MeasureTheory/MeasurableSpace.lean

tactic: simp only [Filter.bliminf_eq_iSup_biInf_of_nat, iInf_eq_iInter, iSup_eq_iUnion]
state_before: α : Type u_1
β : Type ?u.910929
γ : Type ?u.910932
δ : Type ?u.910935
δ' : Type ?u.910938
ι : Sort uι
s✝ t u : Set α
inst✝ : MeasurableSpace α
s : ℕ → Set α
p : ℕ → Prop
h : ∀ (n : ℕ), p n → MeasurableSet (s n)
⊢ MeasurableSet (bliminf s atTop p)

tactic: exact .iUnion fun n => .iInter fun m => .iInter fun hm => h m hm.1
state_before: α : Type u_1
β : Type ?u.910929
γ : Type ?u.910932
δ : Type ?u.910935
δ' : Type ?u.910938
ι : Sort uι
s✝ t u : Set α
inst✝ : MeasurableSpace α
s : ℕ → Set α
p : ℕ → Prop
h : ∀ (n : ℕ), p n → MeasurableSet (s n)
⊢ MeasurableSet (⋃ (i : ℕ), ⋂ (j : ℕ) (_ : p j ∧ i ≤ j), s j)
Theorem: Polynomial.card_roots
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: unfold roots
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
hp0 : p ≠ 0
⊢ ↑(↑Multiset.card (roots p)) ≤ degree p

tactic: rw [dif_neg hp0]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
hp0 : p ≠ 0
⊢ ↑(↑Multiset.card
        (if h : p = 0 then ∅
        else
          Classical.choose (_ : ∃ s, ↑(↑Multiset.card s) ≤ degree p ∧ ∀ (a : R), count a s = rootMultiplicity a p))) ≤
    degree p

tactic: exact (Classical.choose_spec (exists_multiset_roots hp0)).1
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
hp0 : p ≠ 0
⊢ ↑(↑Multiset.card
        (Classical.choose (_ : ∃ s, ↑(↑Multiset.card s) ≤ degree p ∧ ∀ (a : R), count a s = rootMultiplicity a p))) ≤
    degree p
Theorem: Real.exp_log_of_neg
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: rw [exp_log_eq_abs (ne_of_lt hx)]
state_before: x y : ℝ
hx : x < 0
⊢ exp (log x) = -x

tactic: exact abs_of_neg hx
state_before: x y : ℝ
hx : x < 0
⊢ abs x = -x
Theorem: isExtreme_biInter
File: Mathlib/Analysis/Convex/Extreme.lean

tactic: haveI := hF.to_subtype
state_before: 𝕜 : Type u_2
E : Type u_1
F✝ : Type ?u.3511
ι : Type ?u.3514
π : ι → Type ?u.3519
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
A B C : Set E
x : E
F : Set (Set E)
hF : Set.Nonempty F
hA : ∀ (B : Set E), B ∈ F → IsExtreme 𝕜 A B
⊢ IsExtreme 𝕜 A (⋂ (B : Set E) (_ : B ∈ F), B)

tactic: simpa only [iInter_subtype] using isExtreme_iInter fun i : F ↦ hA _ i.2
state_before: 𝕜 : Type u_2
E : Type u_1
F✝ : Type ?u.3511
ι : Type ?u.3514
π : ι → Type ?u.3519
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
A B C : Set E
x : E
F : Set (Set E)
hF : Set.Nonempty F
hA : ∀ (B : Set E), B ∈ F → IsExtreme 𝕜 A B
this : Nonempty ↑F
⊢ IsExtreme 𝕜 A (⋂ (B : Set E) (_ : B ∈ F), B)
Theorem: ContinuousMap.compactConvNhd_filter_isBasis
File: Mathlib/Topology/UniformSpace/CompactConvergence.lean

tactic: rintro ⟨K₁, V₁⟩ ⟨K₂, V₂⟩ ⟨hK₁, hV₁⟩ ⟨hK₂, hV₂⟩
state_before: α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
⊢ ∀ {i j : Set α × Set (β × β)},
    IsCompact i.fst ∧ i.snd ∈ 𝓤 β →
      IsCompact j.fst ∧ j.snd ∈ 𝓤 β →
        ∃ k,
          (IsCompact k.fst ∧ k.snd ∈ 𝓤 β) ∧
            compactConvNhd k.fst k.snd f ⊆ compactConvNhd i.fst i.snd f ∩ compactConvNhd j.fst j.snd f

tactic: exact
  ⟨⟨K₁ ∪ K₂, V₁ ∩ V₂⟩, ⟨hK₁.union hK₂, Filter.inter_mem hV₁ hV₂⟩,
    compactConvNhd_subset_inter f K₁ K₂ V₁ V₂⟩
state_before: case mk.mk.intro.intro
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
K₁ : Set α
V₁ : Set (β × β)
K₂ : Set α
V₂ : Set (β × β)
hK₁ : IsCompact (K₁, V₁).fst
hV₁ : (K₁, V₁).snd ∈ 𝓤 β
hK₂ : IsCompact (K₂, V₂).fst
hV₂ : (K₂, V₂).snd ∈ 𝓤 β
⊢ ∃ k,
    (IsCompact k.fst ∧ k.snd ∈ 𝓤 β) ∧
      compactConvNhd k.fst k.snd f ⊆
        compactConvNhd (K₁, V₁).fst (K₁, V₁).snd f ∩ compactConvNhd (K₂, V₂).fst (K₂, V₂).snd f
Theorem: IsSMulRegular.of_mul
File: Mathlib/Algebra/Regular/SMul.lean

tactic: rw [← smul_eq_mul] at ab
state_before: R : Type u_1
S : Type ?u.5473
M : Type u_2
a b : R
s : S
inst✝⁵ : SMul R M
inst✝⁴ : SMul R S
inst✝³ : SMul S M
inst✝² : IsScalarTower R S M
inst✝¹ : Mul R
inst✝ : IsScalarTower R R M
ab : IsSMulRegular M (a * b)
⊢ IsSMulRegular M b

tactic: exact ab.of_smul _
state_before: R : Type u_1
S : Type ?u.5473
M : Type u_2
a b : R
s : S
inst✝⁵ : SMul R M
inst✝⁴ : SMul R S
inst✝³ : SMul S M
inst✝² : IsScalarTower R S M
inst✝¹ : Mul R
inst✝ : IsScalarTower R R M
ab : IsSMulRegular M (a • b)
⊢ IsSMulRegular M b
Theorem: Sym.of_vector_cons
File: Mathlib/Data/Sym/Basic.lean

tactic: cases v
state_before: α : Type u_1
β : Type ?u.13471
n n' m : ℕ
s : Sym α n
a✝ b a : α
v : Vector α n
⊢ ofVector (a ::ᵥ v) = a ::ₛ ofVector v

tactic: rfl
state_before: case mk
α : Type u_1
β : Type ?u.13471
n n' m : ℕ
s : Sym α n
a✝ b a : α
val✝ : List α
property✝ : List.length val✝ = n
⊢ ofVector (a ::ᵥ { val := val✝, property := property✝ }) = a ::ₛ ofVector { val := val✝, property := property✝ }
Theorem: Polynomial.leadingCoeff_prod
File: Mathlib/Algebra/Polynomial/BigOperators.lean

tactic: simpa using leadingCoeff_multiset_prod (s.1.map f)
state_before: R : Type u
ι : Type w
s : Finset ι
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
f : ι → R[X]
t : Multiset R[X]
⊢ leadingCoeff (∏ i in s, f i) = ∏ i in s, leadingCoeff (f i)
Theorem: ContinuousLinearMap.smulRight_one_one
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: ext
state_before: R₁ : Type u_1
R₂ : Type ?u.652857
R₃ : Type ?u.652860
inst✝²⁰ : Semiring R₁
inst✝¹⁹ : Semiring R₂
inst✝¹⁸ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
M₁ : Type ?u.652938
inst✝¹⁷ : TopologicalSpace M₁
inst✝¹⁶ : AddCommMonoid M₁
M'₁ : Type ?u.652947
inst✝¹⁵ : TopologicalSpace M'₁
inst✝¹⁴ : AddCommMonoid M'₁
M₂ : Type u_2
inst✝¹³ : TopologicalSpace M₂
inst✝¹² : AddCommMonoid M₂
M₃ : Type ?u.652965
inst✝¹¹ : TopologicalSpace M₃
inst✝¹⁰ : AddCommMonoid M₃
M₄ : Type ?u.652974
inst✝⁹ : TopologicalSpace M₄
inst✝⁸ : AddCommMonoid M₄
inst✝⁷ : Module R₁ M₁
inst✝⁶ : Module R₁ M'₁
inst✝⁵ : Module R₂ M₂
inst✝⁴ : Module R₃ M₃
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
F : Type ?u.653212
inst✝² : Module R₁ M₂
inst✝¹ : TopologicalSpace R₁
inst✝ : ContinuousSMul R₁ M₂
c : R₁ →L[R₁] M₂
⊢ smulRight 1 (↑c 1) = c

tactic: simp [← ContinuousLinearMap.map_smul_of_tower]
state_before: case h
R₁ : Type u_1
R₂ : Type ?u.652857
R₃ : Type ?u.652860
inst✝²⁰ : Semiring R₁
inst✝¹⁹ : Semiring R₂
inst✝¹⁸ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
M₁ : Type ?u.652938
inst✝¹⁷ : TopologicalSpace M₁
inst✝¹⁶ : AddCommMonoid M₁
M'₁ : Type ?u.652947
inst✝¹⁵ : TopologicalSpace M'₁
inst✝¹⁴ : AddCommMonoid M'₁
M₂ : Type u_2
inst✝¹³ : TopologicalSpace M₂
inst✝¹² : AddCommMonoid M₂
M₃ : Type ?u.652965
inst✝¹¹ : TopologicalSpace M₃
inst✝¹⁰ : AddCommMonoid M₃
M₄ : Type ?u.652974
inst✝⁹ : TopologicalSpace M₄
inst✝⁸ : AddCommMonoid M₄
inst✝⁷ : Module R₁ M₁
inst✝⁶ : Module R₁ M'₁
inst✝⁵ : Module R₂ M₂
inst✝⁴ : Module R₃ M₃
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
F : Type ?u.653212
inst✝² : Module R₁ M₂
inst✝¹ : TopologicalSpace R₁
inst✝ : ContinuousSMul R₁ M₂
c : R₁ →L[R₁] M₂
⊢ ↑(smulRight 1 (↑c 1)) 1 = ↑c 1