tasksource/leandojo huggingface dataset:
Theorem: hasFDerivAt_of_subsingleton
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: rw [← hasFDerivWithinAt_univ, subsingleton_univ.eq_singleton_of_mem (mem_univ x)]
state_before: 𝕜 : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.1406680
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.1406775
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x✝ : E
s t : Set E
L L₁ L₂ : Filter E
h : Subsingleton E
f : E → F
x : E
⊢ HasFDerivAt f 0 x

tactic: exact hasFDerivWithinAt_singleton f x
state_before: 𝕜 : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.1406680
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.1406775
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x✝ : E
s t : Set E
L L₁ L₂ : Filter E
h : Subsingleton E
f : E → F
x : E
⊢ HasFDerivWithinAt f 0 {x} x
Theorem: Equiv.symm_trans_swap_trans
File: Mathlib/Logic/Equiv/Basic.lean

tactic: have : ∀ a, e.symm x = a ↔ x = e a := fun a => by
  rw [@eq_comm _ (e.symm x)]
  constructor <;> intros <;> simp_all
state_before: α : Sort u_2
inst✝¹ : DecidableEq α
β : Sort u_1
inst✝ : DecidableEq β
a b : α
e : α ≃ β
x : β
⊢ ↑((e.symm.trans (swap a b)).trans e) x = ↑(swap (↑e a) (↑e b)) x

tactic: simp [trans_apply, swap_apply_def, this]
state_before: α : Sort u_2
inst✝¹ : DecidableEq α
β : Sort u_1
inst✝ : DecidableEq β
a b : α
e : α ≃ β
x : β
this : ∀ (a : (fun x => α) x), ↑e.symm x = a ↔ x = ↑e a
⊢ ↑((e.symm.trans (swap a b)).trans e) x = ↑(swap (↑e a) (↑e b)) x

tactic: split_ifs <;> simp
state_before: α : Sort u_2
inst✝¹ : DecidableEq α
β : Sort u_1
inst✝ : DecidableEq β
a b : α
e : α ≃ β
x : β
this : ∀ (a : (fun x => α) x), ↑e.symm x = a ↔ x = ↑e a
⊢ ↑e (if x = ↑e a then b else if x = ↑e b then a else ↑e.symm x) =
    if x = ↑e a then ↑e b else if x = ↑e b then ↑e a else x

tactic: rw [@eq_comm _ (e.symm x)]
state_before: α : Sort u_2
inst✝¹ : DecidableEq α
β : Sort u_1
inst✝ : DecidableEq β
a✝ b : α
e : α ≃ β
x : β
a : (fun x => α) x
⊢ ↑e.symm x = a ↔ x = ↑e a

tactic: constructor <;> intros <;> simp_all
state_before: α : Sort u_2
inst✝¹ : DecidableEq α
β : Sort u_1
inst✝ : DecidableEq β
a✝ b : α
e : α ≃ β
x : β
a : (fun x => α) x
⊢ a = ↑e.symm x ↔ x = ↑e a
Theorem: trop_iInf
File: Mathlib/Algebra/Tropical/BigOperators.lean

tactic: rw [iInf, ← Set.image_univ, ← coe_univ, trop_sInf_image]
state_before: R : Type u_1
S : Type u_2
inst✝¹ : ConditionallyCompleteLinearOrder R
inst✝ : Fintype S
f : S → WithTop R
⊢ trop (⨅ (i : S), f i) = ∑ i : S, trop (f i)
Theorem: measurable_of_tendsto_nnreal'
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Metrizable.lean

tactic: simp_rw [← measurable_coe_nnreal_ennreal_iff] at hf⊢
state_before: α : Type u_2
β : Type ?u.2014
inst✝⁶ : MeasurableSpace α
inst✝⁵ : TopologicalSpace β
inst✝⁴ : PseudoMetrizableSpace β
inst✝³ : MeasurableSpace β
inst✝² : BorelSpace β
ι : Type u_1
f : ι → α → ℝ≥0
g : α → ℝ≥0
u : Filter ι
inst✝¹ : NeBot u
inst✝ : IsCountablyGenerated u
hf : ∀ (i : ι), Measurable (f i)
lim : Tendsto f u (𝓝 g)
⊢ Measurable g

