tasksource/leandojo huggingface dataset:
Theorem: CompHaus.mono_iff_injective
File: Mathlib/Topology/Category/CompHaus/Basic.lean

tactic: constructor
state_before: X Y : CompHaus
f : X ⟶ Y
⊢ Mono f ↔ Function.Injective ((forget CompHaus).map f)

tactic: intro hf x₁ x₂ h
state_before: case mp
X Y : CompHaus
f : X ⟶ Y
⊢ Mono f → Function.Injective ((forget CompHaus).map f)

tactic: let g₁ : of PUnit ⟶ X := ⟨fun _ => x₁, continuous_const⟩
state_before: case mp
X Y : CompHaus
f : X ⟶ Y
hf : Mono f
x₁ x₂ : (forget CompHaus).obj X
h : (forget CompHaus).map f x₁ = (forget CompHaus).map f x₂
⊢ x₁ = x₂

tactic: let g₂ : of PUnit ⟶ X := ⟨fun _ => x₂, continuous_const⟩
state_before: case mp
X Y : CompHaus
f : X ⟶ Y
hf : Mono f
x₁ x₂ : (forget CompHaus).obj X
h : (forget CompHaus).map f x₁ = (forget CompHaus).map f x₂
g₁ : of PUnit ⟶ X := ContinuousMap.mk fun x => x₁
⊢ x₁ = x₂

tactic: have : g₁ ≫ f = g₂ ≫ f := by
  ext
  exact h
state_before: case mp
X Y : CompHaus
f : X ⟶ Y
hf : Mono f
x₁ x₂ : (forget CompHaus).obj X
h : (forget CompHaus).map f x₁ = (forget CompHaus).map f x₂
g₁ : of PUnit ⟶ X := ContinuousMap.mk fun x => x₁
g₂ : of PUnit ⟶ X := ContinuousMap.mk fun x => x₂
⊢ x₁ = x₂

tactic: rw [cancel_mono] at this
state_before: case mp
X Y : CompHaus
f : X ⟶ Y
hf : Mono f
x₁ x₂ : (forget CompHaus).obj X
h : (forget CompHaus).map f x₁ = (forget CompHaus).map f x₂
g₁ : of PUnit ⟶ X := ContinuousMap.mk fun x => x₁
g₂ : of PUnit ⟶ X := ContinuousMap.mk fun x => x₂
this : g₁ ≫ f = g₂ ≫ f
⊢ x₁ = x₂

tactic: apply_fun fun e => e PUnit.unit  at this
state_before: case mp
X Y : CompHaus
f : X ⟶ Y
hf : Mono f
x₁ x₂ : (forget CompHaus).obj X
h : (forget CompHaus).map f x₁ = (forget CompHaus).map f x₂
g₁ : of PUnit ⟶ X := ContinuousMap.mk fun x => x₁
g₂ : of PUnit ⟶ X := ContinuousMap.mk fun x => x₂
this : g₁ = g₂
⊢ x₁ = x₂

tactic: exact this
state_before: case mp
X Y : CompHaus
f : X ⟶ Y
hf : Mono f
x₁ x₂ : (forget CompHaus).obj X
h : (forget CompHaus).map f x₁ = (forget CompHaus).map f x₂
g₁ : of PUnit ⟶ X := ContinuousMap.mk fun x => x₁
g₂ : of PUnit ⟶ X := ContinuousMap.mk fun x => x₂
this : (forget CompHaus).map g₁ PUnit.unit = (forget CompHaus).map g₂ PUnit.unit
⊢ x₁ = x₂

tactic: ext
state_before: X Y : CompHaus
f : X ⟶ Y
hf : Mono f
x₁ x₂ : (forget CompHaus).obj X
h : (forget CompHaus).map f x₁ = (forget CompHaus).map f x₂
g₁ : of PUnit ⟶ X := ContinuousMap.mk fun x => x₁
g₂ : of PUnit ⟶ X := ContinuousMap.mk fun x => x₂
⊢ g₁ ≫ f = g₂ ≫ f

