tasksource/leandojo huggingface dataset:
Theorem: MonoidAlgebra.support_mul_single_subset
File: Mathlib/Algebra/MonoidAlgebra/Support.lean

tactic: intro x hx
state_before: k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
a : G
⊢ (f * single a r).support ⊆ image (fun x => x * a) f.support

tactic: contrapose hx
state_before: k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
a x : G
hx : x ∈ (f * single a r).support
⊢ x ∈ image (fun x => x * a) f.support

tactic: have : ∀ y, y * a = x → f y = 0 := by
  simpa only [not_and', mem_image, mem_support_iff, exists_prop, not_exists,
    Classical.not_not] using hx
state_before: k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
a x : G
hx : ¬x ∈ image (fun x => x * a) f.support
⊢ ¬x ∈ (f * single a r).support

tactic: simp only [mem_support_iff, mul_apply, sum_single_index, zero_mul, ite_self, sum_zero,
  Classical.not_not]
state_before: k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
a x : G
hx : ¬x ∈ image (fun x => x * a) f.support
this : ∀ (y : G), y * a = x → ↑f y = 0
⊢ ¬x ∈ (f * single a r).support

tactic: exact
  Finset.sum_eq_zero
    (by
      simp (config := { contextual := true }) only [this, sum_single_index, ite_eq_right_iff,
        eq_self_iff_true, imp_true_iff, zero_mul])
state_before: k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
a x : G
hx : ¬x ∈ image (fun x => x * a) f.support
this : ∀ (y : G), y * a = x → ↑f y = 0
⊢ (sum f fun a₁ b₁ => sum (single a r) fun a₂ b₂ => if a₁ * a₂ = x then b₁ * b₂ else 0) = 0

tactic: simpa only [not_and', mem_image, mem_support_iff, exists_prop, not_exists,
  Classical.not_not] using hx
state_before: k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
a x : G
hx : ¬x ∈ image (fun x => x * a) f.support
⊢ ∀ (y : G), y * a = x → ↑f y = 0

tactic: simp (config := { contextual := true }) only [this, sum_single_index, ite_eq_right_iff,
  eq_self_iff_true, imp_true_iff, zero_mul]
state_before: k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
a x : G
hx : ¬x ∈ image (fun x => x * a) f.support
this : ∀ (y : G), y * a = x → ↑f y = 0
⊢ ∀ (x_1 : G),
    x_1 ∈ f.support → (fun a₁ b₁ => sum (single a r) fun a₂ b₂ => if a₁ * a₂ = x then b₁ * b₂ else 0) x_1 (↑f x_1) = 0
Theorem: Finsupp.support_filter
File: Mathlib/Data/Finsupp/Basic.lean

tactic: rw [Subsingleton.elim D] <;> rfl
state_before: α : Type u_1
β : Type ?u.473976
γ : Type ?u.473979
ι : Type ?u.473982
M : Type u_2
M' : Type ?u.473988
N : Type ?u.473991
P : Type ?u.473994
G : Type ?u.473997
H : Type ?u.474000
R : Type ?u.474003
S : Type ?u.474006
inst✝ : Zero M
p : α → Prop
f : α →₀ M
D : DecidablePred p
⊢ (filter p f).support = Finset.filter p f.support
Theorem: List.set_set
File: Std/Data/List/Lemmas.lean

tactic: simp
state_before: α : Type u_1
a b : α
x✝ : Nat
⊢ set (set [] x✝ a) x✝ b = set [] x✝ b

tactic: simp [set]
state_before: α : Type u_1
a b head✝ : α
tail✝ : List α
⊢ set (set (head✝ :: tail✝) 0 a) 0 b = set (head✝ :: tail✝) 0 b

tactic: simp [set, set_set]
state_before: α : Type u_1
a b head✝ : α
tail✝ : List α
n✝ : Nat
⊢ set (set (head✝ :: tail✝) (n✝ + 1) a) (n✝ + 1) b = set (head✝ :: tail✝) (n✝ + 1) b
Theorem: Bool.false_and
File: src/lean/Init/SimpLemmas.lean