tactic: refine' measurable_of_tendsto_ennreal' u hf _
state_before: α : Type u_2
β : Type ?u.2014
inst✝⁶ : MeasurableSpace α
inst✝⁵ : TopologicalSpace β
inst✝⁴ : PseudoMetrizableSpace β
inst✝³ : MeasurableSpace β
inst✝² : BorelSpace β
ι : Type u_1
f : ι → α → ℝ≥0
g : α → ℝ≥0
u : Filter ι
inst✝¹ : NeBot u
inst✝ : IsCountablyGenerated u
lim : Tendsto f u (𝓝 g)
hf : ∀ (i : ι), Measurable fun x => ↑(f i x)
⊢ Measurable fun x => ↑(g x)

tactic: rw [tendsto_pi_nhds] at lim⊢
state_before: α : Type u_2
β : Type ?u.2014
inst✝⁶ : MeasurableSpace α
inst✝⁵ : TopologicalSpace β
inst✝⁴ : PseudoMetrizableSpace β
inst✝³ : MeasurableSpace β
inst✝² : BorelSpace β
ι : Type u_1
f : ι → α → ℝ≥0
g : α → ℝ≥0
u : Filter ι
inst✝¹ : NeBot u
inst✝ : IsCountablyGenerated u
lim : Tendsto f u (𝓝 g)
hf : ∀ (i : ι), Measurable fun x => ↑(f i x)
⊢ Tendsto (fun i x => ↑(f i x)) u (𝓝 fun x => ↑(g x))

tactic: exact fun x => (ENNReal.continuous_coe.tendsto (g x)).comp (lim x)
state_before: α : Type u_2
β : Type ?u.2014
inst✝⁶ : MeasurableSpace α
inst✝⁵ : TopologicalSpace β
inst✝⁴ : PseudoMetrizableSpace β
inst✝³ : MeasurableSpace β
inst✝² : BorelSpace β
ι : Type u_1
f : ι → α → ℝ≥0
g : α → ℝ≥0
u : Filter ι
inst✝¹ : NeBot u
inst✝ : IsCountablyGenerated u
lim : ∀ (x : α), Tendsto (fun i => f i x) u (𝓝 (g x))
hf : ∀ (i : ι), Measurable fun x => ↑(f i x)
⊢ ∀ (x : α), Tendsto (fun i => ↑(f i x)) u (𝓝 ↑(g x))
Theorem: CategoryTheory.Subobject.ofLE_mk_le_mk_of_comm
File: Mathlib/CategoryTheory/Subobject/Basic.lean

tactic: ext
state_before: C : Type u₁
inst✝³ : Category C
X Y Z : C
D : Type u₂
inst✝² : Category D
B A₁ A₂ : C
f₁ : A₁ ⟶ B
f₂ : A₂ ⟶ B
inst✝¹ : Mono f₁
inst✝ : Mono f₂
g : A₁ ⟶ A₂
w : g ≫ f₂ = f₁
⊢ ofLE (mk f₁) (mk f₂) (_ : mk f₁ ≤ mk f₂) = (underlyingIso f₁).hom ≫ g ≫ (underlyingIso f₂).inv

tactic: simp [w]
state_before: case h
C : Type u₁
inst✝³ : Category C
X Y Z : C
D : Type u₂
inst✝² : Category D
B A₁ A₂ : C
f₁ : A₁ ⟶ B
f₂ : A₂ ⟶ B
inst✝¹ : Mono f₁
inst✝ : Mono f₂
g : A₁ ⟶ A₂
w : g ≫ f₂ = f₁
⊢ ofLE (mk f₁) (mk f₂) (_ : mk f₁ ≤ mk f₂) ≫ arrow (mk f₂) =
    ((underlyingIso f₁).hom ≫ g ≫ (underlyingIso f₂).inv) ≫ arrow (mk f₂)
