File: Mathlib/Order/Filter/Pointwise.lean

full_name: Filter.instOne
code: /-- `1 : Filter α` is defined as the filter of sets containing `1 : α` in locale `Pointwise`. -/
@[to_additive
      "`0 : Filter α` is defined as the filter of sets containing `0 : α` in locale `Pointwise`."]
protected def instOne : One (Filter α) 
goal: One (Filter α)

full_name: Filter.instZero
code: /-- `1 : Filter α` is defined as the filter of sets containing `1 : α` in locale `Pointwise`. -/
@[to_additive
      "`0 : Filter α` is defined as the filter of sets containing `0 : α` in locale `Pointwise`."]
protected def instOne : One (Filter α) 
goal: Zero (Filter α)

full_name: Filter.mem_zero
code: @[to_additive (attr := simp)]
theorem mem_one : s ∈ (1 : Filter α) ↔ (1 : α) ∈ s 
goal: s ∈ 0 ↔ 0 ∈ s

full_name: Filter.mem_one
code: @[to_additive (attr := simp)]
theorem mem_one : s ∈ (1 : Filter α) ↔ (1 : α) ∈ s 
goal: s ∈ 1 ↔ 1 ∈ s

full_name: Filter.one_mem_one
code: @[to_additive]
theorem one_mem_one : (1 : Set α) ∈ (1 : Filter α) 
goal: 1 ∈ 1

full_name: Filter.zero_mem_zero
code: @[to_additive]
theorem one_mem_one : (1 : Set α) ∈ (1 : Filter α) 
goal: 0 ∈ 0

full_name: Filter.pure_zero
code: @[to_additive (attr := simp)]
theorem pure_one : pure 1 = (1 : Filter α) 
goal: pure 0 = 0

full_name: Filter.pure_one
code: @[to_additive (attr := simp)]
theorem pure_one : pure 1 = (1 : Filter α) 
goal: pure 1 = 1

full_name: Filter.principal_zero
code: @[to_additive (attr := simp)]
theorem principal_one : 𝓟 1 = (1 : Filter α) 
goal: 𝓟 0 = 0

full_name: Filter.principal_one
code: @[to_additive (attr := simp)]
theorem principal_one : 𝓟 1 = (1 : Filter α) 
goal: 𝓟 1 = 1

full_name: Filter.one_neBot
code: @[to_additive]
theorem one_neBot : (1 : Filter α).NeBot 
goal: Filter.NeBot 1

full_name: Filter.zero_neBot
code: @[to_additive]
theorem one_neBot : (1 : Filter α).NeBot 
goal: Filter.NeBot 0

full_name: Filter.map_zero'
code: @[to_additive (attr := simp)]
protected theorem map_one' (f : α → β) : (1 : Filter α).map f = pure (f 1) 
goal: Filter.map f 0 = pure (f 0)

full_name: Filter.map_one'
code: @[to_additive (attr := simp)]
protected theorem map_one' (f : α → β) : (1 : Filter α).map f = pure (f 1) 
goal: Filter.map f 1 = pure (f 1)

full_name: Filter.le_one_iff
code: @[to_additive (attr := simp)]
theorem le_one_iff : f ≤ 1 ↔ (1 : Set α) ∈ f 
goal: f ≤ 1 ↔ 1 ∈ f

full_name: Filter.nonpos_iff
code: @[to_additive (attr := simp)]
theorem le_one_iff : f ≤ 1 ↔ (1 : Set α) ∈ f 
goal: f ≤ 0 ↔ 0 ∈ f

full_name: Filter.NeBot.le_one_iff
code: @[to_additive]
protected theorem NeBot.le_one_iff (h : f.NeBot) : f ≤ 1 ↔ f = 1 
goal: f ≤ 1 ↔ f = 1

full_name: Filter.NeBot.nonpos_iff
code: @[to_additive]
protected theorem NeBot.le_one_iff (h : f.NeBot) : f ≤ 1 ↔ f = 1 
goal: f ≤ 0 ↔ f = 0

full_name: Filter.eventually_one
code: @[to_additive (attr := simp)]
theorem eventually_one {p : α → Prop} : (∀ᶠ x in 1, p x) ↔ p 1 
goal: (∀ᶠ (x : α) in 1, p x) ↔ p 1

full_name: Filter.eventually_zero
code: @[to_additive (attr := simp)]
theorem eventually_one {p : α → Prop} : (∀ᶠ x in 1, p x) ↔ p 1 
goal: (∀ᶠ (x : α) in 0, p x) ↔ p 0

full_name: Filter.tendsto_one
code: @[to_additive (attr := simp)]
theorem tendsto_one {a : Filter β} {f : β → α} : Tendsto f a 1 ↔ ∀ᶠ x in a, f x = 1 
goal: Filter.Tendsto f a 1 ↔ ∀ᶠ (x : β) in a, f x = 1

full_name: Filter.tendsto_zero
code: @[to_additive (attr := simp)]
theorem tendsto_one {a : Filter β} {f : β → α} : Tendsto f a 1 ↔ ∀ᶠ x in a, f x = 1 
goal: Filter.Tendsto f a 0 ↔ ∀ᶠ (x : β) in a, f x = 0

full_name: Filter.zero_sum_zero
code: @[to_additive (attr := simp)]
theorem one_prod_one [One β] : (1 : Filter α) ×ˢ (1 : Filter β) = 1 
goal: 0 ×ˢ 0 = 0

full_name: Filter.one_prod_one
code: @[to_additive (attr := simp)]
theorem one_prod_one [One β] : (1 : Filter α) ×ˢ (1 : Filter β) = 1 
goal: 1 ×ˢ 1 = 1

full_name: Filter.pureOneHom
code: /-- `pure` as a `OneHom`. -/
@[to_additive "`pure` as a `ZeroHom`."]
def pureOneHom : OneHom α (Filter α) 
goal: OneHom α (Filter α)

full_name: Filter.pureZeroHom
code: /-- `pure` as a `OneHom`. -/
@[to_additive "`pure` as a `ZeroHom`."]
def pureOneHom : OneHom α (Filter α) 
goal: ZeroHom α (Filter α)

full_name: Filter.coe_pureOneHom
code: @[to_additive (attr := simp)]
theorem coe_pureOneHom : (pureOneHom : α → Filter α) = pure 
goal: ⇑Filter.pureOneHom = pure

full_name: Filter.coe_pureZeroHom
code: @[to_additive (attr := simp)]
theorem coe_pureOneHom : (pureOneHom : α → Filter α) = pure 
goal: ⇑Filter.pureZeroHom = pure

full_name: Filter.pureZeroHom_apply
code: @[to_additive (attr := simp)]
theorem pureOneHom_apply (a : α) : pureOneHom a = pure a 
goal: Filter.pureZeroHom a = pure a

full_name: Filter.pureOneHom_apply
code: @[to_additive (attr := simp)]
theorem pureOneHom_apply (a : α) : pureOneHom a = pure a 
goal: Filter.pureOneHom a = pure a