tactic: exact h
state_before: case w
X Y : CompHaus
f : X ⟶ Y
hf : Mono f
x₁ x₂ : (forget CompHaus).obj X
h : (forget CompHaus).map f x₁ = (forget CompHaus).map f x₂
g₁ : of PUnit ⟶ X := ContinuousMap.mk fun x => x₁
g₂ : of PUnit ⟶ X := ContinuousMap.mk fun x => x₂
x✝ : (forget CompHaus).obj (of PUnit)
⊢ (forget CompHaus).map (g₁ ≫ f) x✝ = (forget CompHaus).map (g₂ ≫ f) x✝

tactic: rw [← CategoryTheory.mono_iff_injective]
state_before: case mpr
X Y : CompHaus
f : X ⟶ Y
⊢ Function.Injective ((forget CompHaus).map f) → Mono f

tactic: apply (forget CompHaus).mono_of_mono_map
state_before: case mpr
X Y : CompHaus
f : X ⟶ Y
⊢ Mono ((forget CompHaus).map f) → Mono f
Theorem: Module.End.generalizedEigenspace_restrict
File: Mathlib/LinearAlgebra/Eigenspace/Basic.lean

tactic: simp only [generalizedEigenspace, OrderHom.coe_fun_mk, ← LinearMap.ker_comp]
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
p : Submodule R M
k : ℕ
μ : R
hfp : ∀ (x : M), x ∈ p → ↑f x ∈ p
⊢ ↑(generalizedEigenspace (LinearMap.restrict f hfp) μ) k =
    Submodule.comap (Submodule.subtype p) (↑(generalizedEigenspace f μ) k)