tactic: cases b <;> rfl
state_before: b : Bool
⊢ (false && b) = false
Theorem: semiconjBy_iff_eq
File: Mathlib/Algebra/Group/Semiconj.lean

tactic: rw [h, SemiconjBy, mul_comm]
state_before: M : Type u_1
inst✝ : CancelCommMonoid M
a x y : M
h : x = y
⊢ SemiconjBy a x y
Theorem: LiouvilleNumber.partialSum_eq_rat
File: Mathlib/NumberTheory/Liouville/LiouvilleNumber.lean

tactic: induction' k with k h
state_before: m : ℕ
hm : 0 < m
k : ℕ
⊢ ∃ p, partialSum (↑m) k = ↑p / ↑(m ^ k !)

tactic: exact ⟨1, by rw [partialSum, range_one, sum_singleton, Nat.cast_one, Nat.factorial,
  pow_one, pow_one]⟩
state_before: case zero
m : ℕ
hm : 0 < m
⊢ ∃ p, partialSum (↑m) Nat.zero = ↑p / ↑(m ^ Nat.zero !)

tactic: rw [partialSum, range_one, sum_singleton, Nat.cast_one, Nat.factorial,
pow_one, pow_one]
state_before: m : ℕ
hm : 0 < m
⊢ partialSum (↑m) Nat.zero = ↑1 / ↑(m ^ Nat.zero !)

tactic: rcases h with ⟨p_k, h_k⟩
state_before: case succ
m : ℕ
hm : 0 < m
k : ℕ
h : ∃ p, partialSum (↑m) k = ↑p / ↑(m ^ k !)
⊢ ∃ p, partialSum (↑m) (Nat.succ k) = ↑p / ↑(m ^ (Nat.succ k)!)

tactic: use p_k * m ^ ((k + 1)! - k !) + 1
state_before: case succ.intro
m : ℕ
hm : 0 < m
k p_k : ℕ
h_k : partialSum (↑m) k = ↑p_k / ↑(m ^ k !)
⊢ ∃ p, partialSum (↑m) (Nat.succ k) = ↑p / ↑(m ^ (Nat.succ k)!)

tactic: rw [partialSum_succ, h_k, div_add_div, div_eq_div_iff, add_mul]
state_before: case succ.intro
m : ℕ
hm : 0 < m
k p_k : ℕ
h_k : partialSum (↑m) k = ↑p_k / ↑(m ^ k !)
⊢ partialSum (↑m) (Nat.succ k) = ↑(p_k * m ^ ((k + 1)! - k !) + 1) / ↑(m ^ (Nat.succ k)!)

tactic: all_goals positivity
state_before: case succ.intro.hb
m : ℕ
hm : 0 < m
k p_k : ℕ
h_k : partialSum (↑m) k = ↑p_k / ↑(m ^ k !)
⊢ ↑(m ^ k !) * ↑m ^ (k + 1)! ≠ 0

case succ.intro.hd
m : ℕ
hm : 0 < m
k p_k : ℕ
h_k : partialSum (↑m) k = ↑p_k / ↑(m ^ k !)
⊢ ↑(m ^ (Nat.succ k)!) ≠ 0

case succ.intro.hb
m : ℕ
hm : 0 < m
k p_k : ℕ
h_k : partialSum (↑m) k = ↑p_k / ↑(m ^ k !)
⊢ ↑(m ^ k !) ≠ 0

case succ.intro.hd
m : ℕ
hm : 0 < m
k p_k : ℕ
h_k : partialSum (↑m) k = ↑p_k / ↑(m ^ k !)
⊢ ↑m ^ (k + 1)! ≠ 0

tactic: norm_cast
state_before: case succ.intro
m : ℕ
hm : 0 < m
k p_k : ℕ
h_k : partialSum (↑m) k = ↑p_k / ↑(m ^ k !)
⊢ ↑p_k * ↑m ^ (k + 1)! * ↑(m ^ (Nat.succ k)!) + ↑(m ^ k !) * 1 * ↑(m ^ (Nat.succ k)!) =
    ↑(p_k * m ^ ((k + 1)! - k !) + 1) * (↑(m ^ k !) * ↑m ^ (k + 1)!)

tactic: rw [add_mul, one_mul, Nat.factorial_succ, add_mul, one_mul, add_tsub_cancel_right, pow_add]
state_before: case succ.intro
m : ℕ
hm : 0 < m
k p_k : ℕ
h_k : partialSum (↑m) k = ↑p_k / ↑(m ^ k !)
⊢ p_k * m ^ (k + 1)! * m ^ (Nat.succ k)! + m ^ k ! * 1 * m ^ (Nat.succ k)! =
    (p_k * m ^ ((k + 1)! - k !) + 1) * (m ^ k ! * m ^ (k + 1)!)

tactic: simp [mul_assoc]
state_before: case succ.intro
m : ℕ
hm : 0 < m
k p_k : ℕ
h_k : partialSum (↑m) k = ↑p_k / ↑(m ^ k !)
⊢ p_k * (m ^ (k * k !) * m ^ k !) * (m ^ (k * k !) * m ^ k !) + m ^ k ! * 1 * (m ^ (k * k !) * m ^ k !) =
    p_k * m ^ (k * k !) * (m ^ k ! * (m ^ (k * k !) * m ^ k !)) + m ^ k ! * (m ^ (k * k !) * m ^ k !)

tactic: positivity
state_before: case succ.intro.hd
m : ℕ
hm : 0 < m
k p_k : ℕ
h_k : partialSum (↑m) k = ↑p_k / ↑(m ^ k !)
⊢ ↑m ^ (k + 1)! ≠ 0
Theorem: OneHom.comp_one
File: Mathlib/Algebra/Hom/Group.lean

tactic: ext
state_before: α : Type ?u.197112
β : Type ?u.197115
M : Type u_1
N : Type u_2
P : Type u_3
G : Type ?u.197127
H : Type ?u.197130
F : Type ?u.197133
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
f : OneHom N P
⊢ comp f 1 = 1

tactic: simp only [OneHom.map_one, OneHom.coe_comp, Function.comp_apply, OneHom.one_apply]
state_before: case h
α : Type ?u.197112
β : Type ?u.197115
M : Type u_1
N : Type u_2
P : Type u_3
G : Type ?u.197127
H : Type ?u.197130
F : Type ?u.197133
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
f : OneHom N P
x✝ : M
⊢ ↑(comp f 1) x✝ = ↑1 x✝
Theorem: finrank_span_set_eq_card
File: Mathlib/LinearAlgebra/Finrank.lean

tactic: have : Module.rank K (span K s) = (#s) := rank_span_set hs
state_before: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
s : Set V
inst✝ : Fintype ↑s
hs : LinearIndependent K Subtype.val
⊢ Module.rank K { x // x ∈ span K s } = ↑(Finset.card (Set.toFinset s))

tactic: rwa [Cardinal.mk_fintype, ← Set.toFinset_card] at this
state_before: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
s : Set V
inst✝ : Fintype ↑s
hs : LinearIndependent K Subtype.val
this : Module.rank K { x // x ∈ span K s } = (#↑s)
⊢ Module.rank K { x // x ∈ span K s } = ↑(Finset.card (Set.toFinset s))
Theorem: PFunctor.Approx.P_corec
File: Mathlib/Data/PFunctor/Univariate/M.lean

tactic: induction' n with n n_ih generalizing i
state_before: F : PFunctor
X : Type w
f : X → Obj F X
i : X
n : ℕ
⊢ Agree (sCorec f i n) (sCorec f i (succ n))

tactic: constructor
state_before: case zero
F : PFunctor
X : Type w
f : X → Obj F X
i✝ i : X
⊢ Agree (sCorec f i zero) (sCorec f i (succ zero))

case succ
F : PFunctor
X : Type w
f : X → Obj F X
i✝ : X
n : ℕ
n_ih : ∀ (i : X), Agree (sCorec f i n) (sCorec f i (succ n))
i : X
⊢ Agree (sCorec f i (succ n)) (sCorec f i (succ (succ n)))

tactic: cases' h : f i with y g
state_before: case succ
F : PFunctor
X : Type w
f : X → Obj F X
i✝ : X
n : ℕ
n_ih : ∀ (i : X), Agree (sCorec f i n) (sCorec f i (succ n))
i : X
⊢ Agree (sCorec f i (succ n)) (sCorec f i (succ (succ n)))

tactic: constructor
state_before: case succ.mk
F : PFunctor
X : Type w
f : X → Obj F X
i✝ : X
n : ℕ
n_ih : ∀ (i : X), Agree (sCorec f i n) (sCorec f i (succ n))
i : X
y : F.A
g : B F y → X
h : f i = { fst := y, snd := g }
⊢ Agree (sCorec f i (succ n)) (sCorec f i (succ (succ n)))

tactic: introv
state_before: case succ.mk.a
F : PFunctor
X : Type w
f : X → Obj F X
i✝ : X
n : ℕ
n_ih : ∀ (i : X), Agree (sCorec f i n) (sCorec f i (succ n))
i : X
y : F.A
g : B F y → X
h : f i = { fst := y, snd := g }
⊢ ∀ (i_1 : B F (f i).fst), Agree (sCorec f (Sigma.snd (f i) i_1) n) (sCorec f (Sigma.snd (f i) i_1) (succ n))

tactic: apply n_ih
state_before: case succ.mk.a
F : PFunctor
X : Type w
f : X → Obj F X
i✝¹ : X
n : ℕ
n_ih : ∀ (i : X), Agree (sCorec f i n) (sCorec f i (succ n))
i✝ : X
y : F.A
g : B F y → X
h : f i✝ = { fst := y, snd := g }
i : B F (f i✝).fst
⊢ Agree (sCorec f (Sigma.snd (f i✝) i) n) (sCorec f (Sigma.snd (f i✝) i) (succ n))
Theorem: exists_seq_strictMono_tendsto'
File: Mathlib/Topology/Order/Basic.lean

tactic: have hx : x ∉ Ioo y x := fun h => (lt_irrefl x h.2).elim
state_before: α✝ : Type u
β : Type v
γ : Type w
inst✝¹⁰ : TopologicalSpace α✝
inst✝⁹ : TopologicalSpace β
inst✝⁸ : LinearOrder α✝
inst✝⁷ : LinearOrder β
inst✝⁶ : OrderTopology α✝
inst✝⁵ : OrderTopology β
α : Type u_1
inst✝⁴ : LinearOrder α
inst✝³ : TopologicalSpace α
inst✝² : DenselyOrdered α
inst✝¹ : OrderTopology α
inst✝ : FirstCountableTopology α
x y : α
hy : y < x
⊢ ∃ u, StrictMono u ∧ (∀ (n : ℕ), u n ∈ Ioo y x) ∧ Tendsto u atTop (𝓝 x)

tactic: have ht : Set.Nonempty (Ioo y x) := nonempty_Ioo.2 hy
state_before: α✝ : Type u
β : Type v
γ : Type w
inst✝¹⁰ : TopologicalSpace α✝
inst✝⁹ : TopologicalSpace β
inst✝⁸ : LinearOrder α✝
inst✝⁷ : LinearOrder β
inst✝⁶ : OrderTopology α✝
inst✝⁵ : OrderTopology β
α : Type u_1
inst✝⁴ : LinearOrder α
inst✝³ : TopologicalSpace α
inst✝² : DenselyOrdered α
inst✝¹ : OrderTopology α
inst✝ : FirstCountableTopology α
x y : α
hy : y < x
hx : ¬x ∈ Ioo y x
⊢ ∃ u, StrictMono u ∧ (∀ (n : ℕ), u n ∈ Ioo y x) ∧ Tendsto u atTop (𝓝 x)

tactic: rcases(isLUB_Ioo hy).exists_seq_strictMono_tendsto_of_not_mem hx ht with ⟨u, hu⟩
state_before: α✝ : Type u
β : Type v
γ : Type w
inst✝¹⁰ : TopologicalSpace α✝
inst✝⁹ : TopologicalSpace β
inst✝⁸ : LinearOrder α✝
inst✝⁷ : LinearOrder β
inst✝⁶ : OrderTopology α✝
inst✝⁵ : OrderTopology β
α : Type u_1
inst✝⁴ : LinearOrder α
inst✝³ : TopologicalSpace α
inst✝² : DenselyOrdered α
inst✝¹ : OrderTopology α
inst✝ : FirstCountableTopology α
x y : α
hy : y < x
hx : ¬x ∈ Ioo y x
ht : Set.Nonempty (Ioo y x)
⊢ ∃ u, StrictMono u ∧ (∀ (n : ℕ), u n ∈ Ioo y x) ∧ Tendsto u atTop (𝓝 x)

tactic: exact ⟨u, hu.1, hu.2.2.symm⟩
state_before: case intro
α✝ : Type u
β : Type v
γ : Type w
inst✝¹⁰ : TopologicalSpace α✝
inst✝⁹ : TopologicalSpace β
inst✝⁸ : LinearOrder α✝
inst✝⁷ : LinearOrder β
inst✝⁶ : OrderTopology α✝
inst✝⁵ : OrderTopology β
α : Type u_1
inst✝⁴ : LinearOrder α
inst✝³ : TopologicalSpace α
inst✝² : DenselyOrdered α
inst✝¹ : OrderTopology α
inst✝ : FirstCountableTopology α
x y : α
hy : y < x
hx : ¬x ∈ Ioo y x
ht : Set.Nonempty (Ioo y x)
u : ℕ → α
hu : StrictMono u ∧ (∀ (n : ℕ), u n < x) ∧ Tendsto u atTop (𝓝 x) ∧ ∀ (n : ℕ), u n ∈ Ioo y x
⊢ ∃ u, StrictMono u ∧ (∀ (n : ℕ), u n ∈ Ioo y x) ∧ Tendsto u atTop (𝓝 x)
Theorem: SemiconjBy.zero_left
File: Mathlib/Algebra/GroupWithZero/Semiconj.lean

tactic: simp only [SemiconjBy, mul_zero, zero_mul]
state_before: α : Type ?u.307
M₀ : Type ?u.310
G₀ : Type u_1
M₀' : Type ?u.316
G₀' : Type ?u.319
F : Type ?u.322
F' : Type ?u.325
inst✝ : MulZeroClass G₀
x y : G₀
⊢ SemiconjBy 0 x y
Theorem: Polynomial.one_comp
File: Mathlib/Data/Polynomial/Eval.lean

tactic: rw [← C_1, C_comp]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ comp 1 p = 1
Theorem: Set.eq_finite_iUnion_of_finite_subset_iUnion
File: Mathlib/Data/Set/Finite.lean

tactic: ext x
state_before: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : ι → Set α
t : Set α
tfin : Set.Finite t
h : t ⊆ ⋃ (i : ι), s i
I : Set ι
Ifin : Set.Finite I
hI : t ⊆ ⋃ (i : ι) (_ : i ∈ I), s i
⊢ t = ⋃ (i : ↑{i | i ∈ I}), (fun x => s ↑x ∩ t) i

tactic: rw [mem_iUnion]
state_before: case h
α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : ι → Set α
t : Set α
tfin : Set.Finite t
h : t ⊆ ⋃ (i : ι), s i
I : Set ι
Ifin : Set.Finite I
hI : t ⊆ ⋃ (i : ι) (_ : i ∈ I), s i
x : α
⊢ x ∈ t ↔ x ∈ ⋃ (i : ↑{i | i ∈ I}), (fun x => s ↑x ∩ t) i

tactic: constructor
state_before: case h
α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : ι → Set α
t : Set α
tfin : Set.Finite t
h : t ⊆ ⋃ (i : ι), s i
I : Set ι
Ifin : Set.Finite I
hI : t ⊆ ⋃ (i : ι) (_ : i ∈ I), s i
x : α
⊢ x ∈ t ↔ ∃ i, x ∈ (fun x => s ↑x ∩ t) i

tactic: intro x_in
state_before: case h.mp
α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : ι → Set α
t : Set α
tfin : Set.Finite t
h : t ⊆ ⋃ (i : ι), s i
I : Set ι
Ifin : Set.Finite I
hI : t ⊆ ⋃ (i : ι) (_ : i ∈ I), s i
x : α
⊢ x ∈ t → ∃ i, x ∈ (fun x => s ↑x ∩ t) i

tactic: rcases mem_iUnion.mp (hI x_in) with ⟨i, _, ⟨hi, rfl⟩, H⟩
state_before: case h.mp
α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : ι → Set α
t : Set α
tfin : Set.Finite t
h : t ⊆ ⋃ (i : ι), s i
I : Set ι
Ifin : Set.Finite I
hI : t ⊆ ⋃ (i : ι) (_ : i ∈ I), s i
x : α
x_in : x ∈ t
⊢ ∃ i, x ∈ (fun x => s ↑x ∩ t) i

tactic: refine' ⟨⟨i, hi⟩, ⟨H, x_in⟩⟩
state_before: case h.mp.intro.intro.intro.intro
α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : ι → Set α
t : Set α
tfin : Set.Finite t
h : t ⊆ ⋃ (i : ι), s i
I : Set ι
Ifin : Set.Finite I
hI : t ⊆ ⋃ (i : ι) (_ : i ∈ I), s i
x : α
x_in : x ∈ t
i : ι
hi : i ∈ I
H : x ∈ (fun h => s i) hi
⊢ ∃ i, x ∈ (fun x => s ↑x ∩ t) i

tactic: rintro ⟨i, -, H⟩
state_before: case h.mpr
α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : ι → Set α
t : Set α
tfin : Set.Finite t
h : t ⊆ ⋃ (i : ι), s i
I : Set ι
Ifin : Set.Finite I
hI : t ⊆ ⋃ (i : ι) (_ : i ∈ I), s i
x : α
⊢ (∃ i, x ∈ (fun x => s ↑x ∩ t) i) → x ∈ t

tactic: exact H
state_before: case h.mpr.intro.intro
α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : ι → Set α
t : Set α
tfin : Set.Finite t
h : t ⊆ ⋃ (i : ι), s i
I : Set ι
Ifin : Set.Finite I
hI : t ⊆ ⋃ (i : ι) (_ : i ∈ I), s i
x : α
i : ↑{i | i ∈ I}
H : x ∈ t
⊢ x ∈ t
Theorem: Polynomial.separable_X
File: Mathlib/FieldTheory/Separable.lean

tactic: rw [separable_def, derivative_X]
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
⊢ Separable X

tactic: exact isCoprime_one_right
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
⊢ IsCoprime X 1
Theorem: bernsteinPolynomial.eq_zero_of_lt
File: Mathlib/RingTheory/Polynomial/Bernstein.lean

tactic: simp [bernsteinPolynomial, Nat.choose_eq_zero_of_lt h]
state_before: R : Type u_1
inst✝ : CommRing R
n ν : ℕ
h : n < ν
⊢ bernsteinPolynomial R n ν = 0
Theorem: inner_smul_right
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← inner_conj_symm, inner_smul_left, RingHom.map_mul, conj_conj, inner_conj_symm]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1385935
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
r : 𝕜
⊢ inner x (r • y) = r * inner x y
Theorem: smul_ball
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: ext y
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
c : 𝕜
hc : c ≠ 0
x : E
r : ℝ
⊢ c • ball x r = ball (c • x) (‖c‖ * r)

tactic: rw [mem_smul_set_iff_inv_smul_mem₀ hc]
state_before: case h
𝕜 : Type u_1
E : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
c : 𝕜
hc : c ≠ 0
x : E
r : ℝ
y : E
⊢ y ∈ c • ball x r ↔ y ∈ ball (c • x) (‖c‖ * r)

tactic: conv_lhs => rw [← inv_smul_smul₀ hc x]
state_before: case h
𝕜 : Type u_1
E : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
c : 𝕜
hc : c ≠ 0
x : E
r : ℝ
y : E
⊢ c⁻¹ • y ∈ ball x r ↔ y ∈ ball (c • x) (‖c‖ * r)

tactic: simp [← div_eq_inv_mul, div_lt_iff (norm_pos_iff.2 hc), mul_comm _ r, dist_smul₀]
state_before: case h
𝕜 : Type u_1
E : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
c : 𝕜
hc : c ≠ 0
x : E
r : ℝ
y : E
⊢ c⁻¹ • y ∈ ball (c⁻¹ • c • x) r ↔ y ∈ ball (c • x) (‖c‖ * r)
Theorem: RatFunc.eval_C
File: Mathlib/FieldTheory/RatFunc.lean

tactic: simp [eval]
state_before: K : Type u
inst✝¹ : Field K
L : Type u_1
inst✝ : Field L
f : K →+* L
a : L
c : K
⊢ eval f a (↑C c) = ↑f c
Theorem: prodXSubSmul.smul
File: Mathlib/Algebra/Polynomial/GroupRingAction.lean

tactic: rw [ofQuotientStabilizer_smul, smul_sub, Polynomial.smul_X, Polynomial.smul_C]
state_before: M : Type ?u.101578
inst✝⁴ : Monoid M
G : Type u_2
inst✝³ : Group G
inst✝² : Fintype G
R : Type u_1
inst✝¹ : CommRing R
inst✝ : MulSemiringAction G R
x : R
g : G
g' : G ⧸ stabilizer G x
⊢ g • (X - ↑C (ofQuotientStabilizer G x g')) = X - ↑C (ofQuotientStabilizer G x ((fun x_1 x_2 => x_1 • x_2) g g'))
Theorem: HasStrictDerivAt.rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

tactic: convert (hasStrictFDerivAt_rpow_of_pos ((fun x => (f x, g x)) x) h).comp_hasStrictDerivAt x
  (hf.prod hg) using 1
state_before: x y z : ℝ
f g : ℝ → ℝ
f' g' : ℝ
hf : HasStrictDerivAt f f' x
hg : HasStrictDerivAt g g' x
h : 0 < f x
⊢ HasStrictDerivAt (fun x => f x ^ g x) (f' * g x * f x ^ (g x - 1) + g' * f x ^ g x * log (f x)) x

tactic: simp [mul_assoc, mul_comm, mul_left_comm]
state_before: case h.e'_7
x y z : ℝ
f g : ℝ → ℝ
f' g' : ℝ
hf : HasStrictDerivAt f f' x
hg : HasStrictDerivAt g g' x
h : 0 < f x
⊢ f' * g x * f x ^ (g x - 1) + g' * f x ^ g x * log (f x) =
    ↑((((fun x => (f x, g x)) x).snd * ((fun x => (f x, g x)) x).fst ^ (((fun x => (f x, g x)) x).snd - 1)) •
            ContinuousLinearMap.fst ℝ ℝ ℝ +
          (((fun x => (f x, g x)) x).fst ^ ((fun x => (f x, g x)) x).snd * log ((fun x => (f x, g x)) x).fst) •
            ContinuousLinearMap.snd ℝ ℝ ℝ)
      (f', g')
Theorem: SubgroupClass.coe_inclusion
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: cases a
state_before: G : Type u_2
G' : Type ?u.66281
inst✝⁶ : Group G
inst✝⁵ : Group G'
A : Type ?u.66290
inst✝⁴ : AddGroup A
M : Type ?u.66296
S : Type u_1
inst✝³ : DivInvMonoid M
inst✝² : SetLike S M
hSM : SubgroupClass S M
H✝ K✝ : S
inst✝¹ : SetLike S G
inst✝ : SubgroupClass S G
H K : S
h : H ≤ K
a : { x // x ∈ H }
⊢ ↑(↑(inclusion h) a) = ↑a

tactic: simp only [inclusion, MonoidHom.mk'_apply]
state_before: case mk
G : Type u_2
G' : Type ?u.66281
inst✝⁶ : Group G
inst✝⁵ : Group G'
A : Type ?u.66290
inst✝⁴ : AddGroup A
M : Type ?u.66296
S : Type u_1
inst✝³ : DivInvMonoid M
inst✝² : SetLike S M
hSM : SubgroupClass S M
H✝ K✝ : S
inst✝¹ : SetLike S G
inst✝ : SubgroupClass S G
H K : S
h : H ≤ K
val✝ : G
property✝ : val✝ ∈ H
⊢ ↑(↑(inclusion h) { val := val✝, property := property✝ }) = ↑{ val := val✝, property := property✝ }
Theorem: Nat.prime_pow_prime_divisor
File: Mathlib/Data/Nat/PrimeFin.lean

tactic: simp [pow_factors_toFinset p hk, factors_prime hp]
state_before: p k : ℕ
hk : k ≠ 0
hp : Prime p
⊢ List.toFinset (factors (p ^ k)) = {p}
Theorem: List.map_take
File: Mathlib/Data/List/Basic.lean

tactic: simp
state_before: ι : Type ?u.162315
α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α✝
α : Type u_1
β : Type u_2
f : α → β
i : ℕ
⊢ map f (take i []) = take i (map f [])

tactic: simp
state_before: ι : Type ?u.162315
α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α✝
α : Type u_1
β : Type u_2
f : α → β
x✝ : List α
⊢ map f (take 0 x✝) = take 0 (map f x✝)

tactic: dsimp
state_before: ι : Type ?u.162315
α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α✝
α : Type u_1
β : Type u_2
f : α → β
h : α
t : List α
n : ℕ
⊢ map f (take (n + 1) (h :: t)) = take (n + 1) (map f (h :: t))

tactic: rw [map_take f t n]
state_before: ι : Type ?u.162315
α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α✝
α : Type u_1
β : Type u_2
f : α → β
h : α
t : List α
n : ℕ
⊢ f h :: map f (take n t) = f h :: take n (map f t)
Theorem: IsCompactOperator.isCompact_closure_image_of_bounded
File: Mathlib/Analysis/NormedSpace/CompactOperator.lean

tactic: rwa [NormedSpace.isVonNBounded_iff, ← Metric.bounded_iff_isBounded]
state_before: 𝕜₁ : Type u_3
𝕜₂ : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜₁
inst✝⁷ : SeminormedRing 𝕜₂
σ₁₂ : 𝕜₁ →+* 𝕜₂
M₁ : Type u_4
M₂ : Type u_2
M₃ : Type ?u.77547
inst✝⁶ : SeminormedAddCommGroup M₁
inst✝⁵ : TopologicalSpace M₂
inst✝⁴ : AddCommMonoid M₂
inst✝³ : NormedSpace 𝕜₁ M₁
inst✝² : Module 𝕜₂ M₂
inst✝¹ : ContinuousConstSMul 𝕜₂ M₂
inst✝ : T2Space M₂
f : M₁ →ₛₗ[σ₁₂] M₂
hf : IsCompactOperator ↑f
S : Set M₁
hS : Metric.Bounded S
⊢ IsVonNBounded 𝕜₁ S
Theorem: Lagrange.X_sub_C_dvd_nodal
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: classical exact nodal_eq_mul_nodal_erase hi
state_before: F : Type u_2
inst✝ : Field F
ι : Type u_1
s : Finset ι
v✝ : ι → F
i : ι
r : ι → F
x : F
v : ι → F
hi : i ∈ s
⊢ nodal s v = (X - ↑C (v i)) * ?m.392653 v hi

tactic: exact nodal_eq_mul_nodal_erase hi
state_before: F : Type u_2
inst✝ : Field F
ι : Type u_1
s : Finset ι
v✝ : ι → F
i : ι
r : ι → F
x : F
v : ι → F
hi : i ∈ s
⊢ nodal s v = (X - ↑C (v i)) * ?m.392653 v hi