full_name: Filter.map_zero
code: @[to_additive]
-- Porting note (#11119): removed `simp` attribute because `simpNF` says it can prove it.
protected theorem map_one [FunLike F α β] [OneHomClass F α β] (φ : F) : map φ 1 = 1 
goal: Filter.map (⇑φ) 0 = 0

full_name: Filter.map_one
code: @[to_additive]
-- Porting note (#11119): removed `simp` attribute because `simpNF` says it can prove it.
protected theorem map_one [FunLike F α β] [OneHomClass F α β] (φ : F) : map φ 1 = 1 
goal: Filter.map (⇑φ) 1 = 1

full_name: Filter.instNeg
code: /-- The inverse of a filter is the pointwise preimage under `⁻¹` of its sets. -/
@[to_additive "The negation of a filter is the pointwise preimage under `-` of its sets."]
instance instInv : Inv (Filter α) 
goal: Neg (Filter α)

full_name: Filter.instInv
code: /-- The inverse of a filter is the pointwise preimage under `⁻¹` of its sets. -/
@[to_additive "The negation of a filter is the pointwise preimage under `-` of its sets."]
instance instInv : Inv (Filter α) 
goal: Inv (Filter α)

full_name: Filter.map_inv
code: @[to_additive (attr := simp)]
protected theorem map_inv : f.map Inv.inv = f⁻¹ 
goal: Filter.map Inv.inv f = f⁻¹

full_name: Filter.map_neg
code: @[to_additive (attr := simp)]
protected theorem map_inv : f.map Inv.inv = f⁻¹ 
goal: Filter.map Neg.neg f = -f

full_name: Filter.mem_inv
code: @[to_additive]
theorem mem_inv : s ∈ f⁻¹ ↔ Inv.inv ⁻¹' s ∈ f 
goal: s ∈ f⁻¹ ↔ Inv.inv ⁻¹' s ∈ f

full_name: Filter.mem_neg
code: @[to_additive]
theorem mem_inv : s ∈ f⁻¹ ↔ Inv.inv ⁻¹' s ∈ f 
goal: s ∈ -f ↔ Neg.neg ⁻¹' s ∈ f

full_name: Filter.neg_le_neg
code: @[to_additive]
protected theorem inv_le_inv (hf : f ≤ g) : f⁻¹ ≤ g⁻¹ 
goal: -f ≤ -g

full_name: Filter.inv_le_inv
code: @[to_additive]
protected theorem inv_le_inv (hf : f ≤ g) : f⁻¹ ≤ g⁻¹ 
goal: f⁻¹ ≤ g⁻¹

full_name: Filter.neg_pure
code: @[to_additive (attr := simp)]
theorem inv_pure : (pure a : Filter α)⁻¹ = pure a⁻¹ 
goal: -pure a = pure (-a)

full_name: Filter.inv_pure
code: @[to_additive (attr := simp)]
theorem inv_pure : (pure a : Filter α)⁻¹ = pure a⁻¹ 
goal: (pure a)⁻¹ = pure a⁻¹

full_name: Filter.neg_eq_bot_iff
code: @[to_additive (attr := simp)]
theorem inv_eq_bot_iff : f⁻¹ = ⊥ ↔ f = ⊥ 
goal: -f = ⊥ ↔ f = ⊥

full_name: Filter.inv_eq_bot_iff
code: @[to_additive (attr := simp)]
theorem inv_eq_bot_iff : f⁻¹ = ⊥ ↔ f = ⊥ 
goal: f⁻¹ = ⊥ ↔ f = ⊥

full_name: Filter.neBot_inv_iff
code: @[to_additive (attr := simp)]
theorem neBot_inv_iff : f⁻¹.NeBot ↔ NeBot f 
goal: f⁻¹.NeBot ↔ f.NeBot

full_name: Filter.neBot_neg_iff
code: @[to_additive (attr := simp)]
theorem neBot_inv_iff : f⁻¹.NeBot ↔ NeBot f 
goal: (-f).NeBot ↔ f.NeBot

full_name: Filter.NeBot.neg
code: @[to_additive]
protected theorem NeBot.inv : f.NeBot → f⁻¹.NeBot 
goal: f.NeBot → (-f).NeBot

full_name: Filter.NeBot.inv
code: @[to_additive]
protected theorem NeBot.inv : f.NeBot → f⁻¹.NeBot 
goal: f.NeBot → f⁻¹.NeBot

full_name: Filter.neg.instNeBot
code: @[to_additive neg.instNeBot]
lemma inv.instNeBot [NeBot f] : NeBot f⁻¹ 
goal: (-f).NeBot

full_name: Filter.inv.instNeBot
code: @[to_additive neg.instNeBot]
lemma inv.instNeBot [NeBot f] : NeBot f⁻¹ 
goal: f⁻¹.NeBot

full_name: Filter.comap_neg
code: @[to_additive (attr := simp)]
protected lemma comap_inv : comap Inv.inv f = f⁻¹ 
goal: Filter.comap Neg.neg f = -f

full_name: Filter.comap_inv
code: @[to_additive (attr := simp)]
protected lemma comap_inv : comap Inv.inv f = f⁻¹ 
goal: Filter.comap Inv.inv f = f⁻¹

full_name: Filter.neg_mem_neg
code: @[to_additive]
theorem inv_mem_inv (hs : s ∈ f) : s⁻¹ ∈ f⁻¹ 
goal: -s ∈ -f

full_name: Filter.inv_mem_inv
code: @[to_additive]
theorem inv_mem_inv (hs : s ∈ f) : s⁻¹ ∈ f⁻¹ 
goal: s⁻¹ ∈ f⁻¹

full_name: Filter.instInvolutiveNeg
code: /-- Inversion is involutive on `Filter α` if it is on `α`. -/
@[to_additive "Negation is involutive on `Filter α` if it is on `α`."]
protected def instInvolutiveInv : InvolutiveInv (Filter α) 
goal: InvolutiveNeg (Filter α)

full_name: Filter.instInvolutiveInv
code: /-- Inversion is involutive on `Filter α` if it is on `α`. -/
@[to_additive "Negation is involutive on `Filter α` if it is on `α`."]
protected def instInvolutiveInv : InvolutiveInv (Filter α) 
goal: InvolutiveInv (Filter α)

full_name: Filter.inv_le_inv_iff
code: @[to_additive (attr := simp)]
protected theorem inv_le_inv_iff : f⁻¹ ≤ g⁻¹ ↔ f ≤ g 
goal: f⁻¹ ≤ g⁻¹ ↔ f ≤ g

full_name: Filter.neg_le_neg_iff
code: @[to_additive (attr := simp)]
protected theorem inv_le_inv_iff : f⁻¹ ≤ g⁻¹ ↔ f ≤ g 
goal: -f ≤ -g ↔ f ≤ g

full_name: Filter.neg_le_iff_le_neg
code: @[to_additive]
theorem inv_le_iff_le_inv : f⁻¹ ≤ g ↔ f ≤ g⁻¹ 
goal: -f ≤ g ↔ f ≤ -g

full_name: Filter.inv_le_iff_le_inv
code: @[to_additive]
theorem inv_le_iff_le_inv : f⁻¹ ≤ g ↔ f ≤ g⁻¹ 
goal: f⁻¹ ≤ g ↔ f ≤ g⁻¹

full_name: Filter.neg_le_self
code: @[to_additive (attr := simp)]
theorem inv_le_self : f⁻¹ ≤ f ↔ f⁻¹ = f 
goal: -f ≤ f ↔ -f = f

full_name: Filter.inv_le_self
code: @[to_additive (attr := simp)]
theorem inv_le_self : f⁻¹ ≤ f ↔ f⁻¹ = f 
goal: f⁻¹ ≤ f ↔ f⁻¹ = f

full_name: Filter.neg_atTop
code: @[to_additive (attr := simp)]
lemma inv_atTop {G : Type*} [OrderedCommGroup G] : (atTop : Filter G)⁻¹ = atBot 
goal: -Filter.atTop = Filter.atBot

full_name: Filter.inv_atTop
code: @[to_additive (attr := simp)]
lemma inv_atTop {G : Type*} [OrderedCommGroup G] : (atTop : Filter G)⁻¹ = atBot 
goal: Filter.atTop⁻¹ = Filter.atBot

full_name: Filter.instAdd
code: /-- The filter `f * g` is generated by `{s * t | s ∈ f, t ∈ g}` in locale `Pointwise`. -/
@[to_additive "The filter `f + g` is generated by `{s + t | s ∈ f, t ∈ g}` in locale `Pointwise`."]
protected def instMul : Mul (Filter α) 
goal: Add (Filter α)

full_name: Filter.instMul
code: /-- The filter `f * g` is generated by `{s * t | s ∈ f, t ∈ g}` in locale `Pointwise`. -/
@[to_additive "The filter `f + g` is generated by `{s + t | s ∈ f, t ∈ g}` in locale `Pointwise`."]
protected def instMul : Mul (Filter α) 
goal: Mul (Filter α)

full_name: Filter.map₂_mul
code: @[to_additive (attr := simp)]
theorem map₂_mul : map₂ (· * ·) f g = f * g 
goal: Filter.map₂ (fun x x_1 => x * x_1) f g = f * g

full_name: Filter.map₂_add
code: @[to_additive (attr := simp)]
theorem map₂_mul : map₂ (· * ·) f g = f * g 
goal: Filter.map₂ (fun x x_1 => x + x_1) f g = f + g

full_name: Filter.mem_mul
code: @[to_additive]
theorem mem_mul : s ∈ f * g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ * t₂ ⊆ s 
goal: s ∈ f * g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ * t₂ ⊆ s

full_name: Filter.mem_add
code: @[to_additive]
theorem mem_mul : s ∈ f * g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ * t₂ ⊆ s 
goal: s ∈ f + g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ + t₂ ⊆ s

full_name: Filter.add_mem_add
code: @[to_additive]
theorem mul_mem_mul : s ∈ f → t ∈ g → s * t ∈ f * g 
goal: s ∈ f → t ∈ g → s + t ∈ f + g

full_name: Filter.mul_mem_mul
code: @[to_additive]
theorem mul_mem_mul : s ∈ f → t ∈ g → s * t ∈ f * g 
goal: s ∈ f → t ∈ g → s * t ∈ f * g

full_name: Filter.bot_add
code: @[to_additive (attr := simp)]
theorem bot_mul : ⊥ * g = ⊥ 
goal: ⊥ + g = ⊥

full_name: Filter.bot_mul
code: @[to_additive (attr := simp)]
theorem bot_mul : ⊥ * g = ⊥ 
goal: ⊥ * g = ⊥

full_name: Filter.add_bot
code: @[to_additive (attr := simp)]
theorem mul_bot : f * ⊥ = ⊥ 
goal: f + ⊥ = ⊥

full_name: Filter.mul_bot
code: @[to_additive (attr := simp)]
theorem mul_bot : f * ⊥ = ⊥ 
goal: f * ⊥ = ⊥

full_name: Filter.mul_eq_bot_iff
code: @[to_additive (attr := simp)]
theorem mul_eq_bot_iff : f * g = ⊥ ↔ f = ⊥ ∨ g = ⊥ 
goal: f * g = ⊥ ↔ f = ⊥ ∨ g = ⊥

full_name: Filter.add_eq_bot_iff
code: @[to_additive (attr := simp)]
theorem mul_eq_bot_iff : f * g = ⊥ ↔ f = ⊥ ∨ g = ⊥ 
goal: f + g = ⊥ ↔ f = ⊥ ∨ g = ⊥

full_name: Filter.add_neBot_iff
code: @[to_additive (attr := simp)] -- TODO: make this a scoped instance in the `Pointwise` namespace
lemma mul_neBot_iff : (f * g).NeBot ↔ f.NeBot ∧ g.NeBot 
goal: (f + g).NeBot ↔ f.NeBot ∧ g.NeBot

full_name: Filter.mul_neBot_iff
code: @[to_additive (attr := simp)] -- TODO: make this a scoped instance in the `Pointwise` namespace
lemma mul_neBot_iff : (f * g).NeBot ↔ f.NeBot ∧ g.NeBot 
goal: (f * g).NeBot ↔ f.NeBot ∧ g.NeBot

full_name: Filter.NeBot.mul
code: @[to_additive]
protected theorem NeBot.mul : NeBot f → NeBot g → NeBot (f * g) 
goal: f.NeBot → g.NeBot → (f * g).NeBot

full_name: Filter.NeBot.add
code: @[to_additive]
protected theorem NeBot.mul : NeBot f → NeBot g → NeBot (f * g) 
goal: f.NeBot → g.NeBot → (f + g).NeBot

full_name: Filter.NeBot.of_add_left
code: @[to_additive]
theorem NeBot.of_mul_left : (f * g).NeBot → f.NeBot 
goal: (f + g).NeBot → f.NeBot

full_name: Filter.NeBot.of_mul_left
code: @[to_additive]
theorem NeBot.of_mul_left : (f * g).NeBot → f.NeBot 
goal: (f * g).NeBot → f.NeBot

full_name: Filter.NeBot.of_add_right
code: @[to_additive]
theorem NeBot.of_mul_right : (f * g).NeBot → g.NeBot 
goal: (f + g).NeBot → g.NeBot

full_name: Filter.NeBot.of_mul_right
code: @[to_additive]
theorem NeBot.of_mul_right : (f * g).NeBot → g.NeBot 
goal: (f * g).NeBot → g.NeBot

full_name: Filter.mul.instNeBot
code: @[to_additive add.instNeBot]
protected lemma mul.instNeBot [NeBot f] [NeBot g] : NeBot (f * g) 
goal: (f * g).NeBot

full_name: Filter.add.instNeBot
code: @[to_additive add.instNeBot]
protected lemma mul.instNeBot [NeBot f] [NeBot g] : NeBot (f * g) 
goal: (f + g).NeBot

full_name: Filter.pure_mul
code: @[to_additive (attr := simp)]
theorem pure_mul : pure a * g = g.map (a * ·) 
goal: pure a * g = Filter.map (fun x => a * x) g

full_name: Filter.pure_add
code: @[to_additive (attr := simp)]
theorem pure_mul : pure a * g = g.map (a * ·) 
goal: pure a + g = Filter.map (fun x => a + x) g

full_name: Filter.mul_pure
code: @[to_additive (attr := simp)]
theorem mul_pure : f * pure b = f.map (· * b) 
goal: f * pure b = Filter.map (fun x => x * b) f

full_name: Filter.add_pure
code: @[to_additive (attr := simp)]
theorem mul_pure : f * pure b = f.map (· * b) 
goal: f + pure b = Filter.map (fun x => x + b) f

full_name: Filter.pure_add_pure
code: @[to_additive]
-- Porting note (#11119): removed `simp` attribute because `simpNF` says it can prove it.
theorem pure_mul_pure : (pure a : Filter α) * pure b = pure (a * b) 
goal: pure a + pure b = pure (a + b)

full_name: Filter.pure_mul_pure
code: @[to_additive]
-- Porting note (#11119): removed `simp` attribute because `simpNF` says it can prove it.
theorem pure_mul_pure : (pure a : Filter α) * pure b = pure (a * b) 
goal: pure a * pure b = pure (a * b)

full_name: Filter.le_add_iff
code: @[to_additive (attr := simp)]
theorem le_mul_iff : h ≤ f * g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t ∈ g → s * t ∈ h 
goal: h ≤ f + g ↔ ∀ ⦃s : Set α⦄, s ∈ f → ∀ ⦃t : Set α⦄, t ∈ g → s + t ∈ h

full_name: Filter.le_mul_iff
code: @[to_additive (attr := simp)]
theorem le_mul_iff : h ≤ f * g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t ∈ g → s * t ∈ h 
goal: h ≤ f * g ↔ ∀ ⦃s : Set α⦄, s ∈ f → ∀ ⦃t : Set α⦄, t ∈ g → s * t ∈ h

full_name: Filter.covariant_add
code: @[to_additive]
instance covariant_mul : CovariantClass (Filter α) (Filter α) (· * ·) (· ≤ ·) 
goal: CovariantClass (Filter α) (Filter α) (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

full_name: Filter.covariant_mul
code: @[to_additive]
instance covariant_mul : CovariantClass (Filter α) (Filter α) (· * ·) (· ≤ ·) 
goal: CovariantClass (Filter α) (Filter α) (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1

full_name: Filter.covariant_swap_add
code: @[to_additive]
instance covariant_swap_mul : CovariantClass (Filter α) (Filter α) (swap (· * ·)) (· ≤ ·) 
goal: CovariantClass (Filter α) (Filter α) (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

full_name: Filter.covariant_swap_mul
code: @[to_additive]
instance covariant_swap_mul : CovariantClass (Filter α) (Filter α) (swap (· * ·)) (· ≤ ·) 
goal: CovariantClass (Filter α) (Filter α) (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1

full_name: Filter.map_add
code: @[to_additive]
protected theorem map_mul [FunLike F α β] [MulHomClass F α β] (m : F) :
    (f₁ * f₂).map m = f₁.map m * f₂.map m 
goal: Filter.map (⇑m) (f₁ + f₂) = Filter.map (⇑m) f₁ + Filter.map (⇑m) f₂

full_name: Filter.map_mul
code: @[to_additive]
protected theorem map_mul [FunLike F α β] [MulHomClass F α β] (m : F) :
    (f₁ * f₂).map m = f₁.map m * f₂.map m 
goal: Filter.map (⇑m) (f₁ * f₂) = Filter.map (⇑m) f₁ * Filter.map (⇑m) f₂

full_name: Filter.pureMulHom
code: /-- `pure` operation as a `MulHom`. -/
@[to_additive "The singleton operation as an `AddHom`."]
def pureMulHom : α →ₙ* Filter α 
goal: α →ₙ* Filter α

full_name: Filter.pureAddHom
code: /-- `pure` operation as a `MulHom`. -/
@[to_additive "The singleton operation as an `AddHom`."]
def pureMulHom : α →ₙ* Filter α 
goal: AddHom α (Filter α)

full_name: Filter.coe_pureMulHom
code: @[to_additive (attr := simp)]
theorem coe_pureMulHom : (pureMulHom : α → Filter α) = pure 
goal: ⇑Filter.pureMulHom = pure

full_name: Filter.coe_pureAddHom
code: @[to_additive (attr := simp)]
theorem coe_pureMulHom : (pureMulHom : α → Filter α) = pure 
goal: ⇑Filter.pureAddHom = pure

full_name: Filter.pureMulHom_apply
code: @[to_additive (attr := simp)]
theorem pureMulHom_apply (a : α) : pureMulHom a = pure a 
goal: Filter.pureMulHom a = pure a

full_name: Filter.pureAddHom_apply
code: @[to_additive (attr := simp)]
theorem pureMulHom_apply (a : α) : pureMulHom a = pure a 
goal: Filter.pureAddHom a = pure a

full_name: Filter.instSub
code: /-- The filter `f / g` is generated by `{s / t | s ∈ f, t ∈ g}` in locale `Pointwise`. -/
@[to_additive "The filter `f - g` is generated by `{s - t | s ∈ f, t ∈ g}` in locale `Pointwise`."]
protected def instDiv : Div (Filter α) 
goal: Sub (Filter α)

full_name: Filter.instDiv
code: /-- The filter `f / g` is generated by `{s / t | s ∈ f, t ∈ g}` in locale `Pointwise`. -/
@[to_additive "The filter `f - g` is generated by `{s - t | s ∈ f, t ∈ g}` in locale `Pointwise`."]
protected def instDiv : Div (Filter α) 
goal: Div (Filter α)

full_name: Filter.map₂_sub
code: @[to_additive (attr := simp)]
theorem map₂_div : map₂ (· / ·) f g = f / g 
goal: Filter.map₂ (fun x x_1 => x - x_1) f g = f - g

full_name: Filter.map₂_div
code: @[to_additive (attr := simp)]
theorem map₂_div : map₂ (· / ·) f g = f / g 
goal: Filter.map₂ (fun x x_1 => x / x_1) f g = f / g

full_name: Filter.mem_div
code: @[to_additive]
theorem mem_div : s ∈ f / g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ / t₂ ⊆ s 
goal: s ∈ f / g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ / t₂ ⊆ s

full_name: Filter.mem_sub
code: @[to_additive]
theorem mem_div : s ∈ f / g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ / t₂ ⊆ s 
goal: s ∈ f - g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ - t₂ ⊆ s

full_name: Filter.sub_mem_sub
code: @[to_additive]
theorem div_mem_div : s ∈ f → t ∈ g → s / t ∈ f / g 
goal: s ∈ f → t ∈ g → s - t ∈ f - g

full_name: Filter.div_mem_div
code: @[to_additive]
theorem div_mem_div : s ∈ f → t ∈ g → s / t ∈ f / g 
goal: s ∈ f → t ∈ g → s / t ∈ f / g

full_name: Filter.bot_sub
code: @[to_additive (attr := simp)]
theorem bot_div : ⊥ / g = ⊥ 
goal: ⊥ - g = ⊥

full_name: Filter.bot_div
code: @[to_additive (attr := simp)]
theorem bot_div : ⊥ / g = ⊥ 
goal: ⊥ / g = ⊥

full_name: Filter.div_bot
code: @[to_additive (attr := simp)]
theorem div_bot : f / ⊥ = ⊥ 
goal: f / ⊥ = ⊥

full_name: Filter.sub_bot
code: @[to_additive (attr := simp)]
theorem div_bot : f / ⊥ = ⊥ 
goal: f - ⊥ = ⊥

full_name: Filter.div_eq_bot_iff
code: @[to_additive (attr := simp)]
theorem div_eq_bot_iff : f / g = ⊥ ↔ f = ⊥ ∨ g = ⊥ 
goal: f / g = ⊥ ↔ f = ⊥ ∨ g = ⊥

full_name: Filter.sub_eq_bot_iff
code: @[to_additive (attr := simp)]
theorem div_eq_bot_iff : f / g = ⊥ ↔ f = ⊥ ∨ g = ⊥ 
goal: f - g = ⊥ ↔ f = ⊥ ∨ g = ⊥

full_name: Filter.sub_neBot_iff
code: @[to_additive (attr := simp)]
theorem div_neBot_iff : (f / g).NeBot ↔ f.NeBot ∧ g.NeBot 
goal: (f - g).NeBot ↔ f.NeBot ∧ g.NeBot

full_name: Filter.div_neBot_iff
code: @[to_additive (attr := simp)]
theorem div_neBot_iff : (f / g).NeBot ↔ f.NeBot ∧ g.NeBot 
goal: (f / g).NeBot ↔ f.NeBot ∧ g.NeBot

full_name: Filter.NeBot.div
code: @[to_additive]
protected theorem NeBot.div : NeBot f → NeBot g → NeBot (f / g) 
goal: f.NeBot → g.NeBot → (f / g).NeBot

full_name: Filter.NeBot.sub
code: @[to_additive]
protected theorem NeBot.div : NeBot f → NeBot g → NeBot (f / g) 
goal: f.NeBot → g.NeBot → (f - g).NeBot

full_name: Filter.NeBot.of_sub_left
code: @[to_additive]
theorem NeBot.of_div_left : (f / g).NeBot → f.NeBot 
goal: (f - g).NeBot → f.NeBot

full_name: Filter.NeBot.of_div_left
code: @[to_additive]
theorem NeBot.of_div_left : (f / g).NeBot → f.NeBot 
goal: (f / g).NeBot → f.NeBot

full_name: Filter.NeBot.of_sub_right
code: @[to_additive]
theorem NeBot.of_div_right : (f / g).NeBot → g.NeBot 
goal: (f - g).NeBot → g.NeBot

full_name: Filter.NeBot.of_div_right
code: @[to_additive]
theorem NeBot.of_div_right : (f / g).NeBot → g.NeBot 
goal: (f / g).NeBot → g.NeBot

full_name: Filter.div.instNeBot
code: @[to_additive sub.instNeBot]
lemma div.instNeBot [NeBot f] [NeBot g] : NeBot (f / g) 
goal: (f / g).NeBot

full_name: Filter.sub.instNeBot
code: @[to_additive sub.instNeBot]
lemma div.instNeBot [NeBot f] [NeBot g] : NeBot (f / g) 
goal: (f - g).NeBot

full_name: Filter.pure_sub
code: @[to_additive (attr := simp)]
theorem pure_div : pure a / g = g.map (a / ·) 
goal: pure a - g = Filter.map (fun x => a - x) g

full_name: Filter.pure_div
code: @[to_additive (attr := simp)]
theorem pure_div : pure a / g = g.map (a / ·) 
goal: pure a / g = Filter.map (fun x => a / x) g

full_name: Filter.sub_pure
code: @[to_additive (attr := simp)]
theorem div_pure : f / pure b = f.map (· / b) 
goal: f - pure b = Filter.map (fun x => x - b) f

full_name: Filter.div_pure
code: @[to_additive (attr := simp)]
theorem div_pure : f / pure b = f.map (· / b) 
goal: f / pure b = Filter.map (fun x => x / b) f

full_name: Filter.pure_sub_pure
code: @[to_additive]
-- Porting note (#11119): removed `simp` attribute because `simpNF` says it can prove it.
theorem pure_div_pure : (pure a : Filter α) / pure b = pure (a / b) 
goal: pure a - pure b = pure (a - b)

full_name: Filter.pure_div_pure
code: @[to_additive]
-- Porting note (#11119): removed `simp` attribute because `simpNF` says it can prove it.
theorem pure_div_pure : (pure a : Filter α) / pure b = pure (a / b) 
goal: pure a / pure b = pure (a / b)

full_name: Filter.div_le_div
code: @[to_additive]
protected theorem div_le_div : f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ / g₁ ≤ f₂ / g₂ 
goal: f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ / g₁ ≤ f₂ / g₂

full_name: Filter.sub_le_sub
code: @[to_additive]
protected theorem div_le_div : f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ / g₁ ≤ f₂ / g₂ 
goal: f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ - g₁ ≤ f₂ - g₂

full_name: Filter.sub_le_sub_left
code: @[to_additive]
protected theorem div_le_div_left : g₁ ≤ g₂ → f / g₁ ≤ f / g₂ 
goal: g₁ ≤ g₂ → f - g₁ ≤ f - g₂

full_name: Filter.div_le_div_left
code: @[to_additive]
protected theorem div_le_div_left : g₁ ≤ g₂ → f / g₁ ≤ f / g₂ 
goal: g₁ ≤ g₂ → f / g₁ ≤ f / g₂

full_name: Filter.div_le_div_right
code: @[to_additive]
protected theorem div_le_div_right : f₁ ≤ f₂ → f₁ / g ≤ f₂ / g 
goal: f₁ ≤ f₂ → f₁ / g ≤ f₂ / g

full_name: Filter.sub_le_sub_right
code: @[to_additive]
protected theorem div_le_div_right : f₁ ≤ f₂ → f₁ / g ≤ f₂ / g 
goal: f₁ ≤ f₂ → f₁ - g ≤ f₂ - g

full_name: Filter.le_sub_iff
code: @[to_additive (attr := simp)]
protected theorem le_div_iff : h ≤ f / g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t ∈ g → s / t ∈ h 
goal: h ≤ f - g ↔ ∀ ⦃s : Set α⦄, s ∈ f → ∀ ⦃t : Set α⦄, t ∈ g → s - t ∈ h

full_name: Filter.le_div_iff
code: @[to_additive (attr := simp)]
protected theorem le_div_iff : h ≤ f / g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t ∈ g → s / t ∈ h 
goal: h ≤ f / g ↔ ∀ ⦃s : Set α⦄, s ∈ f → ∀ ⦃t : Set α⦄, t ∈ g → s / t ∈ h

full_name: Filter.covariant_div
code: @[to_additive]
instance covariant_div : CovariantClass (Filter α) (Filter α) (· / ·) (· ≤ ·) 
goal: CovariantClass (Filter α) (Filter α) (fun x x_1 => x / x_1) fun x x_1 => x ≤ x_1

full_name: Filter.covariant_sub
code: @[to_additive]
instance covariant_div : CovariantClass (Filter α) (Filter α) (· / ·) (· ≤ ·) 
goal: CovariantClass (Filter α) (Filter α) (fun x x_1 => x - x_1) fun x x_1 => x ≤ x_1

full_name: Filter.covariant_swap_div
code: @[to_additive]
instance covariant_swap_div : CovariantClass (Filter α) (Filter α) (swap (· / ·)) (· ≤ ·) 
goal: CovariantClass (Filter α) (Filter α) (Function.swap fun x x_1 => x / x_1) fun x x_1 => x ≤ x_1

full_name: Filter.covariant_swap_sub
code: @[to_additive]
instance covariant_swap_div : CovariantClass (Filter α) (Filter α) (swap (· / ·)) (· ≤ ·) 
goal: CovariantClass (Filter α) (Filter α) (Function.swap fun x x_1 => x - x_1) fun x x_1 => x ≤ x_1

full_name: Filter.instNSMul
code: /-- Repeated pointwise addition (not the same as pointwise repeated addition!) of a `Filter`. See
Note [pointwise nat action]. -/
protected def instNSMul [Zero α] [Add α] : SMul ℕ (Filter α) 
goal: SMul ℕ (Filter α)

full_name: Filter.instNPow
code: /-- Repeated pointwise multiplication (not the same as pointwise repeated multiplication!) of a
`Filter`. See Note [pointwise nat action]. -/
@[to_additive existing]
protected def instNPow [One α] [Mul α] : Pow (Filter α) ℕ 
goal: Pow (Filter α) ℕ

full_name: Filter.instZSMul
code: /-- Repeated pointwise addition/subtraction (not the same as pointwise repeated
addition/subtraction!) of a `Filter`. See Note [pointwise nat action]. -/
protected def instZSMul [Zero α] [Add α] [Neg α] : SMul ℤ (Filter α) 
goal: SMul ℤ (Filter α)

full_name: Filter.instZPow
code: /-- Repeated pointwise multiplication/division (not the same as pointwise repeated
multiplication/division!) of a `Filter`. See Note [pointwise nat action]. -/
@[to_additive existing]
protected def instZPow [One α] [Mul α] [Inv α] : Pow (Filter α) ℤ 
goal: Pow (Filter α) ℤ

full_name: Filter.addSemigroup
code: /-- `Filter α` is a `Semigroup` under pointwise operations if `α` is. -/
@[to_additive "`Filter α` is an `AddSemigroup` under pointwise operations if `α` is."]
protected def semigroup [Semigroup α] : Semigroup (Filter α) 
goal: AddSemigroup (Filter α)

full_name: Filter.semigroup
code: /-- `Filter α` is a `Semigroup` under pointwise operations if `α` is. -/
@[to_additive "`Filter α` is an `AddSemigroup` under pointwise operations if `α` is."]
protected def semigroup [Semigroup α] : Semigroup (Filter α) 
goal: Semigroup (Filter α)

full_name: Filter.commSemigroup
code: /-- `Filter α` is a `CommSemigroup` under pointwise operations if `α` is. -/
@[to_additive "`Filter α` is an `AddCommSemigroup` under pointwise operations if `α` is."]
protected def commSemigroup [CommSemigroup α] : CommSemigroup (Filter α) 
goal: CommSemigroup (Filter α)

full_name: Filter.addCommSemigroup
code: /-- `Filter α` is a `CommSemigroup` under pointwise operations if `α` is. -/
@[to_additive "`Filter α` is an `AddCommSemigroup` under pointwise operations if `α` is."]
protected def commSemigroup [CommSemigroup α] : CommSemigroup (Filter α) 
goal: AddCommSemigroup (Filter α)

full_name: Filter.addZeroClass
code: /-- `Filter α` is a `MulOneClass` under pointwise operations if `α` is. -/
@[to_additive "`Filter α` is an `AddZeroClass` under pointwise operations if `α` is."]
protected def mulOneClass : MulOneClass (Filter α) 
goal: AddZeroClass (Filter α)

full_name: Filter.mulOneClass
code: /-- `Filter α` is a `MulOneClass` under pointwise operations if `α` is. -/
@[to_additive "`Filter α` is an `AddZeroClass` under pointwise operations if `α` is."]
protected def mulOneClass : MulOneClass (Filter α) 
goal: MulOneClass (Filter α)

full_name: Filter.mapAddMonoidHom
code: /-- If `φ : α →* β` then `mapMonoidHom φ` is the monoid homomorphism
`Filter α →* Filter β` induced by `map φ`. -/
@[to_additive "If `φ : α →+ β` then `mapAddMonoidHom φ` is the monoid homomorphism
 `Filter α →+ Filter β` induced by `map φ`."]
def mapMonoidHom [MonoidHomClass F α β] (φ : F) : Filter α →* Filter β 
goal: Filter α →+ Filter β

full_name: Filter.mapMonoidHom
code: /-- If `φ : α →* β` then `mapMonoidHom φ` is the monoid homomorphism
`Filter α →* Filter β` induced by `map φ`. -/
@[to_additive "If `φ : α →+ β` then `mapAddMonoidHom φ` is the monoid homomorphism
 `Filter α →+ Filter β` induced by `map φ`."]
def mapMonoidHom [MonoidHomClass F α β] (φ : F) : Filter α →* Filter β 
goal: Filter α →* Filter β

full_name: Filter.comap_mul_comap_le
code: @[to_additive]
theorem comap_mul_comap_le [MulHomClass F α β] (m : F) {f g : Filter β} :
    f.comap m * g.comap m ≤ (f * g).comap m 
goal: Filter.comap (⇑m) f * Filter.comap (⇑m) g ≤ Filter.comap (⇑m) (f * g)

full_name: Filter.comap_add_comap_le
code: @[to_additive]
theorem comap_mul_comap_le [MulHomClass F α β] (m : F) {f g : Filter β} :
    f.comap m * g.comap m ≤ (f * g).comap m 
goal: Filter.comap (⇑m) f + Filter.comap (⇑m) g ≤ Filter.comap (⇑m) (f + g)

full_name: Filter.Tendsto.mul_mul
code: @[to_additive]
theorem Tendsto.mul_mul [MulHomClass F α β] (m : F) {f₁ g₁ : Filter α} {f₂ g₂ : Filter β} :
    Tendsto m f₁ f₂ → Tendsto m g₁ g₂ → Tendsto m (f₁ * g₁) (f₂ * g₂) 
goal: Filter.Tendsto (⇑m) f₁ f₂ → Filter.Tendsto (⇑m) g₁ g₂ → Filter.Tendsto (⇑m) (f₁ * g₁) (f₂ * g₂)

full_name: Filter.Tendsto.add_add
code: @[to_additive]
theorem Tendsto.mul_mul [MulHomClass F α β] (m : F) {f₁ g₁ : Filter α} {f₂ g₂ : Filter β} :
    Tendsto m f₁ f₂ → Tendsto m g₁ g₂ → Tendsto m (f₁ * g₁) (f₂ * g₂) 
goal: Filter.Tendsto (⇑m) f₁ f₂ → Filter.Tendsto (⇑m) g₁ g₂ → Filter.Tendsto (⇑m) (f₁ + g₁) (f₂ + g₂)

full_name: Filter.pureMonoidHom
code: /-- `pure` as a `MonoidHom`. -/
@[to_additive "`pure` as an `AddMonoidHom`."]
def pureMonoidHom : α →* Filter α 
goal: α →* Filter α

full_name: Filter.pureAddMonoidHom
code: /-- `pure` as a `MonoidHom`. -/
@[to_additive "`pure` as an `AddMonoidHom`."]
def pureMonoidHom : α →* Filter α 
goal: α →+ Filter α

full_name: Filter.coe_pureMonoidHom
code: @[to_additive (attr := simp)]
theorem coe_pureMonoidHom : (pureMonoidHom : α → Filter α) = pure 
goal: ⇑Filter.pureMonoidHom = pure

full_name: Filter.coe_pureAddMonoidHom
code: @[to_additive (attr := simp)]
theorem coe_pureMonoidHom : (pureMonoidHom : α → Filter α) = pure 
goal: ⇑Filter.pureAddMonoidHom = pure

full_name: Filter.pureMonoidHom_apply
code: @[to_additive (attr := simp)]
theorem pureMonoidHom_apply (a : α) : pureMonoidHom a = pure a 
goal: Filter.pureMonoidHom a = pure a

full_name: Filter.pureAddMonoidHom_apply
code: @[to_additive (attr := simp)]
theorem pureMonoidHom_apply (a : α) : pureMonoidHom a = pure a 
goal: Filter.pureAddMonoidHom a = pure a

full_name: Filter.addMonoid
code: /-- `Filter α` is a `Monoid` under pointwise operations if `α` is. -/
@[to_additive "`Filter α` is an `AddMonoid` under pointwise operations if `α` is."]
protected def monoid : Monoid (Filter α) 
goal: AddMonoid (Filter α)

full_name: Filter.monoid
code: /-- `Filter α` is a `Monoid` under pointwise operations if `α` is. -/
@[to_additive "`Filter α` is an `AddMonoid` under pointwise operations if `α` is."]
protected def monoid : Monoid (Filter α) 
goal: Monoid (Filter α)

full_name: Filter.pow_mem_pow
code: @[to_additive]
theorem pow_mem_pow (hs : s ∈ f) : ∀ n : ℕ, s ^ n ∈ f ^ n
  
goal: s ^ n ∈ f ^ n

full_name: Filter.nsmul_mem_nsmul
code: @[to_additive]
theorem pow_mem_pow (hs : s ∈ f) : ∀ n : ℕ, s ^ n ∈ f ^ n
  
goal: n • s ∈ n • f

full_name: Filter.bot_pow
code: @[to_additive (attr := simp) nsmul_bot]
theorem bot_pow {n : ℕ} (hn : n ≠ 0) : (⊥ : Filter α) ^ n = ⊥ 
goal: ⊥ ^ n = ⊥

full_name: Filter.nsmul_bot
code: @[to_additive (attr := simp) nsmul_bot]
theorem bot_pow {n : ℕ} (hn : n ≠ 0) : (⊥ : Filter α) ^ n = ⊥ 
goal: n • ⊥ = ⊥

full_name: Filter.mul_top_of_one_le
code: @[to_additive]
theorem mul_top_of_one_le (hf : 1 ≤ f) : f * ⊤ = ⊤ 
goal: f * ⊤ = ⊤

full_name: Filter.add_top_of_nonneg
code: @[to_additive]
theorem mul_top_of_one_le (hf : 1 ≤ f) : f * ⊤ = ⊤ 
goal: f + ⊤ = ⊤

full_name: Filter.top_mul_of_one_le
code: @[to_additive]
theorem top_mul_of_one_le (hf : 1 ≤ f) : ⊤ * f = ⊤ 
goal: ⊤ * f = ⊤

full_name: Filter.top_add_of_nonneg
code: @[to_additive]
theorem top_mul_of_one_le (hf : 1 ≤ f) : ⊤ * f = ⊤ 
goal: ⊤ + f = ⊤

full_name: Filter.top_add_top
code: @[to_additive (attr := simp)]
theorem top_mul_top : (⊤ : Filter α) * ⊤ = ⊤ 
goal: ⊤ + ⊤ = ⊤

full_name: Filter.top_mul_top
code: @[to_additive (attr := simp)]
theorem top_mul_top : (⊤ : Filter α) * ⊤ = ⊤ 
goal: ⊤ * ⊤ = ⊤

full_name: Filter.top_pow
code: @[to_additive nsmul_top]
theorem top_pow : ∀ {n : ℕ}, n ≠ 0 → (⊤ : Filter α) ^ n = ⊤
  
goal: n ≠ 0 → ⊤ ^ n = ⊤

full_name: Filter.nsmul_top
code: @[to_additive nsmul_top]
theorem top_pow : ∀ {n : ℕ}, n ≠ 0 → (⊤ : Filter α) ^ n = ⊤
  
goal: n ≠ 0 → n • ⊤ = ⊤

full_name: IsAddUnit.filter
code: @[to_additive]
protected theorem _root_.IsUnit.filter : IsUnit a → IsUnit (pure a : Filter α) 
goal: IsAddUnit a → IsAddUnit (pure a)

full_name: IsUnit.filter
code: @[to_additive]
protected theorem _root_.IsUnit.filter : IsUnit a → IsUnit (pure a : Filter α) 
goal: IsUnit a → IsUnit (pure a)

full_name: Filter.commMonoid
code: /-- `Filter α` is a `CommMonoid` under pointwise operations if `α` is. -/
@[to_additive "`Filter α` is an `AddCommMonoid` under pointwise operations if `α` is."]
protected def commMonoid [CommMonoid α] : CommMonoid (Filter α) 
goal: CommMonoid (Filter α)

full_name: Filter.addCommMonoid
code: /-- `Filter α` is a `CommMonoid` under pointwise operations if `α` is. -/
@[to_additive "`Filter α` is an `AddCommMonoid` under pointwise operations if `α` is."]
protected def commMonoid [CommMonoid α] : CommMonoid (Filter α) 
goal: AddCommMonoid (Filter α)

full_name: Filter.mul_eq_one_iff
code: @[to_additive]
protected theorem mul_eq_one_iff : f * g = 1 ↔ ∃ a b, f = pure a ∧ g = pure b ∧ a * b = 1 
goal: f * g = 1 ↔ ∃ a b, f = pure a ∧ g = pure b ∧ a * b = 1

full_name: Filter.add_eq_zero_iff
code: @[to_additive]
protected theorem mul_eq_one_iff : f * g = 1 ↔ ∃ a b, f = pure a ∧ g = pure b ∧ a * b = 1 
goal: f + g = 0 ↔ ∃ a b, f = pure a ∧ g = pure b ∧ a + b = 0

full_name: Filter.subtractionMonoid
code: /-- `Filter α` is a division monoid under pointwise operations if `α` is. -/
@[to_additive subtractionMonoid "`Filter α` is a subtraction monoid under pointwise operations if
 `α` is."]
-- Porting note: `to_additive` guessed `divisionAddMonoid`
protected def divisionMonoid : DivisionMonoid (Filter α) 
goal: SubtractionMonoid (Filter α)

full_name: Filter.divisionMonoid
code: /-- `Filter α` is a division monoid under pointwise operations if `α` is. -/
@[to_additive subtractionMonoid "`Filter α` is a subtraction monoid under pointwise operations if
 `α` is."]
-- Porting note: `to_additive` guessed `divisionAddMonoid`
protected def divisionMonoid : DivisionMonoid (Filter α) 
goal: DivisionMonoid (Filter α)

full_name: Filter.isUnit_iff
code: @[to_additive]
theorem isUnit_iff : IsUnit f ↔ ∃ a, f = pure a ∧ IsUnit a 
goal: IsUnit f ↔ ∃ a, f = pure a ∧ IsUnit a

full_name: Filter.isAddUnit_iff
code: @[to_additive]
theorem isUnit_iff : IsUnit f ↔ ∃ a, f = pure a ∧ IsUnit a 
goal: IsAddUnit f ↔ ∃ a, f = pure a ∧ IsAddUnit a

full_name: Filter.divisionCommMonoid
code: /-- `Filter α` is a commutative division monoid under pointwise operations if `α` is. -/
@[to_additive subtractionCommMonoid
      "`Filter α` is a commutative subtraction monoid under pointwise operations if `α` is."]
protected def divisionCommMonoid [DivisionCommMonoid α] : DivisionCommMonoid (Filter α) 
goal: DivisionCommMonoid (Filter α)

full_name: Filter.subtractionCommMonoid
code: /-- `Filter α` is a commutative division monoid under pointwise operations if `α` is. -/
@[to_additive subtractionCommMonoid
      "`Filter α` is a commutative subtraction monoid under pointwise operations if `α` is."]
protected def divisionCommMonoid [DivisionCommMonoid α] : DivisionCommMonoid (Filter α) 
goal: SubtractionCommMonoid (Filter α)

full_name: Filter.instDistribNeg
code: /-- `Filter α` has distributive negation if `α` has. -/
protected def instDistribNeg [Mul α] [HasDistribNeg α] : HasDistribNeg (Filter α) 
goal: HasDistribNeg (Filter α)

full_name: Filter.mul_add_subset
code: theorem mul_add_subset : f * (g + h) ≤ f * g + f * h 
goal: f * (g + h) ≤ f * g + f * h

full_name: Filter.add_mul_subset
code: theorem add_mul_subset : (f + g) * h ≤ f * h + g * h 
goal: (f + g) * h ≤ f * h + g * h

full_name: Filter.NeBot.mul_zero_nonneg
code: theorem NeBot.mul_zero_nonneg (hf : f.NeBot) : 0 ≤ f * 0 
goal: 0 ≤ f * 0

full_name: Filter.NeBot.zero_mul_nonneg
code: theorem NeBot.zero_mul_nonneg (hg : g.NeBot) : 0 ≤ 0 * g 
goal: 0 ≤ 0 * g

full_name: Filter.nonneg_sub_iff
code: @[to_additive (attr := simp 1100)]
protected theorem one_le_div_iff : 1 ≤ f / g ↔ ¬Disjoint f g 
goal: 0 ≤ f - g ↔ ¬Disjoint f g

full_name: Filter.one_le_div_iff
code: @[to_additive (attr := simp 1100)]
protected theorem one_le_div_iff : 1 ≤ f / g ↔ ¬Disjoint f g 
goal: 1 ≤ f / g ↔ ¬Disjoint f g

full_name: Filter.not_one_le_div_iff
code: @[to_additive]
theorem not_one_le_div_iff : ¬1 ≤ f / g ↔ Disjoint f g 
goal: ¬1 ≤ f / g ↔ Disjoint f g

full_name: Filter.not_nonneg_sub_iff
code: @[to_additive]
theorem not_one_le_div_iff : ¬1 ≤ f / g ↔ Disjoint f g 
goal: ¬0 ≤ f - g ↔ Disjoint f g

full_name: Filter.NeBot.nonneg_sub
code: @[to_additive]
theorem NeBot.one_le_div (h : f.NeBot) : 1 ≤ f / f 
goal: 0 ≤ f - f

full_name: Filter.NeBot.one_le_div
code: @[to_additive]
theorem NeBot.one_le_div (h : f.NeBot) : 1 ≤ f / f 
goal: 1 ≤ f / f

full_name: Filter.isAddUnit_pure
code: @[to_additive]
theorem isUnit_pure (a : α) : IsUnit (pure a : Filter α) 
goal: IsAddUnit (pure a)

full_name: Filter.isUnit_pure
code: @[to_additive]
theorem isUnit_pure (a : α) : IsUnit (pure a : Filter α) 
goal: IsUnit (pure a)

full_name: Filter.isUnit_iff_singleton
code: @[simp]
theorem isUnit_iff_singleton : IsUnit f ↔ ∃ a, f = pure a 
goal: IsUnit f ↔ ∃ a, f = pure a

full_name: Filter.map_neg'
code: @[to_additive]
theorem map_inv' : f⁻¹.map m = (f.map m)⁻¹ 
goal: Filter.map (⇑m) (-f) = -Filter.map (⇑m) f

full_name: Filter.map_inv'
code: @[to_additive]
theorem map_inv' : f⁻¹.map m = (f.map m)⁻¹ 
goal: Filter.map (⇑m) f⁻¹ = (Filter.map (⇑m) f)⁻¹

full_name: Filter.Tendsto.neg_neg
code: @[to_additive]
protected theorem Tendsto.inv_inv : Tendsto m f₁ f₂ → Tendsto m f₁⁻¹ f₂⁻¹ 
goal: Filter.Tendsto (⇑m) f₁ f₂ → Filter.Tendsto (⇑m) (-f₁) (-f₂)

full_name: Filter.Tendsto.inv_inv
code: @[to_additive]
protected theorem Tendsto.inv_inv : Tendsto m f₁ f₂ → Tendsto m f₁⁻¹ f₂⁻¹ 
goal: Filter.Tendsto (⇑m) f₁ f₂ → Filter.Tendsto (⇑m) f₁⁻¹ f₂⁻¹

full_name: Filter.map_sub
code: @[to_additive]
protected theorem map_div : (f / g).map m = f.map m / g.map m 
goal: Filter.map (⇑m) (f - g) = Filter.map (⇑m) f - Filter.map (⇑m) g

full_name: Filter.map_div
code: @[to_additive]
protected theorem map_div : (f / g).map m = f.map m / g.map m 
goal: Filter.map (⇑m) (f / g) = Filter.map (⇑m) f / Filter.map (⇑m) g

full_name: Filter.Tendsto.div_div
code: @[to_additive]
protected theorem Tendsto.div_div (hf : Tendsto m f₁ f₂) (hg : Tendsto m g₁ g₂) :
    Tendsto m (f₁ / g₁) (f₂ / g₂) 
goal: Filter.Tendsto (⇑m) (f₁ / g₁) (f₂ / g₂)

full_name: Filter.Tendsto.sub_sub
code: @[to_additive]
protected theorem Tendsto.div_div (hf : Tendsto m f₁ f₂) (hg : Tendsto m g₁ g₂) :
    Tendsto m (f₁ / g₁) (f₂ / g₂) 
goal: Filter.Tendsto (⇑m) (f₁ - g₁) (f₂ - g₂)

full_name: Filter.NeBot.div_zero_nonneg
code: theorem NeBot.div_zero_nonneg (hf : f.NeBot) : 0 ≤ f / 0 
goal: 0 ≤ f / 0

full_name: Filter.NeBot.zero_div_nonneg
code: theorem NeBot.zero_div_nonneg (hg : g.NeBot) : 0 ≤ 0 / g 
goal: 0 ≤ 0 / g

full_name: Filter.instVAdd
code: /-- The filter `f • g` is generated by `{s • t | s ∈ f, t ∈ g}` in locale `Pointwise`. -/
@[to_additive "The filter `f +ᵥ g` is generated by `{s +ᵥ t | s ∈ f, t ∈ g}` in locale
 `Pointwise`."]
protected def instSMul : SMul (Filter α) (Filter β) 
goal: VAdd (Filter α) (Filter β)

full_name: Filter.instSMul
code: /-- The filter `f • g` is generated by `{s • t | s ∈ f, t ∈ g}` in locale `Pointwise`. -/
@[to_additive "The filter `f +ᵥ g` is generated by `{s +ᵥ t | s ∈ f, t ∈ g}` in locale
 `Pointwise`."]
protected def instSMul : SMul (Filter α) (Filter β) 
goal: SMul (Filter α) (Filter β)

full_name: Filter.map₂_smul
code: @[to_additive (attr := simp)]
theorem map₂_smul : map₂ (· • ·) f g = f • g 
goal: Filter.map₂ (fun x x_1 => x • x_1) f g = f • g

full_name: Filter.map₂_vadd
code: @[to_additive (attr := simp)]
theorem map₂_smul : map₂ (· • ·) f g = f • g 
goal: Filter.map₂ (fun x x_1 => x +ᵥ x_1) f g = f +ᵥ g

full_name: Filter.mem_smul
code: @[to_additive]
theorem mem_smul : t ∈ f • g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ • t₂ ⊆ t 
goal: t ∈ f • g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ • t₂ ⊆ t

full_name: Filter.mem_vadd
code: @[to_additive]
theorem mem_smul : t ∈ f • g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ • t₂ ⊆ t 
goal: t ∈ f +ᵥ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ +ᵥ t₂ ⊆ t

full_name: Filter.vadd_mem_vadd
code: @[to_additive]
theorem smul_mem_smul : s ∈ f → t ∈ g → s • t ∈ f • g 
goal: s ∈ f → t ∈ g → s +ᵥ t ∈ f +ᵥ g

full_name: Filter.smul_mem_smul
code: @[to_additive]
theorem smul_mem_smul : s ∈ f → t ∈ g → s • t ∈ f • g 
goal: s ∈ f → t ∈ g → s • t ∈ f • g

full_name: Filter.bot_vadd
code: @[to_additive (attr := simp)]
theorem bot_smul : (⊥ : Filter α) • g = ⊥ 
goal: ⊥ +ᵥ g = ⊥

full_name: Filter.bot_smul
code: @[to_additive (attr := simp)]
theorem bot_smul : (⊥ : Filter α) • g = ⊥ 
goal: ⊥ • g = ⊥

full_name: Filter.vadd_bot
code: @[to_additive (attr := simp)]
theorem smul_bot : f • (⊥ : Filter β) = ⊥ 
goal: f +ᵥ ⊥ = ⊥

full_name: Filter.smul_bot
code: @[to_additive (attr := simp)]
theorem smul_bot : f • (⊥ : Filter β) = ⊥ 
goal: f • ⊥ = ⊥

full_name: Filter.vadd_eq_bot_iff
code: @[to_additive (attr := simp)]
theorem smul_eq_bot_iff : f • g = ⊥ ↔ f = ⊥ ∨ g = ⊥ 
goal: f +ᵥ g = ⊥ ↔ f = ⊥ ∨ g = ⊥

full_name: Filter.smul_eq_bot_iff
code: @[to_additive (attr := simp)]
theorem smul_eq_bot_iff : f • g = ⊥ ↔ f = ⊥ ∨ g = ⊥ 
goal: f • g = ⊥ ↔ f = ⊥ ∨ g = ⊥

full_name: Filter.smul_neBot_iff
code: @[to_additive (attr := simp)]
theorem smul_neBot_iff : (f • g).NeBot ↔ f.NeBot ∧ g.NeBot 
goal: (f • g).NeBot ↔ f.NeBot ∧ g.NeBot

full_name: Filter.vadd_neBot_iff
code: @[to_additive (attr := simp)]
theorem smul_neBot_iff : (f • g).NeBot ↔ f.NeBot ∧ g.NeBot 
goal: (f +ᵥ g).NeBot ↔ f.NeBot ∧ g.NeBot

full_name: Filter.NeBot.vadd
code: @[to_additive]
protected theorem NeBot.smul : NeBot f → NeBot g → NeBot (f • g) 
goal: f.NeBot → g.NeBot → (f +ᵥ g).NeBot

full_name: Filter.NeBot.smul
code: @[to_additive]
protected theorem NeBot.smul : NeBot f → NeBot g → NeBot (f • g) 
goal: f.NeBot → g.NeBot → (f • g).NeBot

full_name: Filter.NeBot.of_smul_left
code: @[to_additive]
theorem NeBot.of_smul_left : (f • g).NeBot → f.NeBot 
goal: (f • g).NeBot → f.NeBot

full_name: Filter.NeBot.of_vadd_left
code: @[to_additive]
theorem NeBot.of_smul_left : (f • g).NeBot → f.NeBot 
goal: (f +ᵥ g).NeBot → f.NeBot

full_name: Filter.NeBot.of_smul_right
code: @[to_additive]
theorem NeBot.of_smul_right : (f • g).NeBot → g.NeBot 
goal: (f • g).NeBot → g.NeBot

full_name: Filter.NeBot.of_vadd_right
code: @[to_additive]
theorem NeBot.of_smul_right : (f • g).NeBot → g.NeBot 
goal: (f +ᵥ g).NeBot → g.NeBot

full_name: Filter.vadd.instNeBot
code: @[to_additive vadd.instNeBot]
lemma smul.instNeBot [NeBot f] [NeBot g] : NeBot (f • g) 
goal: (f +ᵥ g).NeBot

full_name: Filter.smul.instNeBot
code: @[to_additive vadd.instNeBot]
lemma smul.instNeBot [NeBot f] [NeBot g] : NeBot (f • g) 
goal: (f • g).NeBot

full_name: Filter.pure_vadd
code: @[to_additive (attr := simp)]
theorem pure_smul : (pure a : Filter α) • g = g.map (a • ·) 
goal: pure a +ᵥ g = Filter.map (fun x => a +ᵥ x) g

full_name: Filter.pure_smul
code: @[to_additive (attr := simp)]
theorem pure_smul : (pure a : Filter α) • g = g.map (a • ·) 
goal: pure a • g = Filter.map (fun x => a • x) g

full_name: Filter.vadd_pure
code: @[to_additive (attr := simp)]
theorem smul_pure : f • pure b = f.map (· • b) 
goal: f +ᵥ pure b = Filter.map (fun x => x +ᵥ b) f

full_name: Filter.smul_pure
code: @[to_additive (attr := simp)]
theorem smul_pure : f • pure b = f.map (· • b) 
goal: f • pure b = Filter.map (fun x => x • b) f

full_name: Filter.pure_vadd_pure
code: @[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) 
goal: pure a +ᵥ pure b = pure (a +ᵥ b)

full_name: Filter.pure_smul_pure
code: @[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) 
goal: pure a • pure b = pure (a • b)

full_name: Filter.vadd_le_vadd
code: @[to_additive]
theorem smul_le_smul : f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ • g₁ ≤ f₂ • g₂ 
goal: f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ +ᵥ g₁ ≤ f₂ +ᵥ g₂

full_name: Filter.smul_le_smul
code: @[to_additive]
theorem smul_le_smul : f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ • g₁ ≤ f₂ • g₂ 
goal: f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ • g₁ ≤ f₂ • g₂

full_name: Filter.smul_le_smul_left
code: @[to_additive]
theorem smul_le_smul_left : g₁ ≤ g₂ → f • g₁ ≤ f • g₂ 
goal: g₁ ≤ g₂ → f • g₁ ≤ f • g₂

full_name: Filter.vadd_le_vadd_left
code: @[to_additive]
theorem smul_le_smul_left : g₁ ≤ g₂ → f • g₁ ≤ f • g₂ 
goal: g₁ ≤ g₂ → f +ᵥ g₁ ≤ f +ᵥ g₂

full_name: Filter.smul_le_smul_right
code: @[to_additive]
theorem smul_le_smul_right : f₁ ≤ f₂ → f₁ • g ≤ f₂ • g 
goal: f₁ ≤ f₂ → f₁ • g ≤ f₂ • g

full_name: Filter.vadd_le_vadd_right
code: @[to_additive]
theorem smul_le_smul_right : f₁ ≤ f₂ → f₁ • g ≤ f₂ • g 
goal: f₁ ≤ f₂ → f₁ +ᵥ g ≤ f₂ +ᵥ g

full_name: Filter.le_vadd_iff
code: @[to_additive (attr := simp)]
theorem le_smul_iff : h ≤ f • g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t ∈ g → s • t ∈ h 
goal: h ≤ f +ᵥ g ↔ ∀ ⦃s : Set α⦄, s ∈ f → ∀ ⦃t : Set β⦄, t ∈ g → s +ᵥ t ∈ h

full_name: Filter.le_smul_iff
code: @[to_additive (attr := simp)]
theorem le_smul_iff : h ≤ f • g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t ∈ g → s • t ∈ h 
goal: h ≤ f • g ↔ ∀ ⦃s : Set α⦄, s ∈ f → ∀ ⦃t : Set β⦄, t ∈ g → s • t ∈ h

full_name: Filter.covariant_smul
code: @[to_additive]
instance covariant_smul : CovariantClass (Filter α) (Filter β) (· • ·) (· ≤ ·) 
goal: CovariantClass (Filter α) (Filter β) (fun x x_1 => x • x_1) fun x x_1 => x ≤ x_1

full_name: Filter.covariant_vadd
code: @[to_additive]
instance covariant_smul : CovariantClass (Filter α) (Filter β) (· • ·) (· ≤ ·) 
goal: CovariantClass (Filter α) (Filter β) (fun x x_1 => x +ᵥ x_1) fun x x_1 => x ≤ x_1

full_name: Filter.instVSub
code: /-- The filter `f -ᵥ g` is generated by `{s -ᵥ t | s ∈ f, t ∈ g}` in locale `Pointwise`. -/
protected def instVSub : VSub (Filter α) (Filter β) 
goal: VSub (Filter α) (Filter β)

full_name: Filter.map₂_vsub
code: @[simp]
theorem map₂_vsub : map₂ (· -ᵥ ·) f g = f -ᵥ g 
goal: Filter.map₂ (fun x x_1 => x -ᵥ x_1) f g = f -ᵥ g

full_name: Filter.mem_vsub
code: theorem mem_vsub {s : Set α} : s ∈ f -ᵥ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ -ᵥ t₂ ⊆ s 
goal: s ∈ f -ᵥ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ -ᵥ t₂ ⊆ s

full_name: Filter.vsub_mem_vsub
code: theorem vsub_mem_vsub : s ∈ f → t ∈ g → s -ᵥ t ∈ f -ᵥ g 
goal: s ∈ f → t ∈ g → s -ᵥ t ∈ f -ᵥ g

full_name: Filter.bot_vsub
code: @[simp]
theorem bot_vsub : (⊥ : Filter β) -ᵥ g = ⊥ 
goal: ⊥ -ᵥ g = ⊥

full_name: Filter.vsub_bot
code: @[simp]
theorem vsub_bot : f -ᵥ (⊥ : Filter β) = ⊥ 
goal: f -ᵥ ⊥ = ⊥

full_name: Filter.vsub_eq_bot_iff
code: @[simp]
theorem vsub_eq_bot_iff : f -ᵥ g = ⊥ ↔ f = ⊥ ∨ g = ⊥ 
goal: f -ᵥ g = ⊥ ↔ f = ⊥ ∨ g = ⊥

full_name: Filter.vsub_neBot_iff
code: @[simp]
theorem vsub_neBot_iff : (f -ᵥ g : Filter α).NeBot ↔ f.NeBot ∧ g.NeBot 
goal: (f -ᵥ g).NeBot ↔ f.NeBot ∧ g.NeBot

full_name: Filter.NeBot.vsub
code: protected theorem NeBot.vsub : NeBot f → NeBot g → NeBot (f -ᵥ g) 
goal: f.NeBot → g.NeBot → (f -ᵥ g).NeBot

full_name: Filter.NeBot.of_vsub_left
code: theorem NeBot.of_vsub_left : (f -ᵥ g : Filter α).NeBot → f.NeBot 
goal: (f -ᵥ g).NeBot → f.NeBot

full_name: Filter.NeBot.of_vsub_right
code: theorem NeBot.of_vsub_right : (f -ᵥ g : Filter α).NeBot → g.NeBot 
goal: (f -ᵥ g).NeBot → g.NeBot

full_name: Filter.vsub.instNeBot
code: lemma vsub.instNeBot [NeBot f] [NeBot g] : NeBot (f -ᵥ g) 
goal: (f -ᵥ g).NeBot

full_name: Filter.pure_vsub
code: @[simp]
theorem pure_vsub : (pure a : Filter β) -ᵥ g = g.map (a -ᵥ ·) 
goal: pure a -ᵥ g = Filter.map (fun x => a -ᵥ x) g

full_name: Filter.vsub_pure
code: @[simp]
theorem vsub_pure : f -ᵥ pure b = f.map (· -ᵥ b) 
goal: f -ᵥ pure b = Filter.map (fun x => x -ᵥ b) f

full_name: Filter.pure_vsub_pure
code: theorem pure_vsub_pure : (pure a : Filter β) -ᵥ pure b = (pure (a -ᵥ b) : Filter α) 
goal: pure a -ᵥ pure b = pure (a -ᵥ b)

full_name: Filter.vsub_le_vsub
code: theorem vsub_le_vsub : f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ -ᵥ g₁ ≤ f₂ -ᵥ g₂ 
goal: f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ -ᵥ g₁ ≤ f₂ -ᵥ g₂

full_name: Filter.vsub_le_vsub_left
code: theorem vsub_le_vsub_left : g₁ ≤ g₂ → f -ᵥ g₁ ≤ f -ᵥ g₂ 
goal: g₁ ≤ g₂ → f -ᵥ g₁ ≤ f -ᵥ g₂

full_name: Filter.vsub_le_vsub_right
code: theorem vsub_le_vsub_right : f₁ ≤ f₂ → f₁ -ᵥ g ≤ f₂ -ᵥ g 
goal: f₁ ≤ f₂ → f₁ -ᵥ g ≤ f₂ -ᵥ g

full_name: Filter.le_vsub_iff
code: @[simp]
theorem le_vsub_iff : h ≤ f -ᵥ g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t ∈ g → s -ᵥ t ∈ h 
goal: h ≤ f -ᵥ g ↔ ∀ ⦃s : Set β⦄, s ∈ f → ∀ ⦃t : Set β⦄, t ∈ g → s -ᵥ t ∈ h

full_name: Filter.instSMulFilter
code: /-- `a • f` is the map of `f` under `a •` in locale `Pointwise`. -/
@[to_additive "`a +ᵥ f` is the map of `f` under `a +ᵥ` in locale `Pointwise`."]
protected def instSMulFilter : SMul α (Filter β) 
goal: SMul α (Filter β)

full_name: Filter.instVAddFilter
code: /-- `a • f` is the map of `f` under `a •` in locale `Pointwise`. -/
@[to_additive "`a +ᵥ f` is the map of `f` under `a +ᵥ` in locale `Pointwise`."]
protected def instSMulFilter : SMul α (Filter β) 
goal: VAdd α (Filter β)

full_name: Filter.map_smul
code: @[to_additive (attr := simp)]
protected theorem map_smul : map (fun b => a • b) f = a • f 
goal: Filter.map (fun b => a • b) f = a • f

full_name: Filter.map_vadd
code: @[to_additive (attr := simp)]
protected theorem map_smul : map (fun b => a • b) f = a • f 
goal: Filter.map (fun b => a +ᵥ b) f = a +ᵥ f

full_name: Filter.mem_vadd_filter
code: @[to_additive]
theorem mem_smul_filter : s ∈ a • f ↔ (a • ·) ⁻¹' s ∈ f 
goal: s ∈ a +ᵥ f ↔ (fun x => a +ᵥ x) ⁻¹' s ∈ f

full_name: Filter.mem_smul_filter
code: @[to_additive]
theorem mem_smul_filter : s ∈ a • f ↔ (a • ·) ⁻¹' s ∈ f 
goal: s ∈ a • f ↔ (fun x => a • x) ⁻¹' s ∈ f

full_name: Filter.smul_set_mem_smul_filter
code: @[to_additive]
theorem smul_set_mem_smul_filter : s ∈ f → a • s ∈ a • f 
goal: s ∈ f → a • s ∈ a • f

full_name: Filter.vadd_set_mem_vadd_filter
code: @[to_additive]
theorem smul_set_mem_smul_filter : s ∈ f → a • s ∈ a • f 
goal: s ∈ f → a +ᵥ s ∈ a +ᵥ f

full_name: Filter.smul_filter_bot
code: @[to_additive (attr := simp)]
theorem smul_filter_bot : a • (⊥ : Filter β) = ⊥ 
goal: a • ⊥ = ⊥

full_name: Filter.vadd_filter_bot
code: @[to_additive (attr := simp)]
theorem smul_filter_bot : a • (⊥ : Filter β) = ⊥ 
goal: a +ᵥ ⊥ = ⊥

full_name: Filter.smul_filter_eq_bot_iff
code: @[to_additive (attr := simp)]
theorem smul_filter_eq_bot_iff : a • f = ⊥ ↔ f = ⊥ 
goal: a • f = ⊥ ↔ f = ⊥

full_name: Filter.vadd_filter_eq_bot_iff
code: @[to_additive (attr := simp)]
theorem smul_filter_eq_bot_iff : a • f = ⊥ ↔ f = ⊥ 
goal: a +ᵥ f = ⊥ ↔ f = ⊥

full_name: Filter.smul_filter_neBot_iff
code: @[to_additive (attr := simp)]
theorem smul_filter_neBot_iff : (a • f).NeBot ↔ f.NeBot 
goal: (a • f).NeBot ↔ f.NeBot

full_name: Filter.vadd_filter_neBot_iff
code: @[to_additive (attr := simp)]
theorem smul_filter_neBot_iff : (a • f).NeBot ↔ f.NeBot 
goal: (a +ᵥ f).NeBot ↔ f.NeBot

full_name: Filter.NeBot.vadd_filter
code: @[to_additive]
theorem NeBot.smul_filter : f.NeBot → (a • f).NeBot 
goal: f.NeBot → (a +ᵥ f).NeBot

full_name: Filter.NeBot.smul_filter
code: @[to_additive]
theorem NeBot.smul_filter : f.NeBot → (a • f).NeBot 
goal: f.NeBot → (a • f).NeBot

full_name: Filter.NeBot.of_smul_filter
code: @[to_additive]
theorem NeBot.of_smul_filter : (a • f).NeBot → f.NeBot 
goal: (a • f).NeBot → f.NeBot

full_name: Filter.NeBot.of_vadd_filter
code: @[to_additive]
theorem NeBot.of_smul_filter : (a • f).NeBot → f.NeBot 
goal: (a +ᵥ f).NeBot → f.NeBot

full_name: Filter.vadd_filter.instNeBot
code: @[to_additive vadd_filter.instNeBot]
lemma smul_filter.instNeBot [NeBot f] : NeBot (a • f) 
goal: (a +ᵥ f).NeBot

full_name: Filter.smul_filter.instNeBot
code: @[to_additive vadd_filter.instNeBot]
lemma smul_filter.instNeBot [NeBot f] : NeBot (a • f) 
goal: (a • f).NeBot

full_name: Filter.smul_filter_le_smul_filter
code: @[to_additive]
theorem smul_filter_le_smul_filter (hf : f₁ ≤ f₂) : a • f₁ ≤ a • f₂ 
goal: a • f₁ ≤ a • f₂

full_name: Filter.vadd_filter_le_vadd_filter
code: @[to_additive]
theorem smul_filter_le_smul_filter (hf : f₁ ≤ f₂) : a • f₁ ≤ a • f₂ 
goal: a +ᵥ f₁ ≤ a +ᵥ f₂

full_name: Filter.covariant_vadd_filter
code: @[to_additive]
instance covariant_smul_filter : CovariantClass α (Filter β) (· • ·) (· ≤ ·) 
goal: CovariantClass α (Filter β) (fun x x_1 => x +ᵥ x_1) fun x x_1 => x ≤ x_1

full_name: Filter.covariant_smul_filter
code: @[to_additive]
instance covariant_smul_filter : CovariantClass α (Filter β) (· • ·) (· ≤ ·) 
goal: CovariantClass α (Filter β) (fun x x_1 => x • x_1) fun x x_1 => x ≤ x_1

full_name: Filter.smulCommClass_filter
code: @[to_additive]
instance smulCommClass_filter [SMul α γ] [SMul β γ] [SMulCommClass α β γ] :
    SMulCommClass α β (Filter γ) 
goal: SMulCommClass α β (Filter γ)

full_name: Filter.vaddCommClass_filter
code: @[to_additive]
instance smulCommClass_filter [SMul α γ] [SMul β γ] [SMulCommClass α β γ] :
    SMulCommClass α β (Filter γ) 
goal: VAddCommClass α β (Filter γ)

full_name: Filter.vaddCommClass_filter'
code: @[to_additive]
instance smulCommClass_filter' [SMul α γ] [SMul β γ] [SMulCommClass α β γ] :
    SMulCommClass α (Filter β) (Filter γ) 
goal: VAddCommClass α (Filter β) (Filter γ)

full_name: Filter.smulCommClass_filter'
code: @[to_additive]
instance smulCommClass_filter' [SMul α γ] [SMul β γ] [SMulCommClass α β γ] :
    SMulCommClass α (Filter β) (Filter γ) 
goal: SMulCommClass α (Filter β) (Filter γ)

full_name: Filter.smulCommClass_filter''
code: @[to_additive]
instance smulCommClass_filter'' [SMul α γ] [SMul β γ] [SMulCommClass α β γ] :
    SMulCommClass (Filter α) β (Filter γ) 
goal: SMulCommClass (Filter α) β (Filter γ)

full_name: Filter.vaddCommClass_filter''
code: @[to_additive]
instance smulCommClass_filter'' [SMul α γ] [SMul β γ] [SMulCommClass α β γ] :
    SMulCommClass (Filter α) β (Filter γ) 
goal: VAddCommClass (Filter α) β (Filter γ)

full_name: Filter.vaddCommClass
code: @[to_additive]
instance smulCommClass [SMul α γ] [SMul β γ] [SMulCommClass α β γ] :
    SMulCommClass (Filter α) (Filter β) (Filter γ) 
goal: VAddCommClass (Filter α) (Filter β) (Filter γ)

full_name: Filter.smulCommClass
code: @[to_additive]
instance smulCommClass [SMul α γ] [SMul β γ] [SMulCommClass α β γ] :
    SMulCommClass (Filter α) (Filter β) (Filter γ) 
goal: SMulCommClass (Filter α) (Filter β) (Filter γ)

full_name: Filter.vaddAssocClass
code: @[to_additive vaddAssocClass]
instance isScalarTower [SMul α β] [SMul α γ] [SMul β γ] [IsScalarTower α β γ] :
    IsScalarTower α β (Filter γ) 
goal: VAddAssocClass α β (Filter γ)

full_name: Filter.isScalarTower
code: @[to_additive vaddAssocClass]
instance isScalarTower [SMul α β] [SMul α γ] [SMul β γ] [IsScalarTower α β γ] :
    IsScalarTower α β (Filter γ) 
goal: IsScalarTower α β (Filter γ)

full_name: Filter.isScalarTower'
code: @[to_additive vaddAssocClass']
instance isScalarTower' [SMul α β] [SMul α γ] [SMul β γ] [IsScalarTower α β γ] :
    IsScalarTower α (Filter β) (Filter γ) 
goal: IsScalarTower α (Filter β) (Filter γ)

full_name: Filter.vaddAssocClass'
code: @[to_additive vaddAssocClass']
instance isScalarTower' [SMul α β] [SMul α γ] [SMul β γ] [IsScalarTower α β γ] :
    IsScalarTower α (Filter β) (Filter γ) 
goal: VAddAssocClass α (Filter β) (Filter γ)

full_name: Filter.isScalarTower''
code: @[to_additive vaddAssocClass'']
instance isScalarTower'' [SMul α β] [SMul α γ] [SMul β γ] [IsScalarTower α β γ] :
    IsScalarTower (Filter α) (Filter β) (Filter γ) 
goal: IsScalarTower (Filter α) (Filter β) (Filter γ)

full_name: Filter.vaddAssocClass''
code: @[to_additive vaddAssocClass'']
instance isScalarTower'' [SMul α β] [SMul α γ] [SMul β γ] [IsScalarTower α β γ] :
    IsScalarTower (Filter α) (Filter β) (Filter γ) 
goal: VAddAssocClass (Filter α) (Filter β) (Filter γ)

full_name: Filter.isCentralVAdd
code: @[to_additive]
instance isCentralScalar [SMul α β] [SMul αᵐᵒᵖ β] [IsCentralScalar α β] :
    IsCentralScalar α (Filter β) 
goal: IsCentralVAdd α (Filter β)

full_name: Filter.isCentralScalar
code: @[to_additive]
instance isCentralScalar [SMul α β] [SMul αᵐᵒᵖ β] [IsCentralScalar α β] :
    IsCentralScalar α (Filter β) 
goal: IsCentralScalar α (Filter β)

full_name: Filter.addAction
code: /-- A multiplicative action of a monoid `α` on a type `β` gives a multiplicative action of
`Filter α` on `Filter β`. -/
@[to_additive "An additive action of an additive monoid `α` on a type `β` gives an additive action
 of `Filter α` on `Filter β`"]
protected def mulAction [Monoid α] [MulAction α β] : MulAction (Filter α) (Filter β) 
goal: AddAction (Filter α) (Filter β)

full_name: Filter.mulAction
code: /-- A multiplicative action of a monoid `α` on a type `β` gives a multiplicative action of
`Filter α` on `Filter β`. -/
@[to_additive "An additive action of an additive monoid `α` on a type `β` gives an additive action
 of `Filter α` on `Filter β`"]
protected def mulAction [Monoid α] [MulAction α β] : MulAction (Filter α) (Filter β) 
goal: MulAction (Filter α) (Filter β)

full_name: Filter.mulActionFilter
code: /-- A multiplicative action of a monoid on a type `β` gives a multiplicative action on `Filter β`.
-/
@[to_additive "An additive action of an additive monoid on a type `β` gives an additive action on
 `Filter β`."]
protected def mulActionFilter [Monoid α] [MulAction α β] : MulAction α (Filter β) 
goal: MulAction α (Filter β)

full_name: Filter.addActionFilter
code: /-- A multiplicative action of a monoid on a type `β` gives a multiplicative action on `Filter β`.
-/
@[to_additive "An additive action of an additive monoid on a type `β` gives an additive action on
 `Filter β`."]
protected def mulActionFilter [Monoid α] [MulAction α β] : MulAction α (Filter β) 
goal: AddAction α (Filter β)

full_name: Filter.distribMulActionFilter
code: /-- A distributive multiplicative action of a monoid on an additive monoid `β` gives a distributive
multiplicative action on `Filter β`. -/
protected def distribMulActionFilter [Monoid α] [AddMonoid β] [DistribMulAction α β] :
    DistribMulAction α (Filter β) 
goal: DistribMulAction α (Filter β)

full_name: Filter.mulDistribMulActionFilter
code: /-- A multiplicative action of a monoid on a monoid `β` gives a multiplicative action on `Set β`. -/
protected def mulDistribMulActionFilter [Monoid α] [Monoid β] [MulDistribMulAction α β] :
    MulDistribMulAction α (Set β) 
goal: MulDistribMulAction α (Set β)

full_name: Filter.NeBot.smul_zero_nonneg
code: theorem NeBot.smul_zero_nonneg (hf : f.NeBot) : 0 ≤ f • (0 : Filter β) 
goal: 0 ≤ f • 0

full_name: Filter.NeBot.zero_smul_nonneg
code: theorem NeBot.zero_smul_nonneg (hg : g.NeBot) : 0 ≤ (0 : Filter α) • g 
goal: 0 ≤ 0 • g

full_name: Filter.zero_smul_filter_nonpos
code: theorem zero_smul_filter_nonpos : (0 : α) • g ≤ 0 
goal: 0 • g ≤ 0

full_name: Filter.zero_smul_filter
code: theorem zero_smul_filter (hg : g.NeBot) : (0 : α) • g = 0 
goal: 0 • g = 0