tasksource/leandojo huggingface dataset:
Theorem: Real.summable_pow_div_factorial
File: Mathlib/Analysis/SpecificLimits/Normed.lean

tactic: have A : (0 : ℝ) < ⌊‖x‖⌋₊ + 1 := zero_lt_one.trans_le (by simp)
state_before: α : Type ?u.2025885
β : Type ?u.2025888
ι : Type ?u.2025891
x : ℝ
⊢ Summable fun n => x ^ n / ↑n !

tactic: have B : ‖x‖ / (⌊‖x‖⌋₊ + 1) < 1 := (div_lt_one A).2 (Nat.lt_floor_add_one _)
state_before: α : Type ?u.2025885
β : Type ?u.2025888
ι : Type ?u.2025891
x : ℝ
A : 0 < ↑⌊‖x‖⌋₊ + 1
⊢ Summable fun n => x ^ n / ↑n !

tactic: suffices : ∀ n ≥ ⌊‖x‖⌋₊, ‖x ^ (n + 1) / (n + 1)!‖ ≤ ‖x‖ / (⌊‖x‖⌋₊ + 1) * ‖x ^ n / ↑n !‖
state_before: α : Type ?u.2025885
β : Type ?u.2025888
ι : Type ?u.2025891
x : ℝ
A : 0 < ↑⌊‖x‖⌋₊ + 1
B : ‖x‖ / (↑⌊‖x‖⌋₊ + 1) < 1
⊢ Summable fun n => x ^ n / ↑n !

tactic: exact summable_of_ratio_norm_eventually_le B (eventually_atTop.2 ⟨⌊‖x‖⌋₊, this⟩)
state_before: α : Type ?u.2025885
β : Type ?u.2025888
ι : Type ?u.2025891
x : ℝ
A : 0 < ↑⌊‖x‖⌋₊ + 1
B : ‖x‖ / (↑⌊‖x‖⌋₊ + 1) < 1
this : ∀ (n : ℕ), n ≥ ⌊‖x‖⌋₊ → ‖x ^ (n + 1) / ↑(n + 1)!‖ ≤ ‖x‖ / (↑⌊‖x‖⌋₊ + 1) * ‖x ^ n / ↑n !‖
⊢ Summable fun n => x ^ n / ↑n !

case this
α : Type ?u.2025885
β : Type ?u.2025888
ι : Type ?u.2025891
x : ℝ
A : 0 < ↑⌊‖x‖⌋₊ + 1
B : ‖x‖ / (↑⌊‖x‖⌋₊ + 1) < 1
⊢ ∀ (n : ℕ), n ≥ ⌊‖x‖⌋₊ → ‖x ^ (n + 1) / ↑(n + 1)!‖ ≤ ‖x‖ / (↑⌊‖x‖⌋₊ + 1) * ‖x ^ n / ↑n !‖

tactic: intro n hn
state_before: case this
α : Type ?u.2025885
β : Type ?u.2025888
ι : Type ?u.2025891
x : ℝ
A : 0 < ↑⌊‖x‖⌋₊ + 1
B : ‖x‖ / (↑⌊‖x‖⌋₊ + 1) < 1
⊢ ∀ (n : ℕ), n ≥ ⌊‖x‖⌋₊ → ‖x ^ (n + 1) / ↑(n + 1)!‖ ≤ ‖x‖ / (↑⌊‖x‖⌋₊ + 1) * ‖x ^ n / ↑n !‖

tactic: calc
  ‖x ^ (n + 1) / (n + 1)!‖ = ‖x‖ / (n + 1) * ‖x ^ n / (n !)‖ := by
    rw [_root_.pow_succ, Nat.factorial_succ, Nat.cast_mul, ← _root_.div_mul_div_comm, norm_mul,
      norm_div, Real.norm_coe_nat, Nat.cast_succ]
  _ ≤ ‖x‖ / (⌊‖x‖⌋₊ + 1) * ‖x ^ n / (n !)‖ :=
    mul_le_mul_of_nonneg_right
      (div_le_div (norm_nonneg x) (le_refl ‖x‖) A (add_le_add (mono_cast hn) (le_refl 1)))
      (norm_nonneg (x ^ n / n !))
