ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Filter.tendsto_zero
@[to_additive (attr := simp)]
theorem tendsto_one {a : Filter β} {f : β → α} : Tendsto f a 1 ↔ ∀ᶠ x in a, f x = 1 
Arguments: {α : Type u_2} {β : Type u_3} [Zero α] {a : Filter β} {f : β → α}
Goal: Filter.Tendsto f a 0 ↔ ∀ᶠ (x : β) in a, f x = 0
-- Filter.zero_sum_zero
@[to_additive (attr := simp)]
theorem one_prod_one [One β] : (1 : Filter α) ×ˢ (1 : Filter β) = 1 
Arguments: {α : Type u_2} {β : Type u_3} [Zero α] [Zero β]
Goal: 0 ×ˢ 0 = 0
-- Filter.one_prod_one
@[to_additive (attr := simp)]
theorem one_prod_one [One β] : (1 : Filter α) ×ˢ (1 : Filter β) = 1 
Arguments: {α : Type u_2} {β : Type u_3} [One α] [One β]
Goal: 1 ×ˢ 1 = 1
-- Filter.coe_pureOneHom
@[to_additive (attr := simp)]
theorem coe_pureOneHom : (pureOneHom : α → Filter α) = pure 
Arguments: {α : Type u_2} [One α]
Goal: ⇑Filter.pureOneHom = pure
-- Filter.coe_pureZeroHom
@[to_additive (attr := simp)]
theorem coe_pureOneHom : (pureOneHom : α → Filter α) = pure 
Arguments: {α : Type u_2} [Zero α]
Goal: ⇑Filter.pureZeroHom = pure
-- Filter.pureZeroHom_apply
@[to_additive (attr := simp)]
theorem pureOneHom_apply (a : α) : pureOneHom a = pure a 
Arguments: {α : Type u_2} [Zero α] (a : α)
Goal: Filter.pureZeroHom a = pure a
-- Filter.pureOneHom_apply
@[to_additive (attr := simp)]
theorem pureOneHom_apply (a : α) : pureOneHom a = pure a 
Arguments: {α : Type u_2} [One α] (a : α)
Goal: Filter.pureOneHom a = pure a
-- Filter.map_zero
@[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 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [Zero α] [Zero β] [FunLike F α β] [ZeroHomClass F α β] (φ : F)
Goal: Filter.map (⇑φ) 0 = 0
-- Filter.map_one
@[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 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [One α] [One β] [FunLike F α β] [OneHomClass F α β] (φ : F)
Goal: Filter.map (⇑φ) 1 = 1
-- Filter.map_inv
@[to_additive (attr := simp)]
protected theorem map_inv : f.map Inv.inv = f⁻¹ 
Arguments: {α : Type u_2} [Inv α] {f : Filter α}
Goal: Filter.map Inv.inv f = f⁻¹
-- Filter.map_neg
@[to_additive (attr := simp)]
protected theorem map_inv : f.map Inv.inv = f⁻¹ 
Arguments: {α : Type u_2} [Neg α] {f : Filter α}
Goal: Filter.map Neg.neg f = -f
-- Filter.mem_inv
@[to_additive]
theorem mem_inv : s ∈ f⁻¹ ↔ Inv.inv ⁻¹' s ∈ f 
Arguments: {α : Type u_2} [Inv α] {f : Filter α} {s : Set α}
Goal: s ∈ f⁻¹ ↔ Inv.inv ⁻¹' s ∈ f
-- Filter.mem_neg
@[to_additive]
theorem mem_inv : s ∈ f⁻¹ ↔ Inv.inv ⁻¹' s ∈ f 
Arguments: {α : Type u_2} [Neg α] {f : Filter α} {s : Set α}
Goal: s ∈ -f ↔ Neg.neg ⁻¹' s ∈ f
-- Filter.neg_le_neg
@[to_additive]
protected theorem inv_le_inv (hf : f ≤ g) : f⁻¹ ≤ g⁻¹ 
Arguments: {α : Type u_2} [Neg α] {f g : Filter α} (hf : f ≤ g)
Goal: -f ≤ -g
-- Filter.inv_le_inv
@[to_additive]
protected theorem inv_le_inv (hf : f ≤ g) : f⁻¹ ≤ g⁻¹ 
Arguments: {α : Type u_2} [Inv α] {f g : Filter α} (hf : f ≤ g)
Goal: f⁻¹ ≤ g⁻¹
-- Filter.neg_pure
@[to_additive (attr := simp)]
theorem inv_pure : (pure a : Filter α)⁻¹ = pure a⁻¹ 
Arguments: {α : Type u_2} [Neg α] {a : α}
Goal: -pure a = pure (-a)
-- Filter.inv_pure
@[to_additive (attr := simp)]
theorem inv_pure : (pure a : Filter α)⁻¹ = pure a⁻¹ 
Arguments: {α : Type u_2} [Inv α] {a : α}
Goal: (pure a)⁻¹ = pure a⁻¹
-- Filter.neg_eq_bot_iff
@[to_additive (attr := simp)]
theorem inv_eq_bot_iff : f⁻¹ = ⊥ ↔ f = ⊥ 
Arguments: {α : Type u_2} [Neg α] {f : Filter α}
Goal: -f = ⊥ ↔ f = ⊥
-- Filter.inv_eq_bot_iff
@[to_additive (attr := simp)]
theorem inv_eq_bot_iff : f⁻¹ = ⊥ ↔ f = ⊥ 
Arguments: {α : Type u_2} [Inv α] {f : Filter α}
Goal: f⁻¹ = ⊥ ↔ f = ⊥
-- Filter.neBot_inv_iff
@[to_additive (attr := simp)]
theorem neBot_inv_iff : f⁻¹.NeBot ↔ NeBot f 
Arguments: {α : Type u_2} [Inv α] {f : Filter α}
Goal: f⁻¹.NeBot ↔ f.NeBot
-- Filter.neBot_neg_iff
@[to_additive (attr := simp)]
theorem neBot_inv_iff : f⁻¹.NeBot ↔ NeBot f 
Arguments: {α : Type u_2} [Neg α] {f : Filter α}
Goal: (-f).NeBot ↔ f.NeBot
-- Filter.NeBot.neg
@[to_additive]
protected theorem NeBot.inv : f.NeBot → f⁻¹.NeBot 
Arguments: {α : Type u_2} [Neg α] {f : Filter α}
Goal: f.NeBot → (-f).NeBot
-- Filter.NeBot.inv
@[to_additive]
protected theorem NeBot.inv : f.NeBot → f⁻¹.NeBot 
Arguments: {α : Type u_2} [Inv α] {f : Filter α}
Goal: f.NeBot → f⁻¹.NeBot
-- Filter.neg.instNeBot
@[to_additive neg.instNeBot]
lemma inv.instNeBot [NeBot f] : NeBot f⁻¹ 
Arguments: {α : Type u_2} [Neg α] {f : Filter α} [f.NeBot]
Goal: (-f).NeBot
-- Filter.inv.instNeBot
@[to_additive neg.instNeBot]
lemma inv.instNeBot [NeBot f] : NeBot f⁻¹ 
Arguments: {α : Type u_2} [Inv α] {f : Filter α} [f.NeBot]
Goal: f⁻¹.NeBot
-- Filter.comap_neg
@[to_additive (attr := simp)]
protected lemma comap_inv : comap Inv.inv f = f⁻¹ 
Arguments: {α : Type u_2} [InvolutiveNeg α] {f : Filter α}
Goal: Filter.comap Neg.neg f = -f
-- Filter.comap_inv
@[to_additive (attr := simp)]
protected lemma comap_inv : comap Inv.inv f = f⁻¹ 
Arguments: {α : Type u_2} [InvolutiveInv α] {f : Filter α}
Goal: Filter.comap Inv.inv f = f⁻¹
-- Filter.neg_mem_neg
@[to_additive]
theorem inv_mem_inv (hs : s ∈ f) : s⁻¹ ∈ f⁻¹ 
Arguments: {α : Type u_2} [InvolutiveNeg α] {f : Filter α} {s : Set α} (hs : s ∈ f)
Goal: -s ∈ -f
-- Filter.inv_mem_inv
@[to_additive]
theorem inv_mem_inv (hs : s ∈ f) : s⁻¹ ∈ f⁻¹ 
Arguments: {α : Type u_2} [InvolutiveInv α] {f : Filter α} {s : Set α} (hs : s ∈ f)
Goal: s⁻¹ ∈ f⁻¹
-- Filter.inv_le_inv_iff
@[to_additive (attr := simp)]
protected theorem inv_le_inv_iff : f⁻¹ ≤ g⁻¹ ↔ f ≤ g 
Arguments: {α : Type u_2} [InvolutiveInv α] {f g : Filter α}
Goal: f⁻¹ ≤ g⁻¹ ↔ f ≤ g
-- Filter.neg_le_neg_iff
@[to_additive (attr := simp)]
protected theorem inv_le_inv_iff : f⁻¹ ≤ g⁻¹ ↔ f ≤ g 
Arguments: {α : Type u_2} [InvolutiveNeg α] {f g : Filter α}
Goal: -f ≤ -g ↔ f ≤ g
-- Filter.neg_le_iff_le_neg
@[to_additive]
theorem inv_le_iff_le_inv : f⁻¹ ≤ g ↔ f ≤ g⁻¹ 
Arguments: {α : Type u_2} [InvolutiveNeg α] {f g : Filter α}
Goal: -f ≤ g ↔ f ≤ -g
-- Filter.inv_le_iff_le_inv
@[to_additive]
theorem inv_le_iff_le_inv : f⁻¹ ≤ g ↔ f ≤ g⁻¹ 
Arguments: {α : Type u_2} [InvolutiveInv α] {f g : Filter α}
Goal: f⁻¹ ≤ g ↔ f ≤ g⁻¹
-- Filter.neg_le_self
@[to_additive (attr := simp)]
theorem inv_le_self : f⁻¹ ≤ f ↔ f⁻¹ = f 
Arguments: {α : Type u_2} [InvolutiveNeg α] {f : Filter α}
Goal: -f ≤ f ↔ -f = f
-- Filter.inv_le_self
@[to_additive (attr := simp)]
theorem inv_le_self : f⁻¹ ≤ f ↔ f⁻¹ = f 
Arguments: {α : Type u_2} [InvolutiveInv α] {f : Filter α}
Goal: f⁻¹ ≤ f ↔ f⁻¹ = f
-- Filter.neg_atTop
@[to_additive (attr := simp)]
lemma inv_atTop {G : Type*} [OrderedCommGroup G] : (atTop : Filter G)⁻¹ = atBot 
Arguments: {G : Type u_7} [OrderedAddCommGroup G]
Goal: -Filter.atTop = Filter.atBot
-- Filter.inv_atTop
@[to_additive (attr := simp)]
lemma inv_atTop {G : Type*} [OrderedCommGroup G] : (atTop : Filter G)⁻¹ = atBot 
Arguments: {G : Type u_7} [OrderedCommGroup G]
Goal: Filter.atTop⁻¹ = Filter.atBot
-- Filter.map₂_mul
@[to_additive (attr := simp)]
theorem map₂_mul : map₂ (· * ·) f g = f * g 
Arguments: {α : Type u_2} [Mul α] {f g : Filter α}
Goal: Filter.map₂ (fun x x_1 => x * x_1) f g = f * g
-- Filter.map₂_add
@[to_additive (attr := simp)]
theorem map₂_mul : map₂ (· * ·) f g = f * g 
Arguments: {α : Type u_2} [Add α] {f g : Filter α}
Goal: Filter.map₂ (fun x x_1 => x + x_1) f g = f + g
-- Filter.mem_mul
@[to_additive]
theorem mem_mul : s ∈ f * g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ * t₂ ⊆ s 
Arguments: {α : Type u_2} [Mul α] {f g : Filter α} {s : Set α}
Goal: s ∈ f * g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ * t₂ ⊆ s
-- Filter.mem_add
@[to_additive]
theorem mem_mul : s ∈ f * g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ * t₂ ⊆ s 
Arguments: {α : Type u_2} [Add α] {f g : Filter α} {s : Set α}
Goal: s ∈ f + g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ + t₂ ⊆ s
-- Filter.add_mem_add
@[to_additive]
theorem mul_mem_mul : s ∈ f → t ∈ g → s * t ∈ f * g 
Arguments: {α : Type u_2} [Add α] {f g : Filter α} {s t : Set α}
Goal: s ∈ f → t ∈ g → s + t ∈ f + g
-- Filter.mul_mem_mul
@[to_additive]
theorem mul_mem_mul : s ∈ f → t ∈ g → s * t ∈ f * g 
Arguments: {α : Type u_2} [Mul α] {f g : Filter α} {s t : Set α}
Goal: s ∈ f → t ∈ g → s * t ∈ f * g
-- Filter.bot_add
@[to_additive (attr := simp)]
theorem bot_mul : ⊥ * g = ⊥ 
Arguments: {α : Type u_2} [Add α] {g : Filter α}
Goal: ⊥ + g = ⊥
-- Filter.bot_mul
@[to_additive (attr := simp)]
theorem bot_mul : ⊥ * g = ⊥ 
Arguments: {α : Type u_2} [Mul α] {g : Filter α}
Goal: ⊥ * g = ⊥
-- Filter.add_bot
@[to_additive (attr := simp)]
theorem mul_bot : f * ⊥ = ⊥ 
Arguments: {α : Type u_2} [Add α] {f : Filter α}
Goal: f + ⊥ = ⊥
-- Filter.mul_bot
@[to_additive (attr := simp)]
theorem mul_bot : f * ⊥ = ⊥ 
Arguments: {α : Type u_2} [Mul α] {f : Filter α}
Goal: f * ⊥ = ⊥
-- Filter.mul_eq_bot_iff
@[to_additive (attr := simp)]
theorem mul_eq_bot_iff : f * g = ⊥ ↔ f = ⊥ ∨ g = ⊥ 
Arguments: {α : Type u_2} [Mul α] {f g : Filter α}
Goal: f * g = ⊥ ↔ f = ⊥ ∨ g = ⊥
-- Filter.add_eq_bot_iff
@[to_additive (attr := simp)]
theorem mul_eq_bot_iff : f * g = ⊥ ↔ f = ⊥ ∨ g = ⊥ 
Arguments: {α : Type u_2} [Add α] {f g : Filter α}
Goal: f + g = ⊥ ↔ f = ⊥ ∨ g = ⊥
-- Filter.add_neBot_iff
@[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 
Arguments: {α : Type u_2} [Add α] {f g : Filter α}
Goal: (f + g).NeBot ↔ f.NeBot ∧ g.NeBot
-- Filter.mul_neBot_iff
@[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 
Arguments: {α : Type u_2} [Mul α] {f g : Filter α}
Goal: (f * g).NeBot ↔ f.NeBot ∧ g.NeBot
-- Filter.NeBot.mul
@[to_additive]
protected theorem NeBot.mul : NeBot f → NeBot g → NeBot (f * g) 
Arguments: {α : Type u_2} [Mul α] {f g : Filter α}
Goal: f.NeBot → g.NeBot → (f * g).NeBot
-- Filter.NeBot.add
@[to_additive]
protected theorem NeBot.mul : NeBot f → NeBot g → NeBot (f * g) 
Arguments: {α : Type u_2} [Add α] {f g : Filter α}
Goal: f.NeBot → g.NeBot → (f + g).NeBot
-- Filter.NeBot.of_add_left
@[to_additive]
theorem NeBot.of_mul_left : (f * g).NeBot → f.NeBot 
Arguments: {α : Type u_2} [Add α] {f g : Filter α}
Goal: (f + g).NeBot → f.NeBot
-- Filter.NeBot.of_mul_left
@[to_additive]
theorem NeBot.of_mul_left : (f * g).NeBot → f.NeBot 
Arguments: {α : Type u_2} [Mul α] {f g : Filter α}
Goal: (f * g).NeBot → f.NeBot
-- Filter.NeBot.of_add_right
@[to_additive]
theorem NeBot.of_mul_right : (f * g).NeBot → g.NeBot 
Arguments: {α : Type u_2} [Add α] {f g : Filter α}
Goal: (f + g).NeBot → g.NeBot
-- Filter.NeBot.of_mul_right
@[to_additive]
theorem NeBot.of_mul_right : (f * g).NeBot → g.NeBot 
Arguments: {α : Type u_2} [Mul α] {f g : Filter α}
Goal: (f * g).NeBot → g.NeBot
-- Filter.mul.instNeBot
@[to_additive add.instNeBot]
protected lemma mul.instNeBot [NeBot f] [NeBot g] : NeBot (f * g) 
Arguments: {α : Type u_2} [Mul α] {f g : Filter α} [f.NeBot] [g.NeBot]
Goal: (f * g).NeBot
-- Filter.add.instNeBot
@[to_additive add.instNeBot]
protected lemma mul.instNeBot [NeBot f] [NeBot g] : NeBot (f * g) 
Arguments: {α : Type u_2} [Add α] {f g : Filter α} [f.NeBot] [g.NeBot]
Goal: (f + g).NeBot
-- Filter.pure_mul
@[to_additive (attr := simp)]
theorem pure_mul : pure a * g = g.map (a * ·) 
Arguments: {α : Type u_2} [Mul α] {g : Filter α} {a : α}
Goal: pure a * g = Filter.map (fun x => a * x) g
-- Filter.pure_add
@[to_additive (attr := simp)]
theorem pure_mul : pure a * g = g.map (a * ·) 
Arguments: {α : Type u_2} [Add α] {g : Filter α} {a : α}
Goal: pure a + g = Filter.map (fun x => a + x) g
-- Filter.mul_pure
@[to_additive (attr := simp)]
theorem mul_pure : f * pure b = f.map (· * b) 
Arguments: {α : Type u_2} [Mul α] {f : Filter α} {b : α}
Goal: f * pure b = Filter.map (fun x => x * b) f
-- Filter.add_pure
@[to_additive (attr := simp)]
theorem mul_pure : f * pure b = f.map (· * b) 
Arguments: {α : Type u_2} [Add α] {f : Filter α} {b : α}
Goal: f + pure b = Filter.map (fun x => x + b) f
-- Filter.pure_add_pure
@[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) 
Arguments: {α : Type u_2} [Add α] {a b : α}
Goal: pure a + pure b = pure (a + b)
-- Filter.pure_mul_pure
@[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) 
Arguments: {α : Type u_2} [Mul α] {a b : α}
Goal: pure a * pure b = pure (a * b)
-- Filter.le_add_iff
@[to_additive (attr := simp)]
theorem le_mul_iff : h ≤ f * g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t ∈ g → s * t ∈ h 
Arguments: {α : Type u_2} [Add α] {f g h : Filter α}
Goal: h ≤ f + g ↔ ∀ ⦃s : Set α⦄, s ∈ f → ∀ ⦃t : Set α⦄, t ∈ g → s + t ∈ h
-- Filter.le_mul_iff
@[to_additive (attr := simp)]
theorem le_mul_iff : h ≤ f * g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t ∈ g → s * t ∈ h 
Arguments: {α : Type u_2} [Mul α] {f g h : Filter α}
Goal: h ≤ f * g ↔ ∀ ⦃s : Set α⦄, s ∈ f → ∀ ⦃t : Set α⦄, t ∈ g → s * t ∈ h
-- Filter.map_add
@[to_additive]
protected theorem map_mul [FunLike F α β] [MulHomClass F α β] (m : F) :
    (f₁ * f₂).map m = f₁.map m * f₂.map m 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [Add α] [Add β] {f₁ f₂ : Filter α} [FunLike F α β] [AddHomClass F α β] (m : F)
Goal: Filter.map (⇑m) (f₁ + f₂) = Filter.map (⇑m) f₁ + Filter.map (⇑m) f₂
-- Filter.map_mul
@[to_additive]
protected theorem map_mul [FunLike F α β] [MulHomClass F α β] (m : F) :
    (f₁ * f₂).map m = f₁.map m * f₂.map m 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [Mul α] [Mul β] {f₁ f₂ : Filter α} [FunLike F α β] [MulHomClass F α β] (m : F)
Goal: Filter.map (⇑m) (f₁ * f₂) = Filter.map (⇑m) f₁ * Filter.map (⇑m) f₂
-- Filter.coe_pureMulHom
@[to_additive (attr := simp)]
theorem coe_pureMulHom : (pureMulHom : α → Filter α) = pure 
Arguments: {α : Type u_2} [Mul α]
Goal: ⇑Filter.pureMulHom = pure
-- Filter.coe_pureAddHom
@[to_additive (attr := simp)]
theorem coe_pureMulHom : (pureMulHom : α → Filter α) = pure 
Arguments: {α : Type u_2} [Add α]
Goal: ⇑Filter.pureAddHom = pure
-- Filter.pureMulHom_apply
@[to_additive (attr := simp)]
theorem pureMulHom_apply (a : α) : pureMulHom a = pure a 
Arguments: {α : Type u_2} [Mul α] (a : α)
Goal: Filter.pureMulHom a = pure a
-- Filter.pureAddHom_apply
@[to_additive (attr := simp)]
theorem pureMulHom_apply (a : α) : pureMulHom a = pure a 
Arguments: {α : Type u_2} [Add α] (a : α)
Goal: Filter.pureAddHom a = pure a
-- Filter.map₂_sub
@[to_additive (attr := simp)]
theorem map₂_div : map₂ (· / ·) f g = f / g 
Arguments: {α : Type u_2} [Sub α] {f g : Filter α}
Goal: Filter.map₂ (fun x x_1 => x - x_1) f g = f - g
-- Filter.map₂_div
@[to_additive (attr := simp)]
theorem map₂_div : map₂ (· / ·) f g = f / g 
Arguments: {α : Type u_2} [Div α] {f g : Filter α}
Goal: Filter.map₂ (fun x x_1 => x / x_1) f g = f / g
-- Filter.mem_div
@[to_additive]
theorem mem_div : s ∈ f / g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ / t₂ ⊆ s 
Arguments: {α : Type u_2} [Div α] {f g : Filter α} {s : Set α}
Goal: s ∈ f / g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ / t₂ ⊆ s
-- Filter.mem_sub
@[to_additive]
theorem mem_div : s ∈ f / g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ / t₂ ⊆ s 
Arguments: {α : Type u_2} [Sub α] {f g : Filter α} {s : Set α}
Goal: s ∈ f - g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ - t₂ ⊆ s
-- Filter.sub_mem_sub
@[to_additive]
theorem div_mem_div : s ∈ f → t ∈ g → s / t ∈ f / g 
Arguments: {α : Type u_2} [Sub α] {f g : Filter α} {s t : Set α}
Goal: s ∈ f → t ∈ g → s - t ∈ f - g
-- Filter.div_mem_div
@[to_additive]
theorem div_mem_div : s ∈ f → t ∈ g → s / t ∈ f / g 
Arguments: {α : Type u_2} [Div α] {f g : Filter α} {s t : Set α}
Goal: s ∈ f → t ∈ g → s / t ∈ f / g
-- Filter.bot_sub
@[to_additive (attr := simp)]
theorem bot_div : ⊥ / g = ⊥ 
Arguments: {α : Type u_2} [Sub α] {g : Filter α}
Goal: ⊥ - g = ⊥
-- Filter.bot_div
@[to_additive (attr := simp)]
theorem bot_div : ⊥ / g = ⊥ 
Arguments: {α : Type u_2} [Div α] {g : Filter α}
Goal: ⊥ / g = ⊥
-- Filter.div_bot
@[to_additive (attr := simp)]
theorem div_bot : f / ⊥ = ⊥ 
Arguments: {α : Type u_2} [Div α] {f : Filter α}
Goal: f / ⊥ = ⊥
-- Filter.sub_bot
@[to_additive (attr := simp)]
theorem div_bot : f / ⊥ = ⊥ 
Arguments: {α : Type u_2} [Sub α] {f : Filter α}
Goal: f - ⊥ = ⊥
-- Filter.div_eq_bot_iff
@[to_additive (attr := simp)]
theorem div_eq_bot_iff : f / g = ⊥ ↔ f = ⊥ ∨ g = ⊥ 
Arguments: {α : Type u_2} [Div α] {f g : Filter α}
Goal: f / g = ⊥ ↔ f = ⊥ ∨ g = ⊥
-- Filter.sub_eq_bot_iff
@[to_additive (attr := simp)]
theorem div_eq_bot_iff : f / g = ⊥ ↔ f = ⊥ ∨ g = ⊥ 
Arguments: {α : Type u_2} [Sub α] {f g : Filter α}
Goal: f - g = ⊥ ↔ f = ⊥ ∨ g = ⊥
-- Filter.sub_neBot_iff
@[to_additive (attr := simp)]
theorem div_neBot_iff : (f / g).NeBot ↔ f.NeBot ∧ g.NeBot 
Arguments: {α : Type u_2} [Sub α] {f g : Filter α}
Goal: (f - g).NeBot ↔ f.NeBot ∧ g.NeBot
-- Filter.div_neBot_iff
@[to_additive (attr := simp)]
theorem div_neBot_iff : (f / g).NeBot ↔ f.NeBot ∧ g.NeBot 
Arguments: {α : Type u_2} [Div α] {f g : Filter α}
Goal: (f / g).NeBot ↔ f.NeBot ∧ g.NeBot
-- Filter.NeBot.div
@[to_additive]
protected theorem NeBot.div : NeBot f → NeBot g → NeBot (f / g) 
Arguments: {α : Type u_2} [Div α] {f g : Filter α}
Goal: f.NeBot → g.NeBot → (f / g).NeBot
-- Filter.NeBot.sub
@[to_additive]
protected theorem NeBot.div : NeBot f → NeBot g → NeBot (f / g) 
Arguments: {α : Type u_2} [Sub α] {f g : Filter α}
Goal: f.NeBot → g.NeBot → (f - g).NeBot
-- Filter.NeBot.of_sub_left
@[to_additive]
theorem NeBot.of_div_left : (f / g).NeBot → f.NeBot 
Arguments: {α : Type u_2} [Sub α] {f g : Filter α}
Goal: (f - g).NeBot → f.NeBot
-- Filter.NeBot.of_div_left
@[to_additive]
theorem NeBot.of_div_left : (f / g).NeBot → f.NeBot 
Arguments: {α : Type u_2} [Div α] {f g : Filter α}
Goal: (f / g).NeBot → f.NeBot
-- Filter.NeBot.of_sub_right
@[to_additive]
theorem NeBot.of_div_right : (f / g).NeBot → g.NeBot 
Arguments: {α : Type u_2} [Sub α] {f g : Filter α}
Goal: (f - g).NeBot → g.NeBot
-- Filter.NeBot.of_div_right
@[to_additive]
theorem NeBot.of_div_right : (f / g).NeBot → g.NeBot 
Arguments: {α : Type u_2} [Div α] {f g : Filter α}
Goal: (f / g).NeBot → g.NeBot
-- Filter.div.instNeBot
@[to_additive sub.instNeBot]
lemma div.instNeBot [NeBot f] [NeBot g] : NeBot (f / g) 
Arguments: {α : Type u_2} [Div α] {f g : Filter α} [f.NeBot] [g.NeBot]
Goal: (f / g).NeBot
-- Filter.sub.instNeBot
@[to_additive sub.instNeBot]
lemma div.instNeBot [NeBot f] [NeBot g] : NeBot (f / g) 
Arguments: {α : Type u_2} [Sub α] {f g : Filter α} [f.NeBot] [g.NeBot]
Goal: (f - g).NeBot
-- Filter.pure_sub
@[to_additive (attr := simp)]
theorem pure_div : pure a / g = g.map (a / ·) 
Arguments: {α : Type u_2} [Sub α] {g : Filter α} {a : α}
Goal: pure a - g = Filter.map (fun x => a - x) g
-- Filter.pure_div
@[to_additive (attr := simp)]
theorem pure_div : pure a / g = g.map (a / ·) 
Arguments: {α : Type u_2} [Div α] {g : Filter α} {a : α}
Goal: pure a / g = Filter.map (fun x => a / x) g
-- Filter.sub_pure
@[to_additive (attr := simp)]
theorem div_pure : f / pure b = f.map (· / b) 
Arguments: {α : Type u_2} [Sub α] {f : Filter α} {b : α}
Goal: f - pure b = Filter.map (fun x => x - b) f
-- Filter.div_pure
@[to_additive (attr := simp)]
theorem div_pure : f / pure b = f.map (· / b) 
Arguments: {α : Type u_2} [Div α] {f : Filter α} {b : α}
Goal: f / pure b = Filter.map (fun x => x / b) f
-- Filter.pure_sub_pure
@[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) 
Arguments: {α : Type u_2} [Sub α] {a b : α}
Goal: pure a - pure b = pure (a - b)
-- Filter.pure_div_pure
@[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) 
Arguments: {α : Type u_2} [Div α] {a b : α}
Goal: pure a / pure b = pure (a / b)
-- Filter.div_le_div
@[to_additive]
protected theorem div_le_div : f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ / g₁ ≤ f₂ / g₂ 
Arguments: {α : Type u_2} [Div α] {f₁ f₂ g₁ g₂ : Filter α}
Goal: f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ / g₁ ≤ f₂ / g₂
-- Filter.sub_le_sub
@[to_additive]
protected theorem div_le_div : f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ / g₁ ≤ f₂ / g₂ 
Arguments: {α : Type u_2} [Sub α] {f₁ f₂ g₁ g₂ : Filter α}
Goal: f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ - g₁ ≤ f₂ - g₂
-- Filter.sub_le_sub_left
@[to_additive]
protected theorem div_le_div_left : g₁ ≤ g₂ → f / g₁ ≤ f / g₂ 
Arguments: {α : Type u_2} [Sub α] {f g₁ g₂ : Filter α}
Goal: g₁ ≤ g₂ → f - g₁ ≤ f - g₂
-- Filter.div_le_div_left
@[to_additive]
protected theorem div_le_div_left : g₁ ≤ g₂ → f / g₁ ≤ f / g₂ 
Arguments: {α : Type u_2} [Div α] {f g₁ g₂ : Filter α}
Goal: g₁ ≤ g₂ → f / g₁ ≤ f / g₂
-- Filter.div_le_div_right
@[to_additive]
protected theorem div_le_div_right : f₁ ≤ f₂ → f₁ / g ≤ f₂ / g 
Arguments: {α : Type u_2} [Div α] {f₁ f₂ g : Filter α}
Goal: f₁ ≤ f₂ → f₁ / g ≤ f₂ / g
-- Filter.sub_le_sub_right
@[to_additive]
protected theorem div_le_div_right : f₁ ≤ f₂ → f₁ / g ≤ f₂ / g 
Arguments: {α : Type u_2} [Sub α] {f₁ f₂ g : Filter α}
Goal: f₁ ≤ f₂ → f₁ - g ≤ f₂ - g
-- Filter.le_sub_iff
@[to_additive (attr := simp)]
protected theorem le_div_iff : h ≤ f / g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t ∈ g → s / t ∈ h 
Arguments: {α : Type u_2} [Sub α] {f g h : Filter α}
Goal: h ≤ f - g ↔ ∀ ⦃s : Set α⦄, s ∈ f → ∀ ⦃t : Set α⦄, t ∈ g → s - t ∈ h
-- Filter.le_div_iff
@[to_additive (attr := simp)]
protected theorem le_div_iff : h ≤ f / g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t ∈ g → s / t ∈ h 
Arguments: {α : Type u_2} [Div α] {f g h : Filter α}
Goal: h ≤ f / g ↔ ∀ ⦃s : Set α⦄, s ∈ f → ∀ ⦃t : Set α⦄, t ∈ g → s / t ∈ h
-- Filter.comap_mul_comap_le
@[to_additive]
theorem comap_mul_comap_le [MulHomClass F α β] (m : F) {f g : Filter β} :
    f.comap m * g.comap m ≤ (f * g).comap m 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [MulOneClass α] [MulOneClass β] [FunLike F α β] [MulHomClass F α β] (m : F) {f g : Filter β}
Goal: Filter.comap (⇑m) f * Filter.comap (⇑m) g ≤ Filter.comap (⇑m) (f * g)
-- Filter.comap_add_comap_le
@[to_additive]
theorem comap_mul_comap_le [MulHomClass F α β] (m : F) {f g : Filter β} :
    f.comap m * g.comap m ≤ (f * g).comap m 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [AddZeroClass α] [AddZeroClass β] [FunLike F α β] [AddHomClass F α β] (m : F) {f g : Filter β}
Goal: Filter.comap (⇑m) f + Filter.comap (⇑m) g ≤ Filter.comap (⇑m) (f + g)
-- Filter.Tendsto.mul_mul
@[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₂) 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [MulOneClass α] [MulOneClass β] [FunLike F α β] [MulHomClass F α β] (m : F) {f₁ g₁ : Filter α} {f₂ g₂ : Filter β}
Goal: Filter.Tendsto (⇑m) f₁ f₂ → Filter.Tendsto (⇑m) g₁ g₂ → Filter.Tendsto (⇑m) (f₁ * g₁) (f₂ * g₂)
-- Filter.Tendsto.add_add
@[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₂) 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [AddZeroClass α] [AddZeroClass β] [FunLike F α β] [AddHomClass F α β] (m : F) {f₁ g₁ : Filter α} {f₂ g₂ : Filter β}
Goal: Filter.Tendsto (⇑m) f₁ f₂ → Filter.Tendsto (⇑m) g₁ g₂ → Filter.Tendsto (⇑m) (f₁ + g₁) (f₂ + g₂)
-- Filter.coe_pureMonoidHom
@[to_additive (attr := simp)]
theorem coe_pureMonoidHom : (pureMonoidHom : α → Filter α) = pure 
Arguments: {α : Type u_2} [MulOneClass α]
Goal: ⇑Filter.pureMonoidHom = pure
-- Filter.coe_pureAddMonoidHom
@[to_additive (attr := simp)]
theorem coe_pureMonoidHom : (pureMonoidHom : α → Filter α) = pure 
Arguments: {α : Type u_2} [AddZeroClass α]
Goal: ⇑Filter.pureAddMonoidHom = pure
-- Filter.pureMonoidHom_apply
@[to_additive (attr := simp)]
theorem pureMonoidHom_apply (a : α) : pureMonoidHom a = pure a 
Arguments: {α : Type u_2} [MulOneClass α] (a : α)
Goal: Filter.pureMonoidHom a = pure a
-- Filter.pureAddMonoidHom_apply
@[to_additive (attr := simp)]
theorem pureMonoidHom_apply (a : α) : pureMonoidHom a = pure a 
Arguments: {α : Type u_2} [AddZeroClass α] (a : α)
Goal: Filter.pureAddMonoidHom a = pure a