ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Filter.pow_mem_pow
@[to_additive]
theorem pow_mem_pow (hs : s ∈ f) : ∀ n : ℕ, s ^ n ∈ f ^ n
  
Arguments: {α : Type u_2} [Monoid α] {f : Filter α} {s : Set α} (hs : s ∈ f) (n : ℕ)
Goal: s ^ n ∈ f ^ n
-- Filter.nsmul_mem_nsmul
@[to_additive]
theorem pow_mem_pow (hs : s ∈ f) : ∀ n : ℕ, s ^ n ∈ f ^ n
  
Arguments: {α : Type u_2} [AddMonoid α] {f : Filter α} {s : Set α} (hs : s ∈ f) (n : ℕ)
Goal: n • s ∈ n • f
-- Filter.bot_pow
@[to_additive (attr := simp) nsmul_bot]
theorem bot_pow {n : ℕ} (hn : n ≠ 0) : (⊥ : Filter α) ^ n = ⊥ 
Arguments: {α : Type u_2} [Monoid α] {n : ℕ} (hn : n ≠ 0)
Goal: ⊥ ^ n = ⊥
-- Filter.nsmul_bot
@[to_additive (attr := simp) nsmul_bot]
theorem bot_pow {n : ℕ} (hn : n ≠ 0) : (⊥ : Filter α) ^ n = ⊥ 
Arguments: {α : Type u_2} [AddMonoid α] {n : ℕ} (hn : n ≠ 0)
Goal: n • ⊥ = ⊥
-- Filter.mul_top_of_one_le
@[to_additive]
theorem mul_top_of_one_le (hf : 1 ≤ f) : f * ⊤ = ⊤ 
Arguments: {α : Type u_2} [Monoid α] {f : Filter α} (hf : 1 ≤ f)
Goal: f * ⊤ = ⊤
-- Filter.add_top_of_nonneg
@[to_additive]
theorem mul_top_of_one_le (hf : 1 ≤ f) : f * ⊤ = ⊤ 
Arguments: {α : Type u_2} [AddMonoid α] {f : Filter α} (hf : 0 ≤ f)
Goal: f + ⊤ = ⊤
-- Filter.top_mul_of_one_le
@[to_additive]
theorem top_mul_of_one_le (hf : 1 ≤ f) : ⊤ * f = ⊤ 
Arguments: {α : Type u_2} [Monoid α] {f : Filter α} (hf : 1 ≤ f)
Goal: ⊤ * f = ⊤
-- Filter.top_add_of_nonneg
@[to_additive]
theorem top_mul_of_one_le (hf : 1 ≤ f) : ⊤ * f = ⊤ 
Arguments: {α : Type u_2} [AddMonoid α] {f : Filter α} (hf : 0 ≤ f)
Goal: ⊤ + f = ⊤
-- Filter.top_add_top
@[to_additive (attr := simp)]
theorem top_mul_top : (⊤ : Filter α) * ⊤ = ⊤ 
Arguments: {α : Type u_2} [AddMonoid α]
Goal: ⊤ + ⊤ = ⊤
-- Filter.top_mul_top
@[to_additive (attr := simp)]
theorem top_mul_top : (⊤ : Filter α) * ⊤ = ⊤ 
Arguments: {α : Type u_2} [Monoid α]
Goal: ⊤ * ⊤ = ⊤
-- Filter.top_pow
@[to_additive nsmul_top]
theorem top_pow : ∀ {n : ℕ}, n ≠ 0 → (⊤ : Filter α) ^ n = ⊤
  
Arguments: {α : Type u_2} [Monoid α] {n : ℕ}
Goal: n ≠ 0 → ⊤ ^ n = ⊤
-- Filter.nsmul_top
@[to_additive nsmul_top]
theorem top_pow : ∀ {n : ℕ}, n ≠ 0 → (⊤ : Filter α) ^ n = ⊤
  