state_before: case this
α : Type ?u.2025885
β : Type ?u.2025888
ι : Type ?u.2025891
x : ℝ
A : 0 < ↑⌊‖x‖⌋₊ + 1
B : ‖x‖ / (↑⌊‖x‖⌋₊ + 1) < 1
n : ℕ
hn : n ≥ ⌊‖x‖⌋₊
⊢ ‖x ^ (n + 1) / ↑(n + 1)!‖ ≤ ‖x‖ / (↑⌊‖x‖⌋₊ + 1) * ‖x ^ n / ↑n !‖

tactic: simp
state_before: α : Type ?u.2025885
β : Type ?u.2025888
ι : Type ?u.2025891
x : ℝ
⊢ 1 ≤ ↑⌊‖x‖⌋₊ + 1

tactic: rw [_root_.pow_succ, Nat.factorial_succ, Nat.cast_mul, ← _root_.div_mul_div_comm, norm_mul,
  norm_div, Real.norm_coe_nat, Nat.cast_succ]
state_before: α : Type ?u.2025885
β : Type ?u.2025888
ι : Type ?u.2025891
x : ℝ
A : 0 < ↑⌊‖x‖⌋₊ + 1
B : ‖x‖ / (↑⌊‖x‖⌋₊ + 1) < 1
n : ℕ
hn : n ≥ ⌊‖x‖⌋₊
⊢ ‖x ^ (n + 1) / ↑(n + 1)!‖ = ‖x‖ / (↑n + 1) * ‖x ^ n / ↑n !‖
Theorem: cmp_self_eq_eq
File: Mathlib/Order/Compare.lean

tactic: rw [cmp_eq_eq_iff]
state_before: α : Type u_1
β : Type ?u.19132
inst✝ : LinearOrder α
x y : α
⊢ cmp x x = eq
Theorem: CategoryTheory.Sieve.pullback_id
File: Mathlib/CategoryTheory/Sites/Sieves.lean

tactic: simp [Sieve.ext_iff]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
S R : Sieve X
⊢ pullback (𝟙 X) S = S
Theorem: Complex.log_im
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: simp [log]
state_before: x : ℂ
⊢ (log x).im = arg x
Theorem: MonCat.FilteredColimits.colimit_one_eq
File: Mathlib/Algebra/Category/Mon/FilteredColimits.lean

tactic: apply M.mk_eq
state_before: J : Type v
inst✝¹ : SmallCategory J
F : J ⥤ MonCat
inst✝ : IsFiltered J
j : J
⊢ 1 = M.mk F { fst := j, snd := 1 }

tactic: refine' ⟨max' _ j, IsFiltered.leftToMax _ j, IsFiltered.rightToMax _ j, _⟩
state_before: case h
J : Type v
inst✝¹ : SmallCategory J
F : J ⥤ MonCat
inst✝ : IsFiltered J
j : J
⊢ ∃ k f g, ↑(F.map f) { fst := Nonempty.some (_ : Nonempty J), snd := 1 }.snd = ↑(F.map g) { fst := j, snd := 1 }.snd

tactic: simp
state_before: case h
J : Type v
inst✝¹ : SmallCategory J
F : J ⥤ MonCat
inst✝ : IsFiltered J
j : J
⊢ ↑(F.map (IsFiltered.leftToMax { fst := Nonempty.some (_ : Nonempty J), snd := 1 }.fst j))
      { fst := Nonempty.some (_ : Nonempty J), snd := 1 }.snd =
    ↑(F.map (IsFiltered.rightToMax { fst := Nonempty.some (_ : Nonempty J), snd := 1 }.fst j))
      { fst := j, snd := 1 }.snd
Theorem: bernoulli'_four
File: Mathlib/NumberTheory/Bernoulli.lean

tactic: have : Nat.choose 4 2 = 6 := by decide
state_before: A : Type ?u.188932
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
⊢ bernoulli' 4 = -1 / 30

tactic: rw [bernoulli'_def, sum_range_succ, sum_range_succ, sum_range_succ,
  sum_range_succ, sum_range_zero, this]
state_before: A : Type ?u.188932
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
this : Nat.choose 4 2 = 6
⊢ bernoulli' 4 = -1 / 30

tactic: norm_num
state_before: A : Type ?u.188932
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
this : Nat.choose 4 2 = 6
⊢ 1 -
      (0 + ↑(Nat.choose 4 0) / (↑4 - ↑0 + 1) * bernoulli' 0 + ↑(Nat.choose 4 1) / (↑4 - ↑1 + 1) * bernoulli' 1 +
          ↑6 / (↑4 - ↑2 + 1) * bernoulli' 2 +
        ↑(Nat.choose 4 3) / (↑4 - ↑3 + 1) * bernoulli' 3) =
    -1 / 30

tactic: decide
state_before: A : Type ?u.188932
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
⊢ Nat.choose 4 2 = 6
Theorem: MeasureTheory.integral_div_left_eq_self
File: Mathlib/MeasureTheory/Group/Integration.lean

tactic: simp_rw [div_eq_mul_inv]
state_before: 𝕜 : Type ?u.79010
M : Type ?u.79013
α : Type ?u.79016
G : Type u_1
E : Type u_2
F : Type ?u.79025
inst✝⁹ : MeasurableSpace G
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NormedAddCommGroup F
μ✝ : Measure G
f✝ : G → E
g : G
inst✝⁴ : Group G
inst✝³ : MeasurableMul G
inst✝² : MeasurableInv G
f : G → E
μ : Measure G
inst✝¹ : IsInvInvariant μ
inst✝ : IsMulLeftInvariant μ
x' : G
⊢ (∫ (x : G), f (x' / x) ∂μ) = ∫ (x : G), f x ∂μ

tactic: rw [integral_inv_eq_self (fun x => f (x' * x)) μ, integral_mul_left_eq_self f x']
state_before: 𝕜 : Type ?u.79010
M : Type ?u.79013
α : Type ?u.79016
G : Type u_1
E : Type u_2
F : Type ?u.79025
inst✝⁹ : MeasurableSpace G
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NormedAddCommGroup F
μ✝ : Measure G
f✝ : G → E
g : G
inst✝⁴ : Group G
inst✝³ : MeasurableMul G
inst✝² : MeasurableInv G
f : G → E
μ : Measure G
inst✝¹ : IsInvInvariant μ
inst✝ : IsMulLeftInvariant μ
x' : G
⊢ (∫ (x : G), f (x' * x⁻¹) ∂μ) = ∫ (x : G), f x ∂μ
Theorem: Hyperreal.Infinitesimal.neg
File: Mathlib/Data/Real/Hyperreal.lean

tactic: simpa only [neg_zero] using hx.neg
state_before: x : ℝ*
hx : Infinitesimal x
⊢ Infinitesimal (-x)
Theorem: Set.image2_image_left
File: Mathlib/Data/Set/NAry.lean

tactic: ext
state_before: α : Type u_4
α' : Type ?u.33962
β : Type u_3
β' : Type ?u.33968
γ : Type u_2
γ' : Type ?u.33974
δ : Type u_1
δ' : Type ?u.33980
ε : Type ?u.33983
ε' : Type ?u.33986
ζ : Type ?u.33989
ζ' : Type ?u.33992
ν : Type ?u.33995
f✝ f' : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
f : γ → β → δ
g : α → γ
⊢ image2 f (g '' s) t = image2 (fun a b => f (g a) b) s t

tactic: constructor
state_before: case h
α : Type u_4
α' : Type ?u.33962
β : Type u_3
β' : Type ?u.33968
γ : Type u_2
γ' : Type ?u.33974
δ : Type u_1
δ' : Type ?u.33980
ε : Type ?u.33983
ε' : Type ?u.33986
ζ : Type ?u.33989
ζ' : Type ?u.33992
ν : Type ?u.33995
f✝ f' : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
f : γ → β → δ
g : α → γ
x✝ : δ
⊢ x✝ ∈ image2 f (g '' s) t ↔ x✝ ∈ image2 (fun a b => f (g a) b) s t

tactic: rintro ⟨_, b, ⟨a, ha, rfl⟩, hb, rfl⟩
state_before: case h.mp
α : Type u_4
α' : Type ?u.33962
β : Type u_3
β' : Type ?u.33968
γ : Type u_2
γ' : Type ?u.33974
δ : Type u_1
δ' : Type ?u.33980
ε : Type ?u.33983
ε' : Type ?u.33986
ζ : Type ?u.33989
ζ' : Type ?u.33992
ν : Type ?u.33995
f✝ f' : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
f : γ → β → δ
g : α → γ
x✝ : δ
⊢ x✝ ∈ image2 f (g '' s) t → x✝ ∈ image2 (fun a b => f (g a) b) s t

tactic: refine' ⟨a, b, ha, hb, rfl⟩
state_before: case h.mp.intro.intro.intro.intro.intro.intro
α : Type u_4
α' : Type ?u.33962
β : Type u_3
β' : Type ?u.33968
γ : Type u_2
γ' : Type ?u.33974
δ : Type u_1
δ' : Type ?u.33980
ε : Type ?u.33983
ε' : Type ?u.33986
ζ : Type ?u.33989
ζ' : Type ?u.33992
ν : Type ?u.33995
f✝ f' : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a✝ a' : α
b✝ b' : β
c c' : γ
d d' : δ
f : γ → β → δ
g : α → γ
b : β
a : α
ha : a ∈ s
hb : b ∈ t
⊢ f (g a) b ∈ image2 (fun a b => f (g a) b) s t

tactic: rintro ⟨a, b, ha, hb, rfl⟩
state_before: case h.mpr
α : Type u_4
α' : Type ?u.33962
β : Type u_3
β' : Type ?u.33968
γ : Type u_2
γ' : Type ?u.33974
δ : Type u_1
δ' : Type ?u.33980
ε : Type ?u.33983
ε' : Type ?u.33986
ζ : Type ?u.33989
ζ' : Type ?u.33992
ν : Type ?u.33995
f✝ f' : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
f : γ → β → δ
g : α → γ
x✝ : δ
⊢ x✝ ∈ image2 (fun a b => f (g a) b) s t → x✝ ∈ image2 f (g '' s) t

tactic: refine' ⟨_, b, ⟨a, ha, rfl⟩, hb, rfl⟩
state_before: case h.mpr.intro.intro.intro.intro
α : Type u_4
α' : Type ?u.33962
β : Type u_3
β' : Type ?u.33968
γ : Type u_2
γ' : Type ?u.33974
δ : Type u_1
δ' : Type ?u.33980
ε : Type ?u.33983
ε' : Type ?u.33986
ζ : Type ?u.33989
ζ' : Type ?u.33992
ν : Type ?u.33995
f✝ f' : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a✝ a' : α
b✝ b' : β
c c' : γ
d d' : δ
f : γ → β → δ
g : α → γ
a : α
b : β
ha : a ∈ s
hb : b ∈ t
⊢ (fun a b => f (g a) b) a b ∈ image2 f (g '' s) t
Theorem: comap_norm_nhds_one
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simpa only [dist_one_right] using nhds_comap_dist (1 : E)
state_before: 𝓕 : Type ?u.451724
𝕜 : Type ?u.451727
α : Type ?u.451730
ι : Type ?u.451733
κ : Type ?u.451736
E : Type u_1
F : Type ?u.451742
G : Type ?u.451745
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
⊢ comap norm (𝓝 0) = 𝓝 1
Theorem: Filter.Subsingleton.atTop_eq
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: refine' top_unique fun s hs x => _
state_before: ι : Type ?u.24415
ι' : Type ?u.24418
α✝ : Type ?u.24421
β : Type ?u.24424
γ : Type ?u.24427
α : Type u_1
inst✝¹ : Subsingleton α
inst✝ : Preorder α
⊢ atTop = ⊤

tactic: rw [atTop, ciInf_subsingleton x, mem_principal] at hs
state_before: ι : Type ?u.24415
ι' : Type ?u.24418
α✝ : Type ?u.24421
β : Type ?u.24424
γ : Type ?u.24427
α : Type u_1
inst✝¹ : Subsingleton α
inst✝ : Preorder α
s : Set α
hs : s ∈ atTop
x : α
⊢ x ∈ s

tactic: exact hs left_mem_Ici
state_before: ι : Type ?u.24415
ι' : Type ?u.24418
α✝ : Type ?u.24421
β : Type ?u.24424
γ : Type ?u.24427
α : Type u_1
inst✝¹ : Subsingleton α
inst✝ : Preorder α
s : Set α
x : α
hs : Ici x ⊆ s
⊢ x ∈ s
Theorem: Module.injective_object_of_injective_module
File: Mathlib/Algebra/Module/Injective.lean

tactic: rcases Module.Injective.out _ _ f ((ModuleCat.mono_iff_injective f).mp mn) g with ⟨h, eq1⟩
state_before: R : Type u
inst✝³ : Ring R
Q : TypeMax
inst✝² : AddCommGroup Q
inst✝¹ : Module R Q
inst✝ : Injective R Q
X✝ Y✝ : ModuleCat R
g : X✝ ⟶ ModuleCat.mk Q
f : X✝ ⟶ Y✝
mn : CategoryTheory.Mono f
⊢ ∃ h, f ≫ h = g

tactic: exact ⟨h, LinearMap.ext eq1⟩
state_before: case intro
R : Type u
inst✝³ : Ring R
Q : TypeMax
inst✝² : AddCommGroup Q
inst✝¹ : Module R Q
inst✝ : Injective R Q
X✝ Y✝ : ModuleCat R
g : X✝ ⟶ ModuleCat.mk Q
f : X✝ ⟶ Y✝
mn : CategoryTheory.Mono f
h : ↑Y✝ →ₗ[R] ↑(ModuleCat.mk Q)
eq1 : ∀ (x : ↑X✝), ↑h (↑f x) = ↑g x
⊢ ∃ h, f ≫ h = g
Theorem: FirstOrder.Language.BoundedFormula.realize_relabelEquiv
File: Mathlib/ModelTheory/Semantics.lean

tactic: simp only [relabelEquiv, mapTermRelEquiv_apply, Equiv.coe_refl]
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.163438
P : Type ?u.163441
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
g : α ≃ β
k : ℕ
φ : BoundedFormula L α k
v : β → M
xs : Fin k → M
⊢ Realize (↑(relabelEquiv g) φ) v xs ↔ Realize φ (v ∘ ↑g) xs

tactic: refine' realize_mapTermRel_id (fun n t xs => _) fun _ _ _ => rfl
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.163438
P : Type ?u.163441
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
g : α ≃ β
k : ℕ
φ : BoundedFormula L α k
v : β → M
xs : Fin k → M
⊢ Realize
      (mapTermRel (fun n => ↑(Term.relabelEquiv (Equiv.sumCongr g (_root_.Equiv.refl (Fin n))))) (fun n => id)
        (fun x => id) φ)
      v xs ↔
    Realize φ (v ∘ ↑g) xs

tactic: simp only [relabelEquiv_apply, Term.realize_relabel]
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.163438
P : Type ?u.163441
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
g : α ≃ β
k : ℕ
φ : BoundedFormula L α k
v : β → M
xs✝ : Fin k → M
n : ℕ
t : Term L (α ⊕ Fin n)
xs : Fin n → M
⊢ realize (Sum.elim v xs) (↑(Term.relabelEquiv (Equiv.sumCongr g (_root_.Equiv.refl (Fin n)))) t) =
    realize (Sum.elim (v ∘ ↑g) xs) t

tactic: refine' congr (congr rfl _) rfl
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.163438
P : Type ?u.163441
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
g : α ≃ β
k : ℕ
φ : BoundedFormula L α k
v : β → M
xs✝ : Fin k → M
n : ℕ
t : Term L (α ⊕ Fin n)
xs : Fin n → M
⊢ realize (Sum.elim v xs ∘ ↑(Equiv.sumCongr g (_root_.Equiv.refl (Fin n)))) t = realize (Sum.elim (v ∘ ↑g) xs) t

tactic: ext (i | i) <;> rfl
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.163438
P : Type ?u.163441
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝¹ : Fin l → M
g : α ≃ β
k : ℕ
φ : BoundedFormula L α k
v : β → M
xs✝ : Fin k → M
n : ℕ
t : Term L (α ⊕ Fin n)
xs : Fin n → M
⊢ Sum.elim v xs ∘ ↑(Equiv.sumCongr g (_root_.Equiv.refl (Fin n))) = Sum.elim (v ∘ ↑g) xs
Theorem: IsCompl.symmDiff_eq_top
File: Mathlib/Order/SymmDiff.lean

tactic: rw [h.eq_hnot, hnot_symmDiff_self]
state_before: ι : Type ?u.56328
α : Type u_1
β : Type ?u.56334
π : ι → Type ?u.56339
inst✝ : CoheytingAlgebra α
a✝ a b : α
h : IsCompl a b
⊢ a ∆ b = ⊤
Theorem: Quaternion.normSq_star
File: Mathlib/Algebra/Quaternion.lean

tactic: simp [normSq_def']
state_before: S : Type ?u.588276
T : Type ?u.588279
R : Type u_1
inst✝ : CommRing R
r x y z : R
a b c : ℍ[R]
⊢ ↑normSq (star a) = ↑normSq a
Theorem: Polynomial.splits_of_splits_id
File: Mathlib/Data/Polynomial/Splits.lean

tactic: decide
state_before: F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f x✝¹ : K[X]
hu : IsUnit x✝¹
x✝ : Splits (RingHom.id K) x✝¹
⊢ 0 ≤ 1

tactic: rw [map_id]
state_before: F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f a p : K[X]
ha0 : a ≠ 0
hp : Prime p
ih : Splits (RingHom.id K) a → Splits i a
hfi : Splits (RingHom.id K) (p * a)
⊢ p ∣ map (RingHom.id K) p
Theorem: HomologicalComplex.Hom.next_eq
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

tactic: obtain rfl := c.next_eq' w
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C C₁ C₂ C₃ : HomologicalComplex V c
f : Hom C₁ C₂
i j : ι
w : ComplexShape.Rel c i j
⊢ next f i = (xNextIso C₁ w).hom ≫ HomologicalComplex.Hom.f f j ≫ (xNextIso C₂ w).inv

tactic: simp only [xNextIso, eqToIso_refl, Iso.refl_hom, Iso.refl_inv, comp_id, id_comp]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C C₁ C₂ C₃ : HomologicalComplex V c
f : Hom C₁ C₂
i : ι
w : ComplexShape.Rel c i (ComplexShape.next c i)
⊢ next f i = (xNextIso C₁ w).hom ≫ HomologicalComplex.Hom.f f (ComplexShape.next c i) ≫ (xNextIso C₂ w).inv
Theorem: OpenEmbedding.locallyCompactSpace
File: Mathlib/Topology/SubsetProperties.lean

tactic: have : ∀ x : α, (𝓝 x).HasBasis
    (fun s => (s ∈ 𝓝 (f x) ∧ IsCompact s) ∧ s ⊆ range f) fun s => f ⁻¹' s := by
  intro x
  rw [hf.toInducing.nhds_eq_comap]
  exact
    ((compact_basis_nhds _).restrict_subset <| hf.open_range.mem_nhds <| mem_range_self _).comap _
state_before: α : Type u
β : Type v
ι : Type ?u.150029
π : ι → Type ?u.150034
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
s t : Set α
inst✝ : LocallyCompactSpace β
f : α → β
hf : OpenEmbedding f
⊢ LocallyCompactSpace α

tactic: refine' locallyCompactSpace_of_hasBasis this fun x s hs => _
state_before: α : Type u
β : Type v
ι : Type ?u.150029
π : ι → Type ?u.150034
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
s t : Set α
inst✝ : LocallyCompactSpace β
f : α → β
hf : OpenEmbedding f
this : ∀ (x : α), HasBasis (𝓝 x) (fun s => (s ∈ 𝓝 (f x) ∧ IsCompact s) ∧ s ⊆ range f) fun s => f ⁻¹' s
⊢ LocallyCompactSpace α

tactic: rw [← hf.toInducing.isCompact_iff, image_preimage_eq_of_subset hs.2]
state_before: α : Type u
β : Type v
ι : Type ?u.150029
π : ι → Type ?u.150034
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
s✝ t : Set α
inst✝ : LocallyCompactSpace β
f : α → β
hf : OpenEmbedding f
this : ∀ (x : α), HasBasis (𝓝 x) (fun s => (s ∈ 𝓝 (f x) ∧ IsCompact s) ∧ s ⊆ range f) fun s => f ⁻¹' s
x : α
s : Set β
hs : (s ∈ 𝓝 (f x) ∧ IsCompact s) ∧ s ⊆ range f
⊢ IsCompact (f ⁻¹' s)

tactic: exact hs.1.2
state_before: α : Type u
β : Type v
ι : Type ?u.150029
π : ι → Type ?u.150034
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
s✝ t : Set α
inst✝ : LocallyCompactSpace β
f : α → β
hf : OpenEmbedding f
this : ∀ (x : α), HasBasis (𝓝 x) (fun s => (s ∈ 𝓝 (f x) ∧ IsCompact s) ∧ s ⊆ range f) fun s => f ⁻¹' s
x : α
s : Set β
hs : (s ∈ 𝓝 (f x) ∧ IsCompact s) ∧ s ⊆ range f
⊢ IsCompact s

tactic: intro x
state_before: α : Type u
β : Type v
ι : Type ?u.150029
π : ι → Type ?u.150034
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
s t : Set α
inst✝ : LocallyCompactSpace β
f : α → β
hf : OpenEmbedding f
⊢ ∀ (x : α), HasBasis (𝓝 x) (fun s => (s ∈ 𝓝 (f x) ∧ IsCompact s) ∧ s ⊆ range f) fun s => f ⁻¹' s

tactic: rw [hf.toInducing.nhds_eq_comap]
state_before: α : Type u
β : Type v
ι : Type ?u.150029
π : ι → Type ?u.150034
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
s t : Set α
inst✝ : LocallyCompactSpace β
f : α → β
hf : OpenEmbedding f
x : α
⊢ HasBasis (𝓝 x) (fun s => (s ∈ 𝓝 (f x) ∧ IsCompact s) ∧ s ⊆ range f) fun s => f ⁻¹' s

tactic: exact
  ((compact_basis_nhds _).restrict_subset <| hf.open_range.mem_nhds <| mem_range_self _).comap _
state_before: α : Type u
β : Type v
ι : Type ?u.150029
π : ι → Type ?u.150034
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
s t : Set α
inst✝ : LocallyCompactSpace β
f : α → β
hf : OpenEmbedding f
x : α
⊢ HasBasis (comap f (𝓝 (f x))) (fun s => (s ∈ 𝓝 (f x) ∧ IsCompact s) ∧ s ⊆ range f) fun s => f ⁻¹' s
Theorem: SimpleGraph.is3Clique_triple_iff
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

tactic: simp only [isNClique_iff, isClique_iff, Set.pairwise_insert_of_symmetric G.symm, coe_insert]
state_before: α : Type u_1
G H : SimpleGraph α
n : ℕ
s : Finset α
inst✝ : DecidableEq α
a b c : α
⊢ IsNClique G 3 {a, b, c} ↔ Adj G a b ∧ Adj G a c ∧ Adj G b c

tactic: by_cases hab : a = b <;> by_cases hbc : b = c <;> by_cases hac : a = c <;> subst_vars <;>
  simp [G.ne_of_adj, and_rotate, *]
state_before: α : Type u_1
G H : SimpleGraph α
n : ℕ
s : Finset α
inst✝ : DecidableEq α
a b c : α
⊢ ((Set.Pairwise (↑{c}) G.Adj ∧ ∀ (b_1 : α), b_1 ∈ ↑{c} → b ≠ b_1 → Adj G b b_1) ∧
        ∀ (b_1 : α), b_1 ∈ insert b ↑{c} → a ≠ b_1 → Adj G a b_1) ∧
      Finset.card {a, b, c} = 3 ↔
    Adj G a b ∧ Adj G a c ∧ Adj G b c
Theorem: exp_zsmul
File: Mathlib/Analysis/NormedSpace/Exponential.lean

tactic: obtain ⟨n, rfl | rfl⟩ := z.eq_nat_or_neg
state_before: 𝕂 : Type u_2
𝔸 : Type u_1
inst✝³ : IsROrC 𝕂
inst✝² : NormedDivisionRing 𝔸
inst✝¹ : NormedAlgebra 𝕂 𝔸
inst✝ : CompleteSpace 𝔸
z : ℤ
x : 𝔸
⊢ exp 𝕂 (z • x) = exp 𝕂 x ^ z

tactic: rw [zpow_ofNat, coe_nat_zsmul, exp_nsmul]
state_before: case intro.inl
𝕂 : Type u_2
𝔸 : Type u_1
inst✝³ : IsROrC 𝕂
inst✝² : NormedDivisionRing 𝔸
inst✝¹ : NormedAlgebra 𝕂 𝔸
inst✝ : CompleteSpace 𝔸
x : 𝔸
n : ℕ
⊢ exp 𝕂 (↑n • x) = exp 𝕂 x ^ ↑n

tactic: rw [zpow_neg, zpow_ofNat, neg_smul, exp_neg, coe_nat_zsmul, exp_nsmul]
state_before: case intro.inr
𝕂 : Type u_2
𝔸 : Type u_1
inst✝³ : IsROrC 𝕂
inst✝² : NormedDivisionRing 𝔸
inst✝¹ : NormedAlgebra 𝕂 𝔸
inst✝ : CompleteSpace 𝔸
x : 𝔸
n : ℕ
⊢ exp 𝕂 (-↑n • x) = exp 𝕂 x ^ (-↑n)
Theorem: ContinuousLinearMap.nonlinearRightInverseOfSurjective_nnnorm_pos
File: Mathlib/Analysis/NormedSpace/Banach.lean

tactic: rw [nonlinearRightInverseOfSurjective]
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
f✝ : E →L[𝕜] F
inst✝¹ : CompleteSpace F
inst✝ : CompleteSpace E
f : E →L[𝕜] F
hsurj : LinearMap.range f = ⊤
⊢ 0 < (nonlinearRightInverseOfSurjective f hsurj).nnnorm

tactic: exact Classical.choose_spec (exists_nonlinearRightInverse_of_surjective f hsurj)
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
f✝ : E →L[𝕜] F
inst✝¹ : CompleteSpace F
inst✝ : CompleteSpace E
f : E →L[𝕜] F
hsurj : LinearMap.range f = ⊤
⊢ 0 < (Classical.choose (_ : ∃ fsymm, 0 < fsymm.nnnorm)).nnnorm
Theorem: integrableOn_Ici_iff_integrableOn_Ioi
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: rw [measure_singleton]
state_before: α : Type u_1
β : Type ?u.4570798
E : Type u_2
F : Type ?u.4570804
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
inst✝² : PartialOrder α
inst✝¹ : MeasurableSingletonClass α
f : α → E
μ : MeasureTheory.Measure α
a b : α
inst✝ : NoAtoms μ
⊢ ↑↑μ {b} ≠ ⊤

tactic: exact ENNReal.zero_ne_top
state_before: α : Type u_1
β : Type ?u.4570798
E : Type u_2
F : Type ?u.4570804
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
inst✝² : PartialOrder α
inst✝¹ : MeasurableSingletonClass α
f : α → E
μ : MeasureTheory.Measure α
a b : α
inst✝ : NoAtoms μ
⊢ 0 ≠ ⊤
Theorem: Convex.combo_affine_apply
File: Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean

tactic: simp only [Convex.combo_eq_smul_sub_add h, ← vsub_eq_sub]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : Ring 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
a b : 𝕜
f : E →ᵃ[𝕜] F
h : a + b = 1
⊢ ↑f (a • x + b • y) = a • ↑f x + b • ↑f y

tactic: exact f.apply_lineMap _ _ _
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : Ring 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
a b : 𝕜
f : E →ᵃ[𝕜] F
h : a + b = 1
⊢ ↑f (b • (y -ᵥ x) + x) = b • (↑f y -ᵥ ↑f x) + ↑f x