Theorem: Polynomial.Chebyshev.one_sub_X_sq_mul_U_eq_pol_in_T
File: Mathlib/RingTheory/Polynomial/Chebyshev.lean

tactic: rw [T_eq_X_mul_T_sub_pol_U, ← sub_add, sub_self, zero_add]
state_before: R : Type u_1
S : Type ?u.37792
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ (1 - X ^ 2) * U R n = X * T R (n + 1) - T R (n + 2)
Theorem: Basis.repr_reindex_apply
File: Mathlib/LinearAlgebra/Basis.lean

tactic: simp
state_before: ι : Type u_4
ι' : Type u_2
R : Type u_1
R₂ : Type ?u.351177
K : Type ?u.351180
M : Type u_3
M' : Type ?u.351186
M'' : Type ?u.351189
V : Type u
V' : Type ?u.351194
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
b' : Basis ι' R M'
e : ι ≃ ι'
i' : ι'
⊢ ↑(↑(Finsupp.domLCongr e) (↑b.repr x)) i' = ↑(↑b.repr x) (↑e.symm i')
Theorem: isLUB_ciSup_set
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: rw [← sSup_image']
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.31436
ι : Sort ?u.31439
inst✝ : ConditionallyCompleteLattice α
s✝ t : Set α
a b : α
f : β → α
s : Set β
H : BddAbove (f '' s)
Hne : Set.Nonempty s
⊢ IsLUB (f '' s) (⨆ (i : ↑s), f ↑i)

tactic: exact isLUB_csSup (Hne.image _) H
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.31436
ι : Sort ?u.31439
inst✝ : ConditionallyCompleteLattice α
s✝ t : Set α
a b : α
f : β → α
s : Set β
H : BddAbove (f '' s)
Hne : Set.Nonempty s
⊢ IsLUB (f '' s) (sSup (f '' s))
Theorem: Int.le_add_of_neg_add_le_right
File: Std/Data/Int/Lemmas.lean

tactic: rw [Int.add_comm] at h
state_before: a b c : Int
h : -c + a ≤ b
⊢ a ≤ b + c

tactic: exact Int.le_add_of_sub_right_le h
state_before: a b c : Int
h : a + -c ≤ b
⊢ a ≤ b + c
Theorem: map_zpow'
File: Mathlib/Algebra/Hom/Group.lean

tactic: rw [zpow_ofNat, map_pow, zpow_ofNat]
state_before: α : Type ?u.55822
β : Type ?u.55825
M : Type ?u.55828
N : Type ?u.55831
P : Type ?u.55834
G : Type u_1
H : Type u_2
F : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : DivInvMonoid G
inst✝¹ : DivInvMonoid H
inst✝ : MonoidHomClass F G H
f : F
hf : ∀ (x : G), ↑f x⁻¹ = (↑f x)⁻¹
a : G
n : ℕ
⊢ ↑f (a ^ ↑n) = ↑f a ^ ↑n

tactic: rw [zpow_negSucc, hf, map_pow, ← zpow_negSucc, ← zpow_negSucc]
state_before: α : Type ?u.55822
β : Type ?u.55825
M : Type ?u.55828
N : Type ?u.55831
P : Type ?u.55834
G : Type u_1
H : Type u_2
F : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : DivInvMonoid G
inst✝¹ : DivInvMonoid H
inst✝ : MonoidHomClass F G H
f : F
hf : ∀ (x : G), ↑f x⁻¹ = (↑f x)⁻¹
a : G
n : ℕ
⊢ ↑f (a ^ Int.negSucc n) = ↑f a ^ Int.negSucc n
Theorem: PartENat.toWithTop_top'
File: Mathlib/Data/Nat/PartENat.lean

tactic: convert toWithTop_top
state_before: h : Decidable ⊤.Dom
⊢ toWithTop ⊤ = ⊤
Theorem: Real.le_rpow_of_log_le
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: obtain hx | rfl := hx.lt_or_eq
state_before: x y z : ℝ
hx : 0 ≤ x
hy : 0 < y
h : log x ≤ z * log y
⊢ x ≤ y ^ z

tactic: exact (Real.rpow_pos_of_pos hy z).le
state_before: case inr
y z : ℝ
hy : 0 < y
hx : 0 ≤ 0
h : log 0 ≤ z * log y
⊢ 0 ≤ y ^ z

tactic: exact (le_rpow_iff_log_le hx hy).2 h
state_before: case inl
x y z : ℝ
hx✝ : 0 ≤ x
hy : 0 < y
h : log x ≤ z * log y
hx : 0 < x
⊢ x ≤ y ^ z
Theorem: Pell.strictMono_y
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: have : yn a1 m ≤ yn a1 n :=
  Or.elim (lt_or_eq_of_le <| Nat.le_of_succ_le_succ h) (fun hl => le_of_lt <| strictMono_y hl)
    fun e => by rw [e]
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : m < n + 1
⊢ yn a1 m < yn a1 (n + 1)

tactic: simp
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : m < n + 1
this : yn a1 m ≤ yn a1 n
⊢ yn a1 m < yn a1 (n + 1)

tactic: refine' lt_of_le_of_lt _ (Nat.lt_add_of_pos_left <| x_pos a1 n)
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : m < n + 1
this : yn a1 m ≤ yn a1 n
⊢ yn a1 m < xn a1 n + yn a1 n * a

tactic: rw [← mul_one (yn a1 m)]
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : m < n + 1
this : yn a1 m ≤ yn a1 n
⊢ yn a1 m ≤ yn a1 n * a

tactic: exact mul_le_mul this (le_of_lt a1) (Nat.zero_le _) (Nat.zero_le _)
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : m < n + 1
this : yn a1 m ≤ yn a1 n
⊢ yn a1 m * 1 ≤ yn a1 n * a

tactic: rw [e]
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : m < n + 1
e : m = n
⊢ yn a1 m ≤ yn a1 n
Theorem: CategoryTheory.Limits.isIso_ι_of_isTerminal
File: Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
J : Type u
inst✝¹ : Category J
j : J
I : IsTerminal j
F : J ⥤ C
inst✝ : HasColimit F
⊢ colimit.ι F j ≫ colimit.desc F (coconeOfDiagramTerminal I F) = 𝟙 (F.obj j)

tactic: ext
state_before: C : Type u₁
inst✝² : Category C
J : Type u
inst✝¹ : Category J
j : J
I : IsTerminal j
F : J ⥤ C
inst✝ : HasColimit F
⊢ colimit.desc F (coconeOfDiagramTerminal I F) ≫ colimit.ι F j = 𝟙 (colimit F)

tactic: simp
state_before: case w
C : Type u₁
inst✝² : Category C
J : Type u
inst✝¹ : Category J
j : J
I : IsTerminal j
F : J ⥤ C
inst✝ : HasColimit F
j✝ : J
⊢ colimit.ι F j✝ ≫ colimit.desc F (coconeOfDiagramTerminal I F) ≫ colimit.ι F j = colimit.ι F j✝ ≫ 𝟙 (colimit F)
Theorem: ClassGroup.mk_mk0
File: Mathlib/RingTheory/ClassGroup.lean

tactic: rw [ClassGroup.mk0, MonoidHom.comp_apply, ← ClassGroup.mk_canonicalEquiv K (FractionRing R),
  FractionalIdeal.map_canonicalEquiv_mk0]
state_before: R : Type u_1
K : Type u_2
L : Type ?u.1219112
inst✝¹¹ : CommRing R
inst✝¹⁰ : Field K
inst✝⁹ : Field L
inst✝⁸ : DecidableEq L
inst✝⁷ : Algebra R K
inst✝⁶ : IsFractionRing R K
inst✝⁵ : Algebra K L
inst✝⁴ : FiniteDimensional K L
inst✝³ : Algebra R L
inst✝² : IsScalarTower R K L
inst✝¹ : IsDomain R
inst✝ : IsDedekindDomain R
I : { x // x ∈ (Ideal R)⁰ }
⊢ ↑mk (↑(FractionalIdeal.mk0 K) I) = ↑mk0 I
Theorem: Finset.min'_singleton
File: Mathlib/Data/Finset/Lattice.lean

tactic: simp [min']
state_before: F : Type ?u.336329
α : Type u_1
β : Type ?u.336335
γ : Type ?u.336338
ι : Type ?u.336341
κ : Type ?u.336344
inst✝ : LinearOrder α
s : Finset α
H : Finset.Nonempty s
x a : α
⊢ min' {a} (_ : Finset.Nonempty {a}) = a
Theorem: Real.sign_one
File: Mathlib/Data/Real/Sign.lean

tactic: norm_num
state_before: ⊢ 0 < 1
Theorem: MeasureTheory.OuterMeasure.le_inter_add_diff
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: convert m.union _ _
state_before: α : Type u_1
β : Type ?u.18650
R : Type ?u.18653
R' : Type ?u.18656
ms : Set (OuterMeasure α)
m✝ m : OuterMeasure α
t s : Set α
⊢ ↑m t ≤ ↑m (t ∩ s) + ↑m (t \ s)

tactic: rw [inter_union_diff t s]
state_before: case h.e'_3.h.e'_3
α : Type u_1
β : Type ?u.18650
R : Type ?u.18653
R' : Type ?u.18656
ms : Set (OuterMeasure α)
m✝ m : OuterMeasure α
t s : Set α
⊢ t = t ∩ s ∪ t \ s
Theorem: RingHom.map_ite_zero_one
File: Mathlib/Algebra/Hom/Ring.lean

tactic: split_ifs with h
state_before: F✝ : Type ?u.81005
α : Type u_2
β : Type u_3
γ : Type ?u.81014
x✝¹ : NonAssocSemiring α
x✝ : NonAssocSemiring β
f✝ : α →+* β
x y : α
F : Type u_1
inst✝¹ : RingHomClass F α β
f : F
p : Prop
inst✝ : Decidable p
⊢ ↑f (if p then 0 else 1) = if p then 0 else 1

tactic: simp only [h, ite_true]
state_before: case inl
F✝ : Type ?u.81005
α : Type u_2
β : Type u_3
γ : Type ?u.81014
x✝¹ : NonAssocSemiring α
x✝ : NonAssocSemiring β
f✝ : α →+* β
x y : α
F : Type u_1
inst✝¹ : RingHomClass F α β
f : F
p : Prop
inst✝ : Decidable p
h : p
⊢ ↑f (if p then 0 else 1) = 0

tactic: rw [map_zero]
state_before: case inl
F✝ : Type ?u.81005
α : Type u_2
β : Type u_3
γ : Type ?u.81014
x✝¹ : NonAssocSemiring α
x✝ : NonAssocSemiring β
f✝ : α →+* β
x y : α
F : Type u_1
inst✝¹ : RingHomClass F α β
f : F
p : Prop
inst✝ : Decidable p
h : p
⊢ ↑f 0 = 0

tactic: simp only [h, ite_false]
state_before: case inr
F✝ : Type ?u.81005
α : Type u_2
β : Type u_3
γ : Type ?u.81014
x✝¹ : NonAssocSemiring α
x✝ : NonAssocSemiring β
f✝ : α →+* β
x y : α
F : Type u_1
inst✝¹ : RingHomClass F α β
f : F
p : Prop
inst✝ : Decidable p
h : ¬p
⊢ ↑f (if p then 0 else 1) = 1

tactic: rw [map_one]
state_before: case inr
F✝ : Type ?u.81005
α : Type u_2
β : Type u_3
γ : Type ?u.81014
x✝¹ : NonAssocSemiring α
x✝ : NonAssocSemiring β
f✝ : α →+* β
x y : α
F : Type u_1
inst✝¹ : RingHomClass F α β
f : F
p : Prop
inst✝ : Decidable p
h : ¬p
⊢ ↑f 1 = 1
Theorem: Polynomial.eq_rootMultiplicity_map
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: by_cases hp0 : p = 0
state_before: R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝¹ : CommRing A
inst✝ : CommRing B
p : A[X]
f : A →+* B
hf : Function.Injective ↑f
a : A
⊢ rootMultiplicity a p = rootMultiplicity (↑f a) (map f p)

tactic: apply le_antisymm (le_rootMultiplicity_map ((Polynomial.map_ne_zero_iff hf).mpr hp0) a)
state_before: case neg
R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝¹ : CommRing A
inst✝ : CommRing B
p : A[X]
f : A →+* B
hf : Function.Injective ↑f
a : A
hp0 : ¬p = 0
⊢ rootMultiplicity a p = rootMultiplicity (↑f a) (map f p)

tactic: rw [le_rootMultiplicity_iff hp0, ← map_dvd_map f hf ((monic_X_sub_C a).pow _),
  Polynomial.map_pow, Polynomial.map_sub, map_X, map_C]
state_before: case neg
R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝¹ : CommRing A
inst✝ : CommRing B
p : A[X]
f : A →+* B
hf : Function.Injective ↑f
a : A
hp0 : ¬p = 0
⊢ rootMultiplicity (↑f a) (map f p) ≤ rootMultiplicity a p

tactic: apply pow_rootMultiplicity_dvd
state_before: case neg
R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝¹ : CommRing A
inst✝ : CommRing B
p : A[X]
f : A →+* B
hf : Function.Injective ↑f
a : A
hp0 : ¬p = 0
⊢ (X - ↑C (↑f a)) ^ rootMultiplicity (↑f a) (map f p) ∣ map f p

tactic: simp only [hp0, rootMultiplicity_zero, Polynomial.map_zero]
state_before: case pos
R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝¹ : CommRing A
inst✝ : CommRing B
p : A[X]
f : A →+* B
hf : Function.Injective ↑f
a : A
hp0 : p = 0
⊢ rootMultiplicity a p = rootMultiplicity (↑f a) (map f p)
Theorem: MvPolynomial.coeff_X'
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: rw [← coeff_X_pow, pow_one]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m✝ : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p q : MvPolynomial σ R
inst✝ : DecidableEq σ
i : σ
m : σ →₀ ℕ
⊢ coeff m (X i) = if Finsupp.single i 1 = m then 1 else 0
Theorem: edist_nndist
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [edist_dist, dist_nndist, ENNReal.ofReal_coe_nnreal]
state_before: α : Type u
β : Type v
X : Type ?u.19532
ι : Type ?u.19535
inst✝ : PseudoMetricSpace α
x y : α
⊢ edist x y = ↑(nndist x y)
Theorem: Nat.Subtype.exists_succ
File: Mathlib/Logic/Denumerable.lean

tactic: rwa [add_right_comm, add_tsub_cancel_of_le hax]
state_before: α : Type ?u.35974
β : Type ?u.35977
s : Set ℕ
inst✝ : Infinite ↑s
x : ↑s
h : ¬∃ n, ↑x + n + 1 ∈ s
a : ℕ
ha : a ∈ s
hax : a ≥ succ ↑x
⊢ ↑x + (a - (↑x + 1)) + 1 ∈ s

tactic: simp [-Multiset.range_succ]
state_before: α : Type ?u.35974
β : Type ?u.35977
s : Set ℕ
inst✝ : Infinite ↑s
x : ↑s
h : ¬∃ n, ↑x + n + 1 ∈ s
this : ∀ (a : ℕ), a ∈ s → a < succ ↑x
⊢ ∀ (a : ℕ), a ∈ Multiset.filter (fun x => x ∈ s) (Multiset.range (succ ↑x)) → a ∈ s

tactic: simpa [Subtype.ext_iff_val, Multiset.mem_filter, -Multiset.range_succ]
state_before: α : Type ?u.35974
β : Type ?u.35977
s : Set ℕ
inst✝ : Infinite ↑s
x : ↑s
h : ¬∃ n, ↑x + n + 1 ∈ s
this : ∀ (a : ℕ), a ∈ s → a < succ ↑x
⊢ ∀ (x_1 : { y // y ∈ s }),
    x_1 ∈
      Multiset.toFinset
        (Multiset.pmap (fun y hy => { val := y, property := hy })
          (Multiset.filter (fun x => x ∈ s) (Multiset.range (succ ↑x)))
          (_ : ∀ (a : ℕ), a ∈ Multiset.filter (fun x => x ∈ s) (Multiset.range (succ ↑x)) → a ∈ s))
Theorem: List.lookmap_cons_none
File: Mathlib/Data/List/Basic.lean

tactic: simp only [lookmap, lookmap.go, Array.toListAppend_eq, Array.data_toArray, nil_append]
state_before: ι : Type ?u.341936
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → Option α
a : α
l : List α
h : f a = none
⊢ lookmap f (a :: l) = a :: lookmap f l

tactic: rw [lookmap.go_append, h]
state_before: ι : Type ?u.341936
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → Option α
a : α
l : List α
h : f a = none
⊢ (match f a with
    | some b => b :: l
    | none => lookmap.go f l (Array.push #[] a)) =
    a :: lookmap.go f l #[]

tactic: rfl
state_before: ι : Type ?u.341936
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → Option α
a : α
l : List α
h : f a = none
⊢ (match none with
    | some b => b :: l
    | none => Array.toListAppend (Array.push #[] a) (lookmap f l)) =
    a :: lookmap.go f l #[]
Theorem: Finsupp.lsingle_range_le_ker_lapply
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: refine' iSup_le fun a₁ => iSup_le fun h₁ => range_le_iff_comap.2 _
state_before: α : Type u_1
M : Type u_2
N : Type ?u.24141
P : Type ?u.24144
R : Type u_3
S : Type ?u.24150
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
s t : Set α
h : Disjoint s t
⊢ (⨆ (a : α) (_ : a ∈ s), LinearMap.range (lsingle a)) ≤ ⨅ (a : α) (_ : a ∈ t), ker (lapply a)

tactic: simp only [(ker_comp _ _).symm, eq_top_iff, SetLike.le_def, mem_ker, comap_iInf, mem_iInf]
state_before: α : Type u_1
M : Type u_2
N : Type ?u.24141
P : Type ?u.24144
R : Type u_3
S : Type ?u.24150
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
s t : Set α
h : Disjoint s t
a₁ : α
h₁ : a₁ ∈ s
⊢ comap (lsingle a₁) (⨅ (a : α) (_ : a ∈ t), ker (lapply a)) = ⊤

tactic: intro b _ a₂ h₂
state_before: α : Type u_1
M : Type u_2
N : Type ?u.24141
P : Type ?u.24144
R : Type u_3
S : Type ?u.24150
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
s t : Set α
h : Disjoint s t
a₁ : α
h₁ : a₁ ∈ s
⊢ ∀ ⦃x : M⦄, x ∈ ⊤ → ∀ (i : α), i ∈ t → x ∈ comap (lsingle a₁) (ker (lapply i))

tactic: have : a₁ ≠ a₂ := fun eq => h.le_bot ⟨h₁, eq.symm ▸ h₂⟩
state_before: α : Type u_1
M : Type u_2
N : Type ?u.24141
P : Type ?u.24144
R : Type u_3
S : Type ?u.24150
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
s t : Set α
h : Disjoint s t
a₁ : α
h₁ : a₁ ∈ s
b : M
a✝ : b ∈ ⊤
a₂ : α
h₂ : a₂ ∈ t
⊢ b ∈ comap (lsingle a₁) (ker (lapply a₂))

tactic: exact single_eq_of_ne this
state_before: α : Type u_1
M : Type u_2
N : Type ?u.24141
P : Type ?u.24144
R : Type u_3
S : Type ?u.24150
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
s t : Set α
h : Disjoint s t
a₁ : α
h₁ : a₁ ∈ s
b : M
a✝ : b ∈ ⊤
a₂ : α
h₂ : a₂ ∈ t
this : a₁ ≠ a₂
⊢ b ∈ comap (lsingle a₁) (ker (lapply a₂))
Theorem: Set.image_eq_empty
File: Mathlib/Data/Set/Image.lean

tactic: simp only [eq_empty_iff_forall_not_mem]
state_before: α✝ : Type ?u.37986
β✝ : Type ?u.37989
γ : Type ?u.37992
ι : Sort ?u.37995
ι' : Sort ?u.37998
f✝ : α✝ → β✝
s✝ t : Set α✝
α : Type u_1
β : Type u_2
f : α → β
s : Set α
⊢ f '' s = ∅ ↔ s = ∅

tactic: exact ⟨fun H a ha => H _ ⟨_, ha, rfl⟩, fun H b ⟨_, ha, _⟩ => H _ ha⟩
state_before: α✝ : Type ?u.37986
β✝ : Type ?u.37989
γ : Type ?u.37992
ι : Sort ?u.37995
ι' : Sort ?u.37998
f✝ : α✝ → β✝
s✝ t : Set α✝
α : Type u_1
β : Type u_2
f : α → β
s : Set α
⊢ (∀ (x : β), ¬x ∈ f '' s) ↔ ∀ (x : α), ¬x ∈ s
Theorem: BddBelow.image2
File: Mathlib/Order/Bounds/Basic.lean

tactic: rintro ⟨a, ha⟩ ⟨b, hb⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a : α
b : β
h₀ : ∀ (b : β), Monotone (swap f b)
h₁ : ∀ (a : α), Monotone (f a)
⊢ BddBelow s → BddBelow t → BddBelow (Set.image2 f s t)

tactic: exact ⟨f a b, mem_lowerBounds_image2 h₀ h₁ ha hb⟩
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a✝ : α
b✝ : β
h₀ : ∀ (b : β), Monotone (swap f b)
h₁ : ∀ (a : α), Monotone (f a)
a : α
ha : a ∈ lowerBounds s
b : β
hb : b ∈ lowerBounds t
⊢ BddBelow (Set.image2 f s t)
Theorem: ENNReal.monotone_rpow_of_nonneg
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: simp only [rpow_zero, monotone_const]
state_before: z : ℝ
h : 0 ≤ z
h0 : 0 = z
⊢ Monotone fun x => x ^ 0
Theorem: MeasureTheory.SignedMeasure.rnDeriv_neg
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

tactic: refine'
  Integrable.ae_eq_of_withDensityᵥ_eq (integrable_rnDeriv _ _) (integrable_rnDeriv _ _).neg _
state_before: α : Type u_1
β : Type ?u.646293
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
inst✝ : HaveLebesgueDecomposition s μ
⊢ rnDeriv (-s) μ =ᶠ[ae μ] -rnDeriv s μ

tactic: rw [withDensityᵥ_neg, ← add_right_inj ((-s).singularPart μ),
  singularPart_add_withDensity_rnDeriv_eq, singularPart_neg, ← neg_add,
  singularPart_add_withDensity_rnDeriv_eq]
state_before: α : Type u_1
β : Type ?u.646293
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
inst✝ : HaveLebesgueDecomposition s μ
⊢ withDensityᵥ μ (rnDeriv (-s) μ) = withDensityᵥ μ (-rnDeriv s μ)