Arguments: {α : Type u_2} [AddMonoid α] {n : ℕ}
Goal: n ≠ 0 → n • ⊤ = ⊤
-- IsAddUnit.filter
@[to_additive]
protected theorem _root_.IsUnit.filter : IsUnit a → IsUnit (pure a : Filter α) 
Arguments: {α : Type u_2} [AddMonoid α] {a : α}
Goal: IsAddUnit a → IsAddUnit (pure a)
-- IsUnit.filter
@[to_additive]
protected theorem _root_.IsUnit.filter : IsUnit a → IsUnit (pure a : Filter α) 
Arguments: {α : Type u_2} [Monoid α] {a : α}
Goal: IsUnit a → IsUnit (pure a)
-- Filter.mul_eq_one_iff
@[to_additive]
protected theorem mul_eq_one_iff : f * g = 1 ↔ ∃ a b, f = pure a ∧ g = pure b ∧ a * b = 1 
Arguments: {α : Type u_2} [DivisionMonoid α] {f g : Filter α}
Goal: f * g = 1 ↔ ∃ a b, f = pure a ∧ g = pure b ∧ a * b = 1
-- Filter.add_eq_zero_iff
@[to_additive]
protected theorem mul_eq_one_iff : f * g = 1 ↔ ∃ a b, f = pure a ∧ g = pure b ∧ a * b = 1 
Arguments: {α : Type u_2} [SubtractionMonoid α] {f g : Filter α}
Goal: f + g = 0 ↔ ∃ a b, f = pure a ∧ g = pure b ∧ a + b = 0
-- Filter.isUnit_iff
@[to_additive]
theorem isUnit_iff : IsUnit f ↔ ∃ a, f = pure a ∧ IsUnit a 
Arguments: {α : Type u_2} [DivisionMonoid α] {f : Filter α}
Goal: IsUnit f ↔ ∃ a, f = pure a ∧ IsUnit a
-- Filter.isAddUnit_iff
@[to_additive]
theorem isUnit_iff : IsUnit f ↔ ∃ a, f = pure a ∧ IsUnit a 
Arguments: {α : Type u_2} [SubtractionMonoid α] {f : Filter α}
Goal: IsAddUnit f ↔ ∃ a, f = pure a ∧ IsAddUnit a
-- Filter.mul_add_subset
theorem mul_add_subset : f * (g + h) ≤ f * g + f * h 
Arguments: {α : Type u_2} [Distrib α] {f g h : Filter α}
Goal: f * (g + h) ≤ f * g + f * h
-- Filter.add_mul_subset
theorem add_mul_subset : (f + g) * h ≤ f * h + g * h 
Arguments: {α : Type u_2} [Distrib α] {f g h : Filter α}
Goal: (f + g) * h ≤ f * h + g * h
-- Filter.NeBot.mul_zero_nonneg
theorem NeBot.mul_zero_nonneg (hf : f.NeBot) : 0 ≤ f * 0 
Arguments: {α : Type u_2} [MulZeroClass α] {f : Filter α} (hf : f.NeBot)
Goal: 0 ≤ f * 0
-- Filter.NeBot.zero_mul_nonneg
theorem NeBot.zero_mul_nonneg (hg : g.NeBot) : 0 ≤ 0 * g 
Arguments: {α : Type u_2} [MulZeroClass α] {g : Filter α} (hg : g.NeBot)
Goal: 0 ≤ 0 * g
-- Filter.nonneg_sub_iff
@[to_additive (attr := simp 1100)]
protected theorem one_le_div_iff : 1 ≤ f / g ↔ ¬Disjoint f g 
Arguments: {α : Type u_2} [AddGroup α] {f g : Filter α}
Goal: 0 ≤ f - g ↔ ¬Disjoint f g
-- Filter.one_le_div_iff
@[to_additive (attr := simp 1100)]
protected theorem one_le_div_iff : 1 ≤ f / g ↔ ¬Disjoint f g 
Arguments: {α : Type u_2} [Group α] {f g : Filter α}
Goal: 1 ≤ f / g ↔ ¬Disjoint f g
-- Filter.not_one_le_div_iff
@[to_additive]
theorem not_one_le_div_iff : ¬1 ≤ f / g ↔ Disjoint f g 
Arguments: {α : Type u_2} [Group α] {f g : Filter α}
Goal: ¬1 ≤ f / g ↔ Disjoint f g
-- Filter.not_nonneg_sub_iff
@[to_additive]
theorem not_one_le_div_iff : ¬1 ≤ f / g ↔ Disjoint f g 
Arguments: {α : Type u_2} [AddGroup α] {f g : Filter α}
Goal: ¬0 ≤ f - g ↔ Disjoint f g
-- Filter.NeBot.nonneg_sub
@[to_additive]
theorem NeBot.one_le_div (h : f.NeBot) : 1 ≤ f / f 
Arguments: {α : Type u_2} [AddGroup α] {f : Filter α} (h : f.NeBot)
Goal: 0 ≤ f - f
-- Filter.NeBot.one_le_div
@[to_additive]
theorem NeBot.one_le_div (h : f.NeBot) : 1 ≤ f / f 
Arguments: {α : Type u_2} [Group α] {f : Filter α} (h : f.NeBot)
Goal: 1 ≤ f / f
-- Filter.isAddUnit_pure
@[to_additive]
theorem isUnit_pure (a : α) : IsUnit (pure a : Filter α) 
Arguments: {α : Type u_2} [AddGroup α] (a : α)
Goal: IsAddUnit (pure a)
-- Filter.isUnit_pure
@[to_additive]
theorem isUnit_pure (a : α) : IsUnit (pure a : Filter α) 
Arguments: {α : Type u_2} [Group α] (a : α)
Goal: IsUnit (pure a)
-- Filter.isUnit_iff_singleton
@[simp]
theorem isUnit_iff_singleton : IsUnit f ↔ ∃ a, f = pure a 
Arguments: {α : Type u_2} [Group α] {f : Filter α}
Goal: IsUnit f ↔ ∃ a, f = pure a
-- Filter.map_neg'
@[to_additive]
theorem map_inv' : f⁻¹.map m = (f.map m)⁻¹ 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [AddGroup α] [SubtractionMonoid β] [FunLike F α β] [AddMonoidHomClass F α β] (m : F) {f : Filter α}
Goal: Filter.map (⇑m) (-f) = -Filter.map (⇑m) f
-- Filter.map_inv'
@[to_additive]
theorem map_inv' : f⁻¹.map m = (f.map m)⁻¹ 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [Group α] [DivisionMonoid β] [FunLike F α β] [MonoidHomClass F α β] (m : F) {f : Filter α}
Goal: Filter.map (⇑m) f⁻¹ = (Filter.map (⇑m) f)⁻¹
-- Filter.Tendsto.neg_neg
@[to_additive]
protected theorem Tendsto.inv_inv : Tendsto m f₁ f₂ → Tendsto m f₁⁻¹ f₂⁻¹ 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [AddGroup α] [SubtractionMonoid β] [FunLike F α β] [AddMonoidHomClass F α β] (m : F) {f₁ : Filter α} {f₂ : Filter β}
Goal: Filter.Tendsto (⇑m) f₁ f₂ → Filter.Tendsto (⇑m) (-f₁) (-f₂)
-- Filter.Tendsto.inv_inv
@[to_additive]
protected theorem Tendsto.inv_inv : Tendsto m f₁ f₂ → Tendsto m f₁⁻¹ f₂⁻¹ 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [Group α] [DivisionMonoid β] [FunLike F α β] [MonoidHomClass F α β] (m : F) {f₁ : Filter α} {f₂ : Filter β}
Goal: Filter.Tendsto (⇑m) f₁ f₂ → Filter.Tendsto (⇑m) f₁⁻¹ f₂⁻¹
-- Filter.map_sub
@[to_additive]
protected theorem map_div : (f / g).map m = f.map m / g.map m 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [AddGroup α] [SubtractionMonoid β] [FunLike F α β] [AddMonoidHomClass F α β] (m : F) {f g : Filter α}
Goal: Filter.map (⇑m) (f - g) = Filter.map (⇑m) f - Filter.map (⇑m) g
-- Filter.map_div
@[to_additive]
protected theorem map_div : (f / g).map m = f.map m / g.map m 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [Group α] [DivisionMonoid β] [FunLike F α β] [MonoidHomClass F α β] (m : F) {f g : Filter α}
Goal: Filter.map (⇑m) (f / g) = Filter.map (⇑m) f / Filter.map (⇑m) g
-- Filter.Tendsto.div_div
@[to_additive]
protected theorem Tendsto.div_div (hf : Tendsto m f₁ f₂) (hg : Tendsto m g₁ g₂) :
    Tendsto m (f₁ / g₁) (f₂ / g₂) 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [Group α] [DivisionMonoid β] [FunLike F α β] [MonoidHomClass F α β] (m : F) {f₁ g₁ : Filter α} {f₂ g₂ : Filter β} (hf : Filter.Tendsto (⇑m) f₁ f₂) (hg : Filter.Tendsto (⇑m) g₁ g₂)