tactic: induction' k with k ih
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
p : Submodule R M
k : ℕ
μ : R
hfp : ∀ (x : M), x ∈ p → ↑f x ∈ p
⊢ LinearMap.ker ((LinearMap.restrict f hfp - ↑(algebraMap R (End R { x // x ∈ p })) μ) ^ k) =
    LinearMap.ker (LinearMap.comp ((f - ↑(algebraMap R (End R M)) μ) ^ k) (Submodule.subtype p))

tactic: rw [pow_zero, pow_zero, LinearMap.one_eq_id]
state_before: case zero
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
p : Submodule R M
μ : R
hfp : ∀ (x : M), x ∈ p → ↑f x ∈ p
⊢ LinearMap.ker ((LinearMap.restrict f hfp - ↑(algebraMap R (End R { x // x ∈ p })) μ) ^ Nat.zero) =
    LinearMap.ker (LinearMap.comp ((f - ↑(algebraMap R (End R M)) μ) ^ Nat.zero) (Submodule.subtype p))

tactic: apply (Submodule.ker_subtype _).symm
state_before: case zero
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
p : Submodule R M
μ : R
hfp : ∀ (x : M), x ∈ p → ↑f x ∈ p
⊢ LinearMap.ker LinearMap.id = LinearMap.ker (LinearMap.comp 1 (Submodule.subtype p))

tactic: erw [pow_succ', pow_succ', LinearMap.ker_comp, LinearMap.ker_comp, ih, ← LinearMap.ker_comp,
  LinearMap.comp_assoc]
state_before: case succ
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
p : Submodule R M
μ : R
hfp : ∀ (x : M), x ∈ p → ↑f x ∈ p
k : ℕ
ih :
  LinearMap.ker ((LinearMap.restrict f hfp - ↑(algebraMap R (End R { x // x ∈ p })) μ) ^ k) =
    LinearMap.ker (LinearMap.comp ((f - ↑(algebraMap R (End R M)) μ) ^ k) (Submodule.subtype p))
⊢ LinearMap.ker ((LinearMap.restrict f hfp - ↑(algebraMap R (End R { x // x ∈ p })) μ) ^ Nat.succ k) =
    LinearMap.ker (LinearMap.comp ((f - ↑(algebraMap R (End R M)) μ) ^ Nat.succ k) (Submodule.subtype p))
Theorem: MonotoneOn.congr
File: Mathlib/Data/Set/Function.lean

tactic: intro a ha b hb hab
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.9325
ι : Sort ?u.9328
π : α → Type ?u.9333
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
inst✝¹ : Preorder α
inst✝ : Preorder β
h₁ : MonotoneOn f₁ s
h : EqOn f₁ f₂ s
⊢ MonotoneOn f₂ s

tactic: rw [← h ha, ← h hb]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.9325
ι : Sort ?u.9328
π : α → Type ?u.9333
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a✝ : α
b✝ : β
inst✝¹ : Preorder α
inst✝ : Preorder β
h₁ : MonotoneOn f₁ s
h : EqOn f₁ f₂ s
a : α
ha : a ∈ s
b : α
hb : b ∈ s
hab : a ≤ b
⊢ f₂ a ≤ f₂ b

tactic: exact h₁ ha hb hab
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.9325
ι : Sort ?u.9328
π : α → Type ?u.9333
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a✝ : α
b✝ : β
inst✝¹ : Preorder α
inst✝ : Preorder β
h₁ : MonotoneOn f₁ s
h : EqOn f₁ f₂ s
a : α
ha : a ∈ s
b : α
hb : b ∈ s
hab : a ≤ b
⊢ f₁ a ≤ f₁ b
Theorem: PFun.core_res
File: Mathlib/Data/PFun.lean

tactic: ext x
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.48032
δ : Type ?u.48035
ε : Type ?u.48038
ι : Type ?u.48041
f✝ : α →. β
f : α → β
s : Set α
t : Set β
⊢ core (res f s) t = sᶜ ∪ f ⁻¹' t

tactic: rw [mem_core_res]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.48032
δ : Type ?u.48035
ε : Type ?u.48038
ι : Type ?u.48041
f✝ : α →. β
f : α → β
s : Set α
t : Set β
x : α
⊢ x ∈ core (res f s) t ↔ x ∈ sᶜ ∪ f ⁻¹' t

tactic: by_cases h : x ∈ s <;> simp [h]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.48032
δ : Type ?u.48035
ε : Type ?u.48038
ι : Type ?u.48041
f✝ : α →. β
f : α → β
s : Set α
t : Set β
x : α
⊢ x ∈ s → f x ∈ t ↔ x ∈ sᶜ ∪ f ⁻¹' t
Theorem: ContinuousOn.sInf_image_Icc_le
File: Mathlib/Topology/Algebra/Order/Compact.lean

tactic: have := mem_image_of_mem f hc
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.72940
inst✝⁷ : ConditionallyCompleteLinearOrder α
inst✝⁶ : TopologicalSpace α
inst✝⁵ : OrderTopology α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : DenselyOrdered α
inst✝¹ : ConditionallyCompleteLinearOrder β
inst✝ : OrderTopology β
f : α → β
a b c : α
h : ContinuousOn f (Icc a b)
hc : c ∈ Icc a b
⊢ sInf (f '' Icc a b) ≤ f c

tactic: rw [h.image_Icc (hc.1.trans hc.2)] at this
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.72940
inst✝⁷ : ConditionallyCompleteLinearOrder α
inst✝⁶ : TopologicalSpace α
inst✝⁵ : OrderTopology α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : DenselyOrdered α
inst✝¹ : ConditionallyCompleteLinearOrder β
inst✝ : OrderTopology β
f : α → β
a b c : α
h : ContinuousOn f (Icc a b)
hc : c ∈ Icc a b
this : f c ∈ f '' Icc a b
⊢ sInf (f '' Icc a b) ≤ f c

tactic: exact this.1
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.72940
inst✝⁷ : ConditionallyCompleteLinearOrder α
inst✝⁶ : TopologicalSpace α
inst✝⁵ : OrderTopology α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : DenselyOrdered α
inst✝¹ : ConditionallyCompleteLinearOrder β
inst✝ : OrderTopology β
f : α → β
a b c : α
h : ContinuousOn f (Icc a b)
hc : c ∈ Icc a b
this : f c ∈ Icc (sInf (f '' Icc a b)) (sSup (f '' Icc a b))
⊢ sInf (f '' Icc a b) ≤ f c
Theorem: Polynomial.iterate_derivative_C_mul
File: Mathlib/Data/Polynomial/Derivative.lean

tactic: simp_rw [← smul_eq_C_mul, iterate_derivative_smul]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a✝ b : R
n : ℕ
inst✝ : Semiring R
a : R
p : R[X]
k : ℕ
⊢ (↑derivative^[k]) (↑C a * p) = ↑C a * (↑derivative^[k]) p
Theorem: Nat.Prime.pow_minFac
File: Mathlib/Data/Nat/Prime.lean

tactic: rw [Nat.pow_minFac hk, hp.minFac_eq]
state_before: p k : ℕ
hp : Prime p
hk : k ≠ 0
⊢ minFac (p ^ k) = p
Theorem: Filter.limsup_sdiff
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp only [limsup_eq_iInf_iSup, sdiff_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.172865
ι : Type ?u.172868
inst✝ : CompleteBooleanAlgebra α
f : Filter β
u : β → α
a : α
⊢ limsup u f \ a = limsup (fun b => u b \ a) f

tactic: rw [biInf_inf (⟨univ, univ_mem⟩ : ∃ i : Set β, i ∈ f)]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.172865
ι : Type ?u.172868
inst✝ : CompleteBooleanAlgebra α
f : Filter β
u : β → α
a : α
⊢ (⨅ (s : Set β) (_ : s ∈ f), ⨆ (a : β) (_ : a ∈ s), u a) ⊓ aᶜ =
    ⨅ (s : Set β) (_ : s ∈ f), ⨆ (a_1 : β) (_ : a_1 ∈ s), u a_1 ⊓ aᶜ

tactic: simp_rw [inf_comm, inf_iSup₂_eq, inf_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.172865
ι : Type ?u.172868
inst✝ : CompleteBooleanAlgebra α
f : Filter β
u : β → α
a : α
⊢ (⨅ (i : Set β) (_ : i ∈ f), (⨆ (a : β) (_ : a ∈ i), u a) ⊓ aᶜ) =
    ⨅ (s : Set β) (_ : s ∈ f), ⨆ (a_1 : β) (_ : a_1 ∈ s), u a_1 ⊓ aᶜ
Theorem: List.cons_prefix_iff
File: Mathlib/Data/List/Infix.lean

tactic: constructor
state_before: α : Type u_1
β : Type ?u.27592
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
⊢ a :: l₁ <+: b :: l₂ ↔ a = b ∧ l₁ <+: l₂

tactic: rintro ⟨L, hL⟩
state_before: case mp
α : Type u_1
β : Type ?u.27592
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
⊢ a :: l₁ <+: b :: l₂ → a = b ∧ l₁ <+: l₂

tactic: simp only [cons_append] at hL
state_before: case mp.intro
α : Type u_1
β : Type ?u.27592
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
L : List α
hL : a :: l₁ ++ L = b :: l₂
⊢ a = b ∧ l₁ <+: l₂

tactic: injection hL with hLLeft hLRight
state_before: case mp.intro
α : Type u_1
β : Type ?u.27592
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
L : List α
hL : a :: (l₁ ++ L) = b :: l₂
⊢ a = b ∧ l₁ <+: l₂

tactic: exact ⟨hLLeft, ⟨L, hLRight⟩⟩
state_before: case mp.intro
α : Type u_1
β : Type ?u.27592
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
L : List α
hLLeft : a = b
hLRight : l₁ ++ L = l₂
⊢ a = b ∧ l₁ <+: l₂

tactic: rintro ⟨rfl, h⟩
state_before: case mpr
α : Type u_1
β : Type ?u.27592
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
⊢ a = b ∧ l₁ <+: l₂ → a :: l₁ <+: b :: l₂

tactic: rwa [prefix_cons_inj]
state_before: case mpr.intro
α : Type u_1
β : Type ?u.27592
l l₁ l₂ l₃ : List α
a : α
m n : ℕ
h : l₁ <+: l₂
⊢ a :: l₁ <+: a :: l₂
Theorem: Nat.Partrec'.comp₁
File: Mathlib/Computability/Halting.lean

tactic: simpa using hf.comp' (Partrec'.cons hg Partrec'.nil)
state_before: n : ℕ
f : ℕ →. ℕ
g : Vector ℕ n → ℕ
hf : Partrec' fun v => f (Vector.head v)
hg : Partrec' ↑g
⊢ Partrec' fun v => f (g v)
Theorem: SatisfiesM.bind
File: Std/Classes/LawfulMonad.lean

tactic: match x, hx with | _, ⟨x, rfl⟩ => ?_
state_before: m : Type u_1 → Type u_2
α β : Type u_1
p : α → Prop
x : m α
q : β → Prop
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → m β
hx : SatisfiesM p x
hf : ∀ (a : α), p a → SatisfiesM q (f a)
⊢ SatisfiesM q (x >>= f)

tactic: have g a ha := Classical.indefiniteDescription _ (hf a ha)
state_before: m : Type u_1 → Type u_2
α β : Type u_1
p : α → Prop
x✝ : m α
q : β → Prop
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → m β
hx : SatisfiesM p x✝
hf : ∀ (a : α), p a → SatisfiesM q (f a)
x : m { a // p a }
⊢ SatisfiesM q (Subtype.val <$> x >>= f)

tactic: refine ⟨x >>= fun ⟨a, h⟩ => g a h, ?_⟩
state_before: m : Type u_1 → Type u_2
α β : Type u_1
p : α → Prop
x✝ : m α
q : β → Prop
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → m β
hx : SatisfiesM p x✝
hf : ∀ (a : α), p a → SatisfiesM q (f a)
x : m { a // p a }
g : (a : α) → p a → { x // Subtype.val <$> x = f a }
⊢ SatisfiesM q (Subtype.val <$> x >>= f)

tactic: simp [← bind_pure_comp]
state_before: m : Type u_1 → Type u_2
α β : Type u_1
p : α → Prop
x✝ : m α
q : β → Prop
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → m β
hx : SatisfiesM p x✝
hf : ∀ (a : α), p a → SatisfiesM q (f a)
x : m { a // p a }
g : (a : α) → p a → { x // Subtype.val <$> x = f a }
⊢ (Subtype.val <$> do
      let x ← x
      match x with
        | { val := a, property := h } => (g a h).val) =
    Subtype.val <$> x >>= f

tactic: congr
state_before: m : Type u_1 → Type u_2
α β : Type u_1
p : α → Prop
x✝ : m α
q : β → Prop
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → m β
hx : SatisfiesM p x✝
hf : ∀ (a : α), p a → SatisfiesM q (f a)
x : m { a // p a }
g : (a : α) → p a → { x // Subtype.val <$> x = f a }
⊢ (do
      let x ← x
      let a ← (g x.val (_ : p x.val)).val
      pure a.val) =
    do
    let x ← x
    f x.val

tactic: funext ⟨a, h⟩
state_before: case e_a
m : Type u_1 → Type u_2
α β : Type u_1
p : α → Prop
x✝ : m α
q : β → Prop
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → m β
hx : SatisfiesM p x✝
hf : ∀ (a : α), p a → SatisfiesM q (f a)
x : m { a // p a }
g : (a : α) → p a → { x // Subtype.val <$> x = f a }
⊢ (fun x => do
      let a ← (g x.val (_ : p x.val)).val
      pure a.val) =
    fun x => f x.val

tactic: simp [← (g a h).2, ← bind_pure_comp]
state_before: case e_a.h
m : Type u_1 → Type u_2
α β : Type u_1
p : α → Prop
x✝ : m α
q : β → Prop
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → m β
hx : SatisfiesM p x✝
hf : ∀ (a : α), p a → SatisfiesM q (f a)
x : m { a // p a }
g : (a : α) → p a → { x // Subtype.val <$> x = f a }
a : α
h : p a
⊢ (do
      let a ← (g { val := a, property := h }.val (_ : p { val := a, property := h }.val)).val
      pure a.val) =
    f { val := a, property := h }.val
Theorem: MultilinearMap.snoc_smul
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

tactic: simp_rw [← update_snoc_last x m (c • x), f.map_smul, update_snoc_last]
state_before: R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹⁰ : Semiring R
inst✝⁹ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁸ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : AddCommMonoid M₃
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝³ : (i : ι) → Module R (M₁ i)
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M'
f✝ f' : MultilinearMap R M₁ M₂
f : MultilinearMap R M M₂
m : (i : Fin n) → M (↑castSucc i)
c : R
x : M (last n)
⊢ ↑f (snoc m (c • x)) = c • ↑f (snoc m x)
Theorem: AntivaryOn.card_smul_sum_le_sum_smul_sum
File: Mathlib/Algebra/Order/Chebyshev.lean

tactic: refine hfg.dual_right.sum_smul_sum_le_card_smul_sum
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : LinearOrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : OrderedSMul α β
s : Finset ι
σ : Perm ι
f : ι → α
g : ι → β
hfg : AntivaryOn f g ↑s
⊢ card s • ∑ i in s, f i • g i ≤ (∑ i in s, f i) • ∑ i in s, g i
Theorem: PadicSeq.lift_index_right
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: apply stationaryPoint_spec hf
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
v1 v2 : ℕ
⊢ padicNorm p (↑f (stationaryPoint hf)) = padicNorm p (↑f (max v1 (max v2 (stationaryPoint hf))))

tactic: apply le_trans
state_before: case a
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
v1 v2 : ℕ
⊢ stationaryPoint hf ≤ max v1 (max v2 (stationaryPoint hf))

tactic: apply le_max_right v2
state_before: case a.a
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
v1 v2 : ℕ
⊢ stationaryPoint hf ≤ ?a.b✝

tactic: apply le_max_right
state_before: case a.a
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
v1 v2 : ℕ
⊢ max v2 (stationaryPoint hf) ≤ max v1 (max v2 (stationaryPoint hf))

tactic: exact le_rfl
state_before: case a
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
v1 v2 : ℕ
⊢ stationaryPoint hf ≤ stationaryPoint hf
Theorem: finprod_mem_one
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.221292
ι : Type ?u.221295
G : Type ?u.221298
M : Type u_2
N : Type ?u.221304
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s✝ t s : Set α
⊢ (∏ᶠ (i : α) (_ : i ∈ s), 1) = 1
Theorem: Multiset.map_single_le_powerset
File: Mathlib/Data/Multiset/Powerset.lean

tactic: simp only [powerset_coe, quot_mk_to_coe, coe_le, coe_map]
state_before: α : Type u_1
s : Multiset α
l : List α
⊢ map singleton (Quotient.mk (isSetoid α) l) ≤ powerset (Quotient.mk (isSetoid α) l)

tactic: show l.map (((↑) : List α → Multiset α) ∘ List.ret) <+~ (sublists l).map (↑)
state_before: α : Type u_1
s : Multiset α
l : List α
⊢ List.map singleton l <+~ List.map ofList (sublists l)

tactic: rw [← List.map_map]
state_before: α : Type u_1
s : Multiset α
l : List α
⊢ List.map (ofList ∘ List.ret) l <+~ List.map ofList (sublists l)

tactic: exact ((map_ret_sublist_sublists _).map _).subperm
state_before: α : Type u_1
s : Multiset α
l : List α
⊢ List.map ofList (List.map List.ret l) <+~ List.map ofList (sublists l)
Theorem: ENNReal.pow_eq_top_iff
File: Mathlib/Data/Real/ENNReal.lean

tactic: rcases n.eq_zero_or_pos with rfl | (hn : 0 < n)
state_before: α : Type ?u.95091
β : Type ?u.95094
a b c d : ℝ≥0∞
r p q : ℝ≥0
n : ℕ
⊢ a ^ n = ⊤ ↔ a = ⊤ ∧ n ≠ 0

tactic: simp
state_before: case inl
α : Type ?u.95091
β : Type ?u.95094
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ a ^ 0 = ⊤ ↔ a = ⊤ ∧ 0 ≠ 0

tactic: induction a using recTopCoe
state_before: case inr
α : Type ?u.95091
β : Type ?u.95094
a b c d : ℝ≥0∞
r p q : ℝ≥0
n : ℕ
hn : 0 < n
⊢ a ^ n = ⊤ ↔ a = ⊤ ∧ n ≠ 0

tactic: simp only [Ne.def, hn.ne', top_pow hn]
state_before: case inr.top
α : Type ?u.95091
β : Type ?u.95094
a b c d : ℝ≥0∞
r p q : ℝ≥0
n : ℕ
hn : 0 < n
⊢ ⊤ ^ n = ⊤ ↔ ⊤ = ⊤ ∧ n ≠ 0

tactic: simp only [← coe_pow, coe_ne_top, false_and]
state_before: case inr.coe
α : Type ?u.95091
β : Type ?u.95094
a b c d : ℝ≥0∞
r p q : ℝ≥0
n : ℕ
hn : 0 < n
x✝ : ℝ≥0
⊢ ↑x✝ ^ n = ⊤ ↔ ↑x✝ = ⊤ ∧ n ≠ 0
Theorem: TrivSqZeroExt.exp_def_of_smul_comm
File: Mathlib/Analysis/NormedSpace/TrivSqZeroExt.lean

tactic: simp_rw [exp, FormalMultilinearSeries.sum]
state_before: 𝕜 : Type u_3
R : Type u_1
M : Type u_2
inst✝¹⁷ : IsROrC 𝕜
inst✝¹⁶ : NormedRing R
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : NormedAlgebra 𝕜 R
inst✝¹³ : Module R M
inst✝¹² : Module Rᵐᵒᵖ M
inst✝¹¹ : SMulCommClass R Rᵐᵒᵖ M
inst✝¹⁰ : Module 𝕜 M
inst✝⁹ : IsScalarTower 𝕜 R M
inst✝⁸ : IsScalarTower 𝕜 Rᵐᵒᵖ M
inst✝⁷ : TopologicalSpace M
inst✝⁶ : TopologicalRing R
inst✝⁵ : TopologicalAddGroup M
inst✝⁴ : ContinuousSMul R M
inst✝³ : ContinuousSMul Rᵐᵒᵖ M
inst✝² : CompleteSpace R
inst✝¹ : T2Space R
inst✝ : T2Space M
x : tsze R M
hx : MulOpposite.op (fst x) • snd x = fst x • snd x
⊢ exp 𝕜 x = inl (exp 𝕜 (fst x)) + inr (exp 𝕜 (fst x) • snd x)

tactic: refine' (hasSum_expSeries_of_smul_comm 𝕜 x hx _).tsum_eq
state_before: 𝕜 : Type u_3
R : Type u_1
M : Type u_2
inst✝¹⁷ : IsROrC 𝕜
inst✝¹⁶ : NormedRing R
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : NormedAlgebra 𝕜 R
inst✝¹³ : Module R M
inst✝¹² : Module Rᵐᵒᵖ M
inst✝¹¹ : SMulCommClass R Rᵐᵒᵖ M
inst✝¹⁰ : Module 𝕜 M
inst✝⁹ : IsScalarTower 𝕜 R M
inst✝⁸ : IsScalarTower 𝕜 Rᵐᵒᵖ M
inst✝⁷ : TopologicalSpace M
inst✝⁶ : TopologicalRing R
inst✝⁵ : TopologicalAddGroup M
inst✝⁴ : ContinuousSMul R M
inst✝³ : ContinuousSMul Rᵐᵒᵖ M
inst✝² : CompleteSpace R
inst✝¹ : T2Space R
inst✝ : T2Space M
x : tsze R M
hx : MulOpposite.op (fst x) • snd x = fst x • snd x
⊢ (∑' (n : ℕ), ↑(expSeries 𝕜 (tsze R M) n) fun x_1 => x) =
    inl (∑' (n : ℕ), ↑(expSeries 𝕜 R n) fun x_1 => fst x) +
      inr ((∑' (n : ℕ), ↑(expSeries 𝕜 R n) fun x_1 => fst x) • snd x)

tactic: exact expSeries_hasSum_exp _
state_before: 𝕜 : Type u_3
R : Type u_1
M : Type u_2
inst✝¹⁷ : IsROrC 𝕜
inst✝¹⁶ : NormedRing R
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : NormedAlgebra 𝕜 R
inst✝¹³ : Module R M
inst✝¹² : Module Rᵐᵒᵖ M
inst✝¹¹ : SMulCommClass R Rᵐᵒᵖ M
inst✝¹⁰ : Module 𝕜 M
inst✝⁹ : IsScalarTower 𝕜 R M
inst✝⁸ : IsScalarTower 𝕜 Rᵐᵒᵖ M
inst✝⁷ : TopologicalSpace M
inst✝⁶ : TopologicalRing R
inst✝⁵ : TopologicalAddGroup M
inst✝⁴ : ContinuousSMul R M
inst✝³ : ContinuousSMul Rᵐᵒᵖ M
inst✝² : CompleteSpace R
inst✝¹ : T2Space R
inst✝ : T2Space M
x : tsze R M
hx : MulOpposite.op (fst x) • snd x = fst x • snd x
⊢ HasSum (fun n => ↑(expSeries 𝕜 R n) fun x_1 => fst x) (∑' (n : ℕ), ↑(expSeries 𝕜 R n) fun x_1 => fst x)
Theorem: Computation.Results.len_unique
File: Mathlib/Data/Seq/Computation.lean

tactic: haveI := h1.terminates
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
a b : α
m n : ℕ
h1 : Results s a m
h2 : Results s b n
⊢ m = n

tactic: haveI := h2.terminates
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
a b : α
m n : ℕ
h1 : Results s a m
h2 : Results s b n
this : Terminates s
⊢ m = n

tactic: rw [← h1.length, h2.length]
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
a b : α
m n : ℕ
h1 : Results s a m
h2 : Results s b n
this✝ this : Terminates s
⊢ m = n
Theorem: unique_iff_subsingleton_and_nonempty
File: Mathlib/Logic/Unique.lean

tactic: constructor <;> exact inferInstance
state_before: α : Sort u
x✝ : Nonempty (Unique α)
u : Unique α
⊢ Subsingleton α ∧ Nonempty α

tactic: inhabit α
state_before: α : Sort u
x✝ : Subsingleton α ∧ Nonempty α
hs : Subsingleton α
hn : Nonempty α
⊢ Unique α

tactic: exact Unique.mk' α
state_before: α : Sort u
x✝ : Subsingleton α ∧ Nonempty α
hs : Subsingleton α
hn : Nonempty α
inhabited_h : Inhabited α
⊢ Unique α