Goal: Filter.Tendsto (⇑m) (f₁ / g₁) (f₂ / g₂)
-- Filter.Tendsto.sub_sub
@[to_additive]
protected theorem Tendsto.div_div (hf : Tendsto m f₁ f₂) (hg : Tendsto m g₁ g₂) :
    Tendsto m (f₁ / g₁) (f₂ / g₂) 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [AddGroup α] [SubtractionMonoid β] [FunLike F α β] [AddMonoidHomClass F α β] (m : F) {f₁ g₁ : Filter α} {f₂ g₂ : Filter β} (hf : Filter.Tendsto (⇑m) f₁ f₂) (hg : Filter.Tendsto (⇑m) g₁ g₂)
Goal: Filter.Tendsto (⇑m) (f₁ - g₁) (f₂ - g₂)
-- Filter.NeBot.div_zero_nonneg
theorem NeBot.div_zero_nonneg (hf : f.NeBot) : 0 ≤ f / 0 
Arguments: {α : Type u_2} [GroupWithZero α] {f : Filter α} (hf : f.NeBot)
Goal: 0 ≤ f / 0
-- Filter.NeBot.zero_div_nonneg
theorem NeBot.zero_div_nonneg (hg : g.NeBot) : 0 ≤ 0 / g 
Arguments: {α : Type u_2} [GroupWithZero α] {g : Filter α} (hg : g.NeBot)
Goal: 0 ≤ 0 / g
-- Filter.map₂_smul
@[to_additive (attr := simp)]
theorem map₂_smul : map₂ (· • ·) f g = f • g 
Arguments: {α : Type u_2} {β : Type u_3} [SMul α β] {f : Filter α} {g : Filter β}
Goal: Filter.map₂ (fun x x_1 => x • x_1) f g = f • g
-- Filter.map₂_vadd
@[to_additive (attr := simp)]
theorem map₂_smul : map₂ (· • ·) f g = f • g 
Arguments: {α : Type u_2} {β : Type u_3} [VAdd α β] {f : Filter α} {g : Filter β}
Goal: Filter.map₂ (fun x x_1 => x +ᵥ x_1) f g = f +ᵥ g
-- Filter.mem_smul
@[to_additive]
theorem mem_smul : t ∈ f • g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ • t₂ ⊆ t 
Arguments: {α : Type u_2} {β : Type u_3} [SMul α β] {f : Filter α} {g : Filter β} {t : Set β}
Goal: t ∈ f • g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ • t₂ ⊆ t
-- Filter.mem_vadd
@[to_additive]
theorem mem_smul : t ∈ f • g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ • t₂ ⊆ t 
Arguments: {α : Type u_2} {β : Type u_3} [VAdd α β] {f : Filter α} {g : Filter β} {t : Set β}
Goal: t ∈ f +ᵥ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ +ᵥ t₂ ⊆ t
-- Filter.vadd_mem_vadd
@[to_additive]
theorem smul_mem_smul : s ∈ f → t ∈ g → s • t ∈ f • g 
Arguments: {α : Type u_2} {β : Type u_3} [VAdd α β] {f : Filter α} {g : Filter β} {s : Set α} {t : Set β}
Goal: s ∈ f → t ∈ g → s +ᵥ t ∈ f +ᵥ g
-- Filter.smul_mem_smul
@[to_additive]
theorem smul_mem_smul : s ∈ f → t ∈ g → s • t ∈ f • g 
Arguments: {α : Type u_2} {β : Type u_3} [SMul α β] {f : Filter α} {g : Filter β} {s : Set α} {t : Set β}
Goal: s ∈ f → t ∈ g → s • t ∈ f • g
-- Filter.bot_vadd
@[to_additive (attr := simp)]
theorem bot_smul : (⊥ : Filter α) • g = ⊥ 
Arguments: {α : Type u_2} {β : Type u_3} [VAdd α β] {g : Filter β}
Goal: ⊥ +ᵥ g = ⊥
-- Filter.bot_smul
@[to_additive (attr := simp)]
theorem bot_smul : (⊥ : Filter α) • g = ⊥ 
Arguments: {α : Type u_2} {β : Type u_3} [SMul α β] {g : Filter β}
Goal: ⊥ • g = ⊥
-- Filter.vadd_bot
@[to_additive (attr := simp)]
theorem smul_bot : f • (⊥ : Filter β) = ⊥ 
Arguments: {α : Type u_2} {β : Type u_3} [VAdd α β] {f : Filter α}
Goal: f +ᵥ ⊥ = ⊥
-- Filter.smul_bot
@[to_additive (attr := simp)]
theorem smul_bot : f • (⊥ : Filter β) = ⊥ 
Arguments: {α : Type u_2} {β : Type u_3} [SMul α β] {f : Filter α}
Goal: f • ⊥ = ⊥
-- Filter.vadd_eq_bot_iff
@[to_additive (attr := simp)]
theorem smul_eq_bot_iff : f • g = ⊥ ↔ f = ⊥ ∨ g = ⊥ 
Arguments: {α : Type u_2} {β : Type u_3} [VAdd α β] {f : Filter α} {g : Filter β}
Goal: f +ᵥ g = ⊥ ↔ f = ⊥ ∨ g = ⊥
-- Filter.smul_eq_bot_iff
@[to_additive (attr := simp)]
theorem smul_eq_bot_iff : f • g = ⊥ ↔ f = ⊥ ∨ g = ⊥ 
Arguments: {α : Type u_2} {β : Type u_3} [SMul α β] {f : Filter α} {g : Filter β}
Goal: f • g = ⊥ ↔ f = ⊥ ∨ g = ⊥
-- Filter.smul_neBot_iff
@[to_additive (attr := simp)]
theorem smul_neBot_iff : (f • g).NeBot ↔ f.NeBot ∧ g.NeBot 
Arguments: {α : Type u_2} {β : Type u_3} [SMul α β] {f : Filter α} {g : Filter β}
Goal: (f • g).NeBot ↔ f.NeBot ∧ g.NeBot
-- Filter.vadd_neBot_iff
@[to_additive (attr := simp)]
theorem smul_neBot_iff : (f • g).NeBot ↔ f.NeBot ∧ g.NeBot 
Arguments: {α : Type u_2} {β : Type u_3} [VAdd α β] {f : Filter α} {g : Filter β}
Goal: (f +ᵥ g).NeBot ↔ f.NeBot ∧ g.NeBot
-- Filter.NeBot.vadd
@[to_additive]
protected theorem NeBot.smul : NeBot f → NeBot g → NeBot (f • g) 
Arguments: {α : Type u_2} {β : Type u_3} [VAdd α β] {f : Filter α} {g : Filter β}
Goal: f.NeBot → g.NeBot → (f +ᵥ g).NeBot
-- Filter.NeBot.smul
@[to_additive]
protected theorem NeBot.smul : NeBot f → NeBot g → NeBot (f • g) 
Arguments: {α : Type u_2} {β : Type u_3} [SMul α β] {f : Filter α} {g : Filter β}
Goal: f.NeBot → g.NeBot → (f • g).NeBot
-- Filter.NeBot.of_smul_left
@[to_additive]
theorem NeBot.of_smul_left : (f • g).NeBot → f.NeBot 
Arguments: {α : Type u_2} {β : Type u_3} [SMul α β] {f : Filter α} {g : Filter β}
Goal: (f • g).NeBot → f.NeBot
-- Filter.NeBot.of_vadd_left
@[to_additive]
theorem NeBot.of_smul_left : (f • g).NeBot → f.NeBot 
Arguments: {α : Type u_2} {β : Type u_3} [VAdd α β] {f : Filter α} {g : Filter β}
Goal: (f +ᵥ g).NeBot → f.NeBot
-- Filter.NeBot.of_smul_right
@[to_additive]
theorem NeBot.of_smul_right : (f • g).NeBot → g.NeBot 
Arguments: {α : Type u_2} {β : Type u_3} [SMul α β] {f : Filter α} {g : Filter β}
Goal: (f • g).NeBot → g.NeBot
-- Filter.NeBot.of_vadd_right
@[to_additive]
theorem NeBot.of_smul_right : (f • g).NeBot → g.NeBot 
Arguments: {α : Type u_2} {β : Type u_3} [VAdd α β] {f : Filter α} {g : Filter β}
Goal: (f +ᵥ g).NeBot → g.NeBot
-- Filter.vadd.instNeBot
@[to_additive vadd.instNeBot]
lemma smul.instNeBot [NeBot f] [NeBot g] : NeBot (f • g) 
Arguments: {α : Type u_2} {β : Type u_3} [VAdd α β] {f : Filter α} {g : Filter β} [f.NeBot] [g.NeBot]
Goal: (f +ᵥ g).NeBot
-- Filter.smul.instNeBot
@[to_additive vadd.instNeBot]
lemma smul.instNeBot [NeBot f] [NeBot g] : NeBot (f • g) 
Arguments: {α : Type u_2} {β : Type u_3} [SMul α β] {f : Filter α} {g : Filter β} [f.NeBot] [g.NeBot]
Goal: (f • g).NeBot
-- Filter.pure_vadd
@[to_additive (attr := simp)]
theorem pure_smul : (pure a : Filter α) • g = g.map (a • ·) 
Arguments: {α : Type u_2} {β : Type u_3} [VAdd α β] {g : Filter β} {a : α}
Goal: pure a +ᵥ g = Filter.map (fun x => a +ᵥ x) g
-- Filter.pure_smul
@[to_additive (attr := simp)]
theorem pure_smul : (pure a : Filter α) • g = g.map (a • ·) 
Arguments: {α : Type u_2} {β : Type u_3} [SMul α β] {g : Filter β} {a : α}
Goal: pure a • g = Filter.map (fun x => a • x) g
-- Filter.vadd_pure
@[to_additive (attr := simp)]
theorem smul_pure : f • pure b = f.map (· • b) 
Arguments: {α : Type u_2} {β : Type u_3} [VAdd α β] {f : Filter α} {b : β}
Goal: f +ᵥ pure b = Filter.map (fun x => x +ᵥ b) f
-- Filter.smul_pure
@[to_additive (attr := simp)]
theorem smul_pure : f • pure b = f.map (· • b) 
Arguments: {α : Type u_2} {β : Type u_3} [SMul α β] {f : Filter α} {b : β}
Goal: f • pure b = Filter.map (fun x => x • b) f
-- Filter.pure_vadd_pure
@[to_additive]
-- Porting note (#11119): removed `simp` attribute because `simpNF` says it can prove it.
theorem pure_smul_pure : (pure a : Filter α) • (pure b : Filter β) = pure (a • b) 
Arguments: {α : Type u_2} {β : Type u_3} [VAdd α β] {a : α} {b : β}
Goal: pure a +ᵥ pure b = pure (a +ᵥ b)
-- Filter.pure_smul_pure
@[to_additive]
-- Porting note (#11119): removed `simp` attribute because `simpNF` says it can prove it.
theorem pure_smul_pure : (pure a : Filter α) • (pure b : Filter β) = pure (a • b) 
Arguments: {α : Type u_2} {β : Type u_3} [SMul α β] {a : α} {b : β}
Goal: pure a • pure b = pure (a • b)
-- Filter.vadd_le_vadd
@[to_additive]
theorem smul_le_smul : f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ • g₁ ≤ f₂ • g₂ 
Arguments: {α : Type u_2} {β : Type u_3} [VAdd α β] {f₁ f₂ : Filter α} {g₁ g₂ : Filter β}
Goal: f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ +ᵥ g₁ ≤ f₂ +ᵥ g₂
-- Filter.smul_le_smul
@[to_additive]
theorem smul_le_smul : f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ • g₁ ≤ f₂ • g₂ 
Arguments: {α : Type u_2} {β : Type u_3} [SMul α β] {f₁ f₂ : Filter α} {g₁ g₂ : Filter β}
Goal: f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ • g₁ ≤ f₂ • g₂
-- Filter.smul_le_smul_left
@[to_additive]
theorem smul_le_smul_left : g₁ ≤ g₂ → f • g₁ ≤ f • g₂ 
Arguments: {α : Type u_2} {β : Type u_3} [SMul α β] {f : Filter α} {g₁ g₂ : Filter β}
Goal: g₁ ≤ g₂ → f • g₁ ≤ f • g₂
-- Filter.vadd_le_vadd_left
@[to_additive]
theorem smul_le_smul_left : g₁ ≤ g₂ → f • g₁ ≤ f • g₂ 
Arguments: {α : Type u_2} {β : Type u_3} [VAdd α β] {f : Filter α} {g₁ g₂ : Filter β}
Goal: g₁ ≤ g₂ → f +ᵥ g₁ ≤ f +ᵥ g₂
-- Filter.smul_le_smul_right
@[to_additive]
theorem smul_le_smul_right : f₁ ≤ f₂ → f₁ • g ≤ f₂ • g 
Arguments: {α : Type u_2} {β : Type u_3} [SMul α β] {f₁ f₂ : Filter α} {g : Filter β}
Goal: f₁ ≤ f₂ → f₁ • g ≤ f₂ • g
-- Filter.vadd_le_vadd_right
@[to_additive]
theorem smul_le_smul_right : f₁ ≤ f₂ → f₁ • g ≤ f₂ • g 
Arguments: {α : Type u_2} {β : Type u_3} [VAdd α β] {f₁ f₂ : Filter α} {g : Filter β}
Goal: f₁ ≤ f₂ → f₁ +ᵥ g ≤ f₂ +ᵥ g
-- Filter.le_vadd_iff
@[to_additive (attr := simp)]
theorem le_smul_iff : h ≤ f • g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t ∈ g → s • t ∈ h 
Arguments: {α : Type u_2} {β : Type u_3} [VAdd α β] {f : Filter α} {g h : Filter β}
Goal: h ≤ f +ᵥ g ↔ ∀ ⦃s : Set α⦄, s ∈ f → ∀ ⦃t : Set β⦄, t ∈ g → s +ᵥ t ∈ h
-- Filter.le_smul_iff
@[to_additive (attr := simp)]
theorem le_smul_iff : h ≤ f • g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t ∈ g → s • t ∈ h 
Arguments: {α : Type u_2} {β : Type u_3} [SMul α β] {f : Filter α} {g h : Filter β}
Goal: h ≤ f • g ↔ ∀ ⦃s : Set α⦄, s ∈ f → ∀ ⦃t : Set β⦄, t ∈ g → s • t ∈ h
-- Filter.map₂_vsub
@[simp]
theorem map₂_vsub : map₂ (· -ᵥ ·) f g = f -ᵥ g 
Arguments: {α : Type u_2} {β : Type u_3} [VSub α β] {f g : Filter β}
Goal: Filter.map₂ (fun x x_1 => x -ᵥ x_1) f g = f -ᵥ g
-- Filter.mem_vsub
theorem mem_vsub {s : Set α} : s ∈ f -ᵥ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ -ᵥ t₂ ⊆ s 
Arguments: {α : Type u_2} {β : Type u_3} [VSub α β] {f g : Filter β} {s : Set α}
Goal: s ∈ f -ᵥ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ -ᵥ t₂ ⊆ s
-- Filter.vsub_mem_vsub
theorem vsub_mem_vsub : s ∈ f → t ∈ g → s -ᵥ t ∈ f -ᵥ g 
Arguments: {α : Type u_2} {β : Type u_3} [VSub α β] {f g : Filter β} {s t : Set β}
Goal: s ∈ f → t ∈ g → s -ᵥ t ∈ f -ᵥ g
-- Filter.bot_vsub
@[simp]
theorem bot_vsub : (⊥ : Filter β) -ᵥ g = ⊥ 
Arguments: {α : Type u_2} {β : Type u_3} [VSub α β] {g : Filter β}
Goal: ⊥ -ᵥ g = ⊥
-- Filter.vsub_bot
@[simp]
theorem vsub_bot : f -ᵥ (⊥ : Filter β) = ⊥ 
Arguments: {α : Type u_2} {β : Type u_3} [VSub α β] {f : Filter β}
Goal: f -ᵥ ⊥ = ⊥
-- Filter.vsub_eq_bot_iff
@[simp]
theorem vsub_eq_bot_iff : f -ᵥ g = ⊥ ↔ f = ⊥ ∨ g = ⊥ 
Arguments: {α : Type u_2} {β : Type u_3} [VSub α β] {f g : Filter β}
Goal: f -ᵥ g = ⊥ ↔ f = ⊥ ∨ g = ⊥
-- Filter.vsub_neBot_iff
@[simp]
theorem vsub_neBot_iff : (f -ᵥ g : Filter α).NeBot ↔ f.NeBot ∧ g.NeBot 
Arguments: {α : Type u_2} {β : Type u_3} [VSub α β] {f g : Filter β}
Goal: (f -ᵥ g).NeBot ↔ f.NeBot ∧ g.NeBot
-- Filter.NeBot.vsub
protected theorem NeBot.vsub : NeBot f → NeBot g → NeBot (f -ᵥ g) 
Arguments: {α : Type u_2} {β : Type u_3} [VSub α β] {f g : Filter β}
Goal: f.NeBot → g.NeBot → (f -ᵥ g).NeBot
-- Filter.NeBot.of_vsub_left
theorem NeBot.of_vsub_left : (f -ᵥ g : Filter α).NeBot → f.NeBot 
Arguments: {α : Type u_2} {β : Type u_3} [VSub α β] {f g : Filter β}
Goal: (f -ᵥ g).NeBot → f.NeBot
-- Filter.NeBot.of_vsub_right
theorem NeBot.of_vsub_right : (f -ᵥ g : Filter α).NeBot → g.NeBot 
Arguments: {α : Type u_2} {β : Type u_3} [VSub α β] {f g : Filter β}
Goal: (f -ᵥ g).NeBot → g.NeBot
-- Filter.vsub.instNeBot
lemma vsub.instNeBot [NeBot f] [NeBot g] : NeBot (f -ᵥ g) 
Arguments: {α : Type u_2} {β : Type u_3} [VSub α β] {f g : Filter β} [f.NeBot] [g.NeBot]
Goal: (f -ᵥ g).NeBot
-- Filter.pure_vsub
@[simp]
theorem pure_vsub : (pure a : Filter β) -ᵥ g = g.map (a -ᵥ ·) 
Arguments: {α : Type u_2} {β : Type u_3} [VSub α β] {g : Filter β} {a : β}
Goal: pure a -ᵥ g = Filter.map (fun x => a -ᵥ x) g
-- Filter.vsub_pure
@[simp]
theorem vsub_pure : f -ᵥ pure b = f.map (· -ᵥ b) 
Arguments: {α : Type u_2} {β : Type u_3} [VSub α β] {f : Filter β} {b : β}
Goal: f -ᵥ pure b = Filter.map (fun x => x -ᵥ b) f
-- Filter.pure_vsub_pure
theorem pure_vsub_pure : (pure a : Filter β) -ᵥ pure b = (pure (a -ᵥ b) : Filter α) 
Arguments: {α : Type u_2} {β : Type u_3} [VSub α β] {a b : β}
Goal: pure a -ᵥ pure b = pure (a -ᵥ b)
-- Filter.vsub_le_vsub
theorem vsub_le_vsub : f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ -ᵥ g₁ ≤ f₂ -ᵥ g₂ 
Arguments: {α : Type u_2} {β : Type u_3} [VSub α β] {f₁ f₂ g₁ g₂ : Filter β}
Goal: f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ -ᵥ g₁ ≤ f₂ -ᵥ g₂
-- Filter.vsub_le_vsub_left
theorem vsub_le_vsub_left : g₁ ≤ g₂ → f -ᵥ g₁ ≤ f -ᵥ g₂ 
Arguments: {α : Type u_2} {β : Type u_3} [VSub α β] {f g₁ g₂ : Filter β}
Goal: g₁ ≤ g₂ → f -ᵥ g₁ ≤ f -ᵥ g₂
-- Filter.vsub_le_vsub_right
theorem vsub_le_vsub_right : f₁ ≤ f₂ → f₁ -ᵥ g ≤ f₂ -ᵥ g 
Arguments: {α : Type u_2} {β : Type u_3} [VSub α β] {f₁ f₂ g : Filter β}
Goal: f₁ ≤ f₂ → f₁ -ᵥ g ≤ f₂ -ᵥ g
-- Filter.le_vsub_iff
@[simp]
theorem le_vsub_iff : h ≤ f -ᵥ g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t ∈ g → s -ᵥ t ∈ h 
Arguments: {α : Type u_2} {β : Type u_3} [VSub α β] {f g : Filter β} {h : Filter α}
Goal: h ≤ f -ᵥ g ↔ ∀ ⦃s : Set β⦄, s ∈ f → ∀ ⦃t : Set β⦄, t ∈ g → s -ᵥ t ∈ h
-- Filter.map_smul
@[to_additive (attr := simp)]
protected theorem map_smul : map (fun b => a • b) f = a • f 
Arguments: {α : Type u_2} {β : Type u_3} [SMul α β] {f : Filter β} {a : α}
Goal: Filter.map (fun b => a • b) f = a • f
-- Filter.map_vadd
@[to_additive (attr := simp)]
protected theorem map_smul : map (fun b => a • b) f = a • f 
Arguments: {α : Type u_2} {β : Type u_3} [VAdd α β] {f : Filter β} {a : α}
Goal: Filter.map (fun b => a +ᵥ b) f = a +ᵥ f
-- Filter.mem_vadd_filter
@[to_additive]
theorem mem_smul_filter : s ∈ a • f ↔ (a • ·) ⁻¹' s ∈ f 
Arguments: {α : Type u_2} {β : Type u_3} [VAdd α β] {f : Filter β} {s : Set β} {a : α}
Goal: s ∈ a +ᵥ f ↔ (fun x => a +ᵥ x) ⁻¹' s ∈ f
-- Filter.mem_smul_filter
@[to_additive]
theorem mem_smul_filter : s ∈ a • f ↔ (a • ·) ⁻¹' s ∈ f 
Arguments: {α : Type u_2} {β : Type u_3} [SMul α β] {f : Filter β} {s : Set β} {a : α}
Goal: s ∈ a • f ↔ (fun x => a • x) ⁻¹' s ∈ f
-- Filter.smul_set_mem_smul_filter
@[to_additive]
theorem smul_set_mem_smul_filter : s ∈ f → a • s ∈ a • f 
Arguments: {α : Type u_2} {β : Type u_3} [SMul α β] {f : Filter β} {s : Set β} {a : α}
Goal: s ∈ f → a • s ∈ a • f
-- Filter.vadd_set_mem_vadd_filter
@[to_additive]
theorem smul_set_mem_smul_filter : s ∈ f → a • s ∈ a • f 
Arguments: {α : Type u_2} {β : Type u_3} [VAdd α β] {f : Filter β} {s : Set β} {a : α}
Goal: s ∈ f → a +ᵥ s ∈ a +ᵥ f
-- Filter.smul_filter_bot
@[to_additive (attr := simp)]
theorem smul_filter_bot : a • (⊥ : Filter β) = ⊥ 
Arguments: {α : Type u_2} {β : Type u_3} [SMul α β] {a : α}
Goal: a • ⊥ = ⊥
-- Filter.vadd_filter_bot
@[to_additive (attr := simp)]
theorem smul_filter_bot : a • (⊥ : Filter β) = ⊥ 
Arguments: {α : Type u_2} {β : Type u_3} [VAdd α β] {a : α}
Goal: a +ᵥ ⊥ = ⊥
-- Filter.smul_filter_eq_bot_iff
@[to_additive (attr := simp)]
theorem smul_filter_eq_bot_iff : a • f = ⊥ ↔ f = ⊥ 
Arguments: {α : Type u_2} {β : Type u_3} [SMul α β] {f : Filter β} {a : α}
Goal: a • f = ⊥ ↔ f = ⊥
-- Filter.vadd_filter_eq_bot_iff
@[to_additive (attr := simp)]
theorem smul_filter_eq_bot_iff : a • f = ⊥ ↔ f = ⊥ 
Arguments: {α : Type u_2} {β : Type u_3} [VAdd α β] {f : Filter β} {a : α}
Goal: a +ᵥ f = ⊥ ↔ f = ⊥
-- Filter.smul_filter_neBot_iff
@[to_additive (attr := simp)]
theorem smul_filter_neBot_iff : (a • f).NeBot ↔ f.NeBot 
Arguments: {α : Type u_2} {β : Type u_3} [SMul α β] {f : Filter β} {a : α}
Goal: (a • f).NeBot ↔ f.NeBot
-- Filter.vadd_filter_neBot_iff
@[to_additive (attr := simp)]
theorem smul_filter_neBot_iff : (a • f).NeBot ↔ f.NeBot 
Arguments: {α : Type u_2} {β : Type u_3} [VAdd α β] {f : Filter β} {a : α}
Goal: (a +ᵥ f).NeBot ↔ f.NeBot
-- Filter.NeBot.vadd_filter
@[to_additive]
theorem NeBot.smul_filter : f.NeBot → (a • f).NeBot 
Arguments: {α : Type u_2} {β : Type u_3} [VAdd α β] {f : Filter β} {a : α}
Goal: f.NeBot → (a +ᵥ f).NeBot
-- Filter.NeBot.smul_filter
@[to_additive]
theorem NeBot.smul_filter : f.NeBot → (a • f).NeBot 
Arguments: {α : Type u_2} {β : Type u_3} [SMul α β] {f : Filter β} {a : α}
Goal: f.NeBot → (a • f).NeBot
-- Filter.NeBot.of_smul_filter
@[to_additive]
theorem NeBot.of_smul_filter : (a • f).NeBot → f.NeBot 
Arguments: {α : Type u_2} {β : Type u_3} [SMul α β] {f : Filter β} {a : α}
Goal: (a • f).NeBot → f.NeBot
-- Filter.NeBot.of_vadd_filter
@[to_additive]
theorem NeBot.of_smul_filter : (a • f).NeBot → f.NeBot 
Arguments: {α : Type u_2} {β : Type u_3} [VAdd α β] {f : Filter β} {a : α}
Goal: (a +ᵥ f).NeBot → f.NeBot