ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Filter.tendsto_swap4_prod
theorem tendsto_swap4_prod {h : Filter γ} {k : Filter δ} :
    Tendsto (fun p : (α × β) × γ × δ => ((p.1.1, p.2.1), (p.1.2, p.2.2))) ((f ×ˢ g) ×ˢ (h ×ˢ k))
      ((f ×ˢ h) ×ˢ (g ×ˢ k)) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {f : Filter α} {g : Filter β} {h : Filter γ} {k : Filter δ}
Goal: Filter.Tendsto (fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) ((f ×ˢ g) ×ˢ h ×ˢ k) ((f ×ˢ h) ×ˢ g ×ˢ k)
-- Filter.prod_map_map_eq
theorem prod_map_map_eq.{u, v, w, x} {α₁ : Type u} {α₂ : Type v} {β₁ : Type w} {β₂ : Type x}
    {f₁ : Filter α₁} {f₂ : Filter α₂} {m₁ : α₁ → β₁} {m₂ : α₂ → β₂} :
    map m₁ f₁ ×ˢ map m₂ f₂ = map (fun p : α₁ × α₂ => (m₁ p.1, m₂ p.2)) (f₁ ×ˢ f₂) 
Arguments: {α₁ : Type u} {α₂ : Type v} {β₁ : Type w} {β₂ : Type x} {f₁ : Filter α₁} {f₂ : Filter α₂} {m₁ : α₁ → β₁} {m₂ : α₂ → β₂}
Goal: Filter.map m₁ f₁ ×ˢ Filter.map m₂ f₂ = Filter.map (fun p => (m₁ p.1, m₂ p.2)) (f₁ ×ˢ f₂)
-- Filter.prod_map_map_eq'
theorem prod_map_map_eq' {α₁ : Type*} {α₂ : Type*} {β₁ : Type*} {β₂ : Type*} (f : α₁ → α₂)
    (g : β₁ → β₂) (F : Filter α₁) (G : Filter β₁) :
    map f F ×ˢ map g G = map (Prod.map f g) (F ×ˢ G) 
Arguments: {α₁ : Type u_6} {α₂ : Type u_7} {β₁ : Type u_8} {β₂ : Type u_9} (f : α₁ → α₂) (g : β₁ → β₂) (F : Filter α₁) (G : Filter β₁)
Goal: Filter.map f F ×ˢ Filter.map g G = Filter.map (Prod.map f g) (F ×ˢ G)
-- Filter.prod_map_left
theorem prod_map_left (f : α → β) (F : Filter α) (G : Filter γ) :
    map f F ×ˢ G = map (Prod.map f id) (F ×ˢ G) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β) (F : Filter α) (G : Filter γ)
Goal: Filter.map f F ×ˢ G = Filter.map (Prod.map f id) (F ×ˢ G)
-- Filter.prod_map_right
theorem prod_map_right (f : β → γ) (F : Filter α) (G : Filter β) :
    F ×ˢ map f G = map (Prod.map id f) (F ×ˢ G) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : β → γ) (F : Filter α) (G : Filter β)
Goal: F ×ˢ Filter.map f G = Filter.map (Prod.map id f) (F ×ˢ G)
-- Filter.le_prod_map_fst_snd
theorem le_prod_map_fst_snd {f : Filter (α × β)} : f ≤ map Prod.fst f ×ˢ map Prod.snd f 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter (α × β)}
Goal: f ≤ Filter.map Prod.fst f ×ˢ Filter.map Prod.snd f
-- Filter.Tendsto.prod_map
theorem Tendsto.prod_map {δ : Type*} {f : α → γ} {g : β → δ} {a : Filter α} {b : Filter β}
    {c : Filter γ} {d : Filter δ} (hf : Tendsto f a c) (hg : Tendsto g b d) :
    Tendsto (Prod.map f g) (a ×ˢ b) (c ×ˢ d) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_6} {f : α → γ} {g : β → δ} {a : Filter α} {b : Filter β} {c : Filter γ} {d : Filter δ} (hf : Filter.Tendsto f a c) (hg : Filter.Tendsto g b d)
Goal: Filter.Tendsto (Prod.map f g) (a ×ˢ b) (c ×ˢ d)
-- Filter.map_prod
protected theorem map_prod (m : α × β → γ) (f : Filter α) (g : Filter β) :
    map m (f ×ˢ g) = (f.map fun a b => m (a, b)).seq g 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (m : α × β → γ) (f : Filter α) (g : Filter β)
Goal: Filter.map m (f ×ˢ g) = (Filter.map (fun a b => m (a, b)) f).seq g
-- Filter.prod_eq
theorem prod_eq : f ×ˢ g = (f.map Prod.mk).seq g 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β}
Goal: f ×ˢ g = (Filter.map Prod.mk f).seq g
-- Filter.prod_inf_prod
theorem prod_inf_prod {f₁ f₂ : Filter α} {g₁ g₂ : Filter β} :
    (f₁ ×ˢ g₁) ⊓ (f₂ ×ˢ g₂) = (f₁ ⊓ f₂) ×ˢ (g₁ ⊓ g₂) 
Arguments: {α : Type u_1} {β : Type u_2} {f₁ f₂ : Filter α} {g₁ g₂ : Filter β}
Goal: f₁ ×ˢ g₁ ⊓ f₂ ×ˢ g₂ = (f₁ ⊓ f₂) ×ˢ (g₁ ⊓ g₂)
-- Filter.inf_prod
theorem inf_prod {f₁ f₂ : Filter α} : (f₁ ⊓ f₂) ×ˢ g = (f₁ ×ˢ g) ⊓ (f₂ ×ˢ g) 
Arguments: {α : Type u_1} {β : Type u_2} {g : Filter β} {f₁ f₂ : Filter α}
Goal: (f₁ ⊓ f₂) ×ˢ g = f₁ ×ˢ g ⊓ f₂ ×ˢ g
-- Filter.prod_inf
theorem prod_inf {g₁ g₂ : Filter β} : f ×ˢ (g₁ ⊓ g₂) = (f ×ˢ g₁) ⊓ (f ×ˢ g₂) 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g₁ g₂ : Filter β}
Goal: f ×ˢ (g₁ ⊓ g₂) = f ×ˢ g₁ ⊓ f ×ˢ g₂
-- Filter.prod_principal_principal
@[simp]
theorem prod_principal_principal {s : Set α} {t : Set β} : 𝓟 s ×ˢ 𝓟 t = 𝓟 (s ×ˢ t) 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β}
Goal: 𝓟 s ×ˢ 𝓟 t = 𝓟 (s ×ˢ t)
-- Filter.pure_prod
@[simp]
theorem pure_prod {a : α} {f : Filter β} : pure a ×ˢ f = map (Prod.mk a) f 
Arguments: {α : Type u_1} {β : Type u_2} {a : α} {f : Filter β}
Goal: pure a ×ˢ f = Filter.map (Prod.mk a) f
-- Filter.map_pure_prod
theorem map_pure_prod (f : α → β → γ) (a : α) (B : Filter β) :
    map (Function.uncurry f) (pure a ×ˢ B) = map (f a) B 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β → γ) (a : α) (B : Filter β)
Goal: Filter.map (Function.uncurry f) (pure a ×ˢ B) = Filter.map (f a) B
-- Filter.prod_pure
@[simp]
theorem prod_pure {b : β} : f ×ˢ pure b = map (fun a => (a, b)) f 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {b : β}
Goal: f ×ˢ pure b = Filter.map (fun a => (a, b)) f
-- Filter.prod_pure_pure
theorem prod_pure_pure {a : α} {b : β} :
    (pure a : Filter α) ×ˢ (pure b : Filter β) = pure (a, b) 
Arguments: {α : Type u_1} {β : Type u_2} {a : α} {b : β}
Goal: pure a ×ˢ pure b = pure (a, b)
-- Filter.prod_eq_bot
@[simp]
theorem prod_eq_bot : f ×ˢ g = ⊥ ↔ f = ⊥ ∨ g = ⊥ 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β}
Goal: f ×ˢ g = ⊥ ↔ f = ⊥ ∨ g = ⊥
-- Filter.prod_bot
@[simp] theorem prod_bot : f ×ˢ (⊥ : Filter β) = ⊥ 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α}
Goal: f ×ˢ ⊥ = ⊥
-- Filter.bot_prod
@[simp] theorem bot_prod : (⊥ : Filter α) ×ˢ g = ⊥ 
Arguments: {α : Type u_1} {β : Type u_2} {g : Filter β}
Goal: ⊥ ×ˢ g = ⊥
-- Filter.prod_neBot
theorem prod_neBot : NeBot (f ×ˢ g) ↔ NeBot f ∧ NeBot g 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β}
Goal: (f ×ˢ g).NeBot ↔ f.NeBot ∧ g.NeBot
-- Filter.NeBot.prod
protected theorem NeBot.prod (hf : NeBot f) (hg : NeBot g) : NeBot (f ×ˢ g) 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β} (hf : f.NeBot) (hg : g.NeBot)
Goal: (f ×ˢ g).NeBot
-- Filter.disjoint_prod
@[simp]
lemma disjoint_prod {f' : Filter α} {g' : Filter β} :
    Disjoint (f ×ˢ g) (f' ×ˢ g') ↔ Disjoint f f' ∨ Disjoint g g' 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β} {f' : Filter α} {g' : Filter β}
Goal: Disjoint (f ×ˢ g) (f' ×ˢ g') ↔ Disjoint f f' ∨ Disjoint g g'
-- Filter.frequently_prod_and
theorem frequently_prod_and {p : α → Prop} {q : β → Prop} :
    (∃ᶠ x in f ×ˢ g, p x.1 ∧ q x.2) ↔ (∃ᶠ a in f, p a) ∧ ∃ᶠ b in g, q b 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β} {p : α → Prop} {q : β → Prop}
Goal: (∃ᶠ (x : α × β) in f ×ˢ g, p x.1 ∧ q x.2) ↔ (∃ᶠ (a : α) in f, p a) ∧ ∃ᶠ (b : β) in g, q b
-- Filter.tendsto_prod_iff
theorem tendsto_prod_iff {f : α × β → γ} {x : Filter α} {y : Filter β} {z : Filter γ} :
    Tendsto f (x ×ˢ y) z ↔ ∀ W ∈ z, ∃ U ∈ x, ∃ V ∈ y, ∀ x y, x ∈ U → y ∈ V → f (x, y) ∈ W 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α × β → γ} {x : Filter α} {y : Filter β} {z : Filter γ}
Goal: Filter.Tendsto f (x ×ˢ y) z ↔ ∀ W ∈ z, ∃ U ∈ x, ∃ V ∈ y, ∀ (x : α) (y : β), x ∈ U → y ∈ V → f (x, y) ∈ W
-- Filter.tendsto_prod_iff'
theorem tendsto_prod_iff' {g' : Filter γ} {s : α → β × γ} :
    Tendsto s f (g ×ˢ g') ↔ Tendsto (fun n => (s n).1) f g ∧ Tendsto (fun n => (s n).2) f g' 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {g : Filter β} {g' : Filter γ} {s : α → β × γ}
Goal: Filter.Tendsto s f (g ×ˢ g') ↔ Filter.Tendsto (fun n => (s n).1) f g ∧ Filter.Tendsto (fun n => (s n).2) f g'
-- Filter.le_prod
theorem le_prod {f : Filter (α × β)} {g : Filter α} {g' : Filter β} :
    (f ≤ g ×ˢ g') ↔ Tendsto Prod.fst f g ∧ Tendsto Prod.snd f g' 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter (α × β)} {g : Filter α} {g' : Filter β}
Goal: f ≤ g ×ˢ g' ↔ Filter.Tendsto Prod.fst f g ∧ Filter.Tendsto Prod.snd f g'
-- Filter.coprod_eq_prod_top_sup_top_prod
theorem coprod_eq_prod_top_sup_top_prod (f : Filter α) (g : Filter β) :
    Filter.coprod f g = f ×ˢ ⊤ ⊔ ⊤ ×ˢ g 
Arguments: {α : Type u_1} {β : Type u_2} (f : Filter α) (g : Filter β)
Goal: f.coprod g = f ×ˢ ⊤ ⊔ ⊤ ×ˢ g
-- Filter.mem_coprod_iff
theorem mem_coprod_iff {s : Set (α × β)} {f : Filter α} {g : Filter β} :
    s ∈ f.coprod g ↔ (∃ t₁ ∈ f, Prod.fst ⁻¹' t₁ ⊆ s) ∧ ∃ t₂ ∈ g, Prod.snd ⁻¹' t₂ ⊆ s 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set (α × β)} {f : Filter α} {g : Filter β}
Goal: s ∈ f.coprod g ↔ (∃ t₁ ∈ f, Prod.fst ⁻¹' t₁ ⊆ s) ∧ ∃ t₂ ∈ g, Prod.snd ⁻¹' t₂ ⊆ s
-- Filter.bot_coprod
@[simp]
theorem bot_coprod (l : Filter β) : (⊥ : Filter α).coprod l = comap Prod.snd l 
Arguments: {α : Type u_1} {β : Type u_2} (l : Filter β)
Goal: ⊥.coprod l = Filter.comap Prod.snd l
-- Filter.coprod_bot
@[simp]
theorem coprod_bot (l : Filter α) : l.coprod (⊥ : Filter β) = comap Prod.fst l 
Arguments: {α : Type u_1} {β : Type u_2} (l : Filter α)
Goal: l.coprod ⊥ = Filter.comap Prod.fst l
-- Filter.bot_coprod_bot
theorem bot_coprod_bot : (⊥ : Filter α).coprod (⊥ : Filter β) = ⊥ 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: ⊥.coprod ⊥ = ⊥
-- Filter.compl_mem_coprod
theorem compl_mem_coprod {s : Set (α × β)} {la : Filter α} {lb : Filter β} :
    sᶜ ∈ la.coprod lb ↔ (Prod.fst '' s)ᶜ ∈ la ∧ (Prod.snd '' s)ᶜ ∈ lb 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set (α × β)} {la : Filter α} {lb : Filter β}
Goal: sᶜ ∈ la.coprod lb ↔ (Prod.fst '' s)ᶜ ∈ la ∧ (Prod.snd '' s)ᶜ ∈ lb
-- Filter.coprod_mono
@[mono]
theorem coprod_mono {f₁ f₂ : Filter α} {g₁ g₂ : Filter β} (hf : f₁ ≤ f₂) (hg : g₁ ≤ g₂) :
    f₁.coprod g₁ ≤ f₂.coprod g₂ 
Arguments: {α : Type u_1} {β : Type u_2} {f₁ f₂ : Filter α} {g₁ g₂ : Filter β} (hf : f₁ ≤ f₂) (hg : g₁ ≤ g₂)
Goal: f₁.coprod g₁ ≤ f₂.coprod g₂
-- Filter.coprod_neBot_iff
theorem coprod_neBot_iff : (f.coprod g).NeBot ↔ f.NeBot ∧ Nonempty β ∨ Nonempty α ∧ g.NeBot 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β}
Goal: (f.coprod g).NeBot ↔ f.NeBot ∧ Nonempty β ∨ Nonempty α ∧ g.NeBot
-- Filter.coprod_neBot_left
@[instance]
theorem coprod_neBot_left [NeBot f] [Nonempty β] : (f.coprod g).NeBot 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β} [f.NeBot] [Nonempty β]
Goal: (f.coprod g).NeBot
-- Filter.coprod_neBot_right
@[instance]
theorem coprod_neBot_right [NeBot g] [Nonempty α] : (f.coprod g).NeBot 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β} [g.NeBot] [Nonempty α]
Goal: (f.coprod g).NeBot
-- Filter.principal_coprod_principal
theorem principal_coprod_principal (s : Set α) (t : Set β) :
    (𝓟 s).coprod (𝓟 t) = 𝓟 (sᶜ ×ˢ tᶜ)ᶜ 
Arguments: {α : Type u_1} {β : Type u_2} (s : Set α) (t : Set β)
Goal: (𝓟 s).coprod (𝓟 t) = 𝓟 (sᶜ ×ˢ tᶜ)ᶜ
-- Filter.map_prod_map_coprod_le
theorem map_prod_map_coprod_le.{u, v, w, x} {α₁ : Type u} {α₂ : Type v} {β₁ : Type w} {β₂ : Type x}
    {f₁ : Filter α₁} {f₂ : Filter α₂} {m₁ : α₁ → β₁} {m₂ : α₂ → β₂} :
    map (Prod.map m₁ m₂) (f₁.coprod f₂) ≤ (map m₁ f₁).coprod (map m₂ f₂) 
Arguments: {α₁ : Type u} {α₂ : Type v} {β₁ : Type w} {β₂ : Type x} {f₁ : Filter α₁} {f₂ : Filter α₂} {m₁ : α₁ → β₁} {m₂ : α₂ → β₂}
Goal: Filter.map (Prod.map m₁ m₂) (f₁.coprod f₂) ≤ (Filter.map m₁ f₁).coprod (Filter.map m₂ f₂)
-- Filter.map_const_principal_coprod_map_id_principal
theorem map_const_principal_coprod_map_id_principal {α β ι : Type*} (a : α) (b : β) (i : ι) :
    (map (fun _ => b) (𝓟 {a})).coprod (map id (𝓟 {i})) =
      𝓟 ((({b} : Set β) ×ˢ univ) ∪ (univ ×ˢ ({i} : Set ι))) 
Arguments: {α : Type u_6} {β : Type u_7} {ι : Type u_8} (a : α) (b : β) (i : ι)
Goal: (Filter.map (fun x => b) (𝓟 {a})).coprod (Filter.map id (𝓟 {i})) = 𝓟 ({b} ×ˢ Set.univ ∪ Set.univ ×ˢ {i})
-- Filter.map_prod_map_const_id_principal_coprod_principal
theorem map_prod_map_const_id_principal_coprod_principal {α β ι : Type*} (a : α) (b : β) (i : ι) :
    map (Prod.map (fun _ : α => b) id) ((𝓟 {a}).coprod (𝓟 {i})) =
      𝓟 (({b} : Set β) ×ˢ (univ : Set ι)) 
Arguments: {α : Type u_6} {β : Type u_7} {ι : Type u_8} (a : α) (b : β) (i : ι)
Goal: Filter.map (Prod.map (fun x => b) id) ((𝓟 {a}).coprod (𝓟 {i})) = 𝓟 ({b} ×ˢ Set.univ)
-- Filter.Tendsto.prod_map_coprod
theorem Tendsto.prod_map_coprod {δ : Type*} {f : α → γ} {g : β → δ} {a : Filter α} {b : Filter β}
    {c : Filter γ} {d : Filter δ} (hf : Tendsto f a c) (hg : Tendsto g b d) :
    Tendsto (Prod.map f g) (a.coprod b) (c.coprod d) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_6} {f : α → γ} {g : β → δ} {a : Filter α} {b : Filter β} {c : Filter γ} {d : Filter δ} (hf : Filter.Tendsto f a c) (hg : Filter.Tendsto g b d)
Goal: Filter.Tendsto (Prod.map f g) (a.coprod b) (c.coprod d)
-- Filter.TendstoIxxClass.tendsto_Ixx
class TendstoIxxClass (Ixx : α → α → Set α) (l₁ : Filter α) (l₂ : outParam <| Filter α) : Prop where
    tendsto_Ixx : Tendsto (fun p : α × α => Ixx p.1 p.2) (l₁ ×ˢ l₁) l₂.smallSets
Arguments: {α : Type u_1} {Ixx : α → α → Set α} {l₁ : Filter α} {l₂ : outParam (Filter α)} [self : Filter.TendstoIxxClass Ixx l₁ l₂]
Goal: Filter.Tendsto (fun p => Ixx p.1 p.2) (l₁ ×ˢ l₁) (Filter.smallSets l₂)
-- Filter.Tendsto.Icc
protected theorem Tendsto.Icc {l₁ l₂ : Filter α} [TendstoIxxClass Icc l₁ l₂] {lb : Filter β}
    {u₁ u₂ : β → α} (h₁ : Tendsto u₁ lb l₁) (h₂ : Tendsto u₂ lb l₁) :
    Tendsto (fun x => Icc (u₁ x) (u₂ x)) lb l₂.smallSets 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] {l₁ l₂ : Filter α} [Filter.TendstoIxxClass Set.Icc l₁ l₂] {lb : Filter β} {u₁ u₂ : β → α} (h₁ : Filter.Tendsto u₁ lb l₁) (h₂ : Filter.Tendsto u₂ lb l₁)
Goal: Filter.Tendsto (fun x => Set.Icc (u₁ x) (u₂ x)) lb l₂.smallSets
-- Filter.Tendsto.Ioc
protected theorem Tendsto.Ioc {l₁ l₂ : Filter α} [TendstoIxxClass Ioc l₁ l₂] {lb : Filter β}
    {u₁ u₂ : β → α} (h₁ : Tendsto u₁ lb l₁) (h₂ : Tendsto u₂ lb l₁) :
    Tendsto (fun x => Ioc (u₁ x) (u₂ x)) lb l₂.smallSets 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] {l₁ l₂ : Filter α} [Filter.TendstoIxxClass Set.Ioc l₁ l₂] {lb : Filter β} {u₁ u₂ : β → α} (h₁ : Filter.Tendsto u₁ lb l₁) (h₂ : Filter.Tendsto u₂ lb l₁)
Goal: Filter.Tendsto (fun x => Set.Ioc (u₁ x) (u₂ x)) lb l₂.smallSets
-- Filter.Tendsto.Ico
protected theorem Tendsto.Ico {l₁ l₂ : Filter α} [TendstoIxxClass Ico l₁ l₂] {lb : Filter β}
    {u₁ u₂ : β → α} (h₁ : Tendsto u₁ lb l₁) (h₂ : Tendsto u₂ lb l₁) :
    Tendsto (fun x => Ico (u₁ x) (u₂ x)) lb l₂.smallSets 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] {l₁ l₂ : Filter α} [Filter.TendstoIxxClass Set.Ico l₁ l₂] {lb : Filter β} {u₁ u₂ : β → α} (h₁ : Filter.Tendsto u₁ lb l₁) (h₂ : Filter.Tendsto u₂ lb l₁)
Goal: Filter.Tendsto (fun x => Set.Ico (u₁ x) (u₂ x)) lb l₂.smallSets
-- Filter.Tendsto.Ioo
protected theorem Tendsto.Ioo {l₁ l₂ : Filter α} [TendstoIxxClass Ioo l₁ l₂] {lb : Filter β}
    {u₁ u₂ : β → α} (h₁ : Tendsto u₁ lb l₁) (h₂ : Tendsto u₂ lb l₁) :
    Tendsto (fun x => Ioo (u₁ x) (u₂ x)) lb l₂.smallSets 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] {l₁ l₂ : Filter α} [Filter.TendstoIxxClass Set.Ioo l₁ l₂] {lb : Filter β} {u₁ u₂ : β → α} (h₁ : Filter.Tendsto u₁ lb l₁) (h₂ : Filter.Tendsto u₂ lb l₁)
Goal: Filter.Tendsto (fun x => Set.Ioo (u₁ x) (u₂ x)) lb l₂.smallSets
-- Filter.tendstoIxxClass_principal
theorem tendstoIxxClass_principal {s t : Set α} {Ixx : α → α → Set α} :
    TendstoIxxClass Ixx (𝓟 s) (𝓟 t) ↔ ∀ᵉ (x ∈ s) (y ∈ s), Ixx x y ⊆ t 
Arguments: {α : Type u_1} {s t : Set α} {Ixx : α → α → Set α}
Goal: Filter.TendstoIxxClass Ixx (𝓟 s) (𝓟 t) ↔ ∀ x ∈ s, ∀ y ∈ s, Ixx x y ⊆ t
-- Filter.tendstoIxxClass_inf
theorem tendstoIxxClass_inf {l₁ l₁' l₂ l₂' : Filter α} {Ixx} [h : TendstoIxxClass Ixx l₁ l₂]
    [h' : TendstoIxxClass Ixx l₁' l₂'] : TendstoIxxClass Ixx (l₁ ⊓ l₁') (l₂ ⊓ l₂') 
Arguments: {α : Type u_1} {l₁ l₁' l₂ l₂' : Filter α} {Ixx : α → α → Set α} [h : Filter.TendstoIxxClass Ixx l₁ l₂] [h' : Filter.TendstoIxxClass Ixx l₁' l₂']
Goal: Filter.TendstoIxxClass Ixx (l₁ ⊓ l₁') (l₂ ⊓ l₂')
-- Filter.tendstoIxxClass_of_subset
theorem tendstoIxxClass_of_subset {l₁ l₂ : Filter α} {Ixx Ixx' : α → α → Set α}
    (h : ∀ a b, Ixx a b ⊆ Ixx' a b) [h' : TendstoIxxClass Ixx' l₁ l₂] : TendstoIxxClass Ixx l₁ l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : Filter α} {Ixx Ixx' : α → α → Set α} (h : ∀ (a b : α), Ixx a b ⊆ Ixx' a b) [h' : Filter.TendstoIxxClass Ixx' l₁ l₂]
Goal: Filter.TendstoIxxClass Ixx l₁ l₂
-- Filter.HasBasis.tendstoIxxClass
theorem HasBasis.tendstoIxxClass {ι : Type*} {p : ι → Prop} {s} {l : Filter α}
    (hl : l.HasBasis p s) {Ixx : α → α → Set α}
    (H : ∀ i, p i → ∀ x ∈ s i, ∀ y ∈ s i, Ixx x y ⊆ s i) : TendstoIxxClass Ixx l l 
Arguments: {α : Type u_1} {ι : Type u_3} {p : ι → Prop} {s : ι → Set α} {l : Filter α} (hl : l.HasBasis p s) {Ixx : α → α → Set α} (H : ∀ (i : ι), p i → ∀ x ∈ s i, ∀ y ∈ s i, Ixx x y ⊆ s i)
Goal: Filter.TendstoIxxClass Ixx l l
-- Filter.Tendsto.uIcc
protected theorem Tendsto.uIcc {l : Filter α} [TendstoIxxClass Icc l l] {f g : β → α}
    {lb : Filter β} (hf : Tendsto f lb l) (hg : Tendsto g lb l) :
    Tendsto (fun x => [[f x, g x]]) lb l.smallSets 
Arguments: {α : Type u_1} {β : Type u_2} [LinearOrder α] {l : Filter α} [Filter.TendstoIxxClass Set.Icc l l] {f g : β → α} {lb : Filter β} (hf : Filter.Tendsto f lb l) (hg : Filter.Tendsto g lb l)
Goal: Filter.Tendsto (fun x => Set.uIcc (f x) (g x)) lb l.smallSets
-- IsExtrOn.elim
theorem IsExtrOn.elim {p : Prop} : IsExtrOn f s a → (IsMinOn f s a → p) → (IsMaxOn f s a → p) → p 
Arguments: {α : Type u} {β : Type v} [Preorder β] {f : α → β} {s : Set α} {a : α} {p : Prop}
Goal: IsExtrOn f s a → (IsMinOn f s a → p) → (IsMaxOn f s a → p) → p
-- isMinOn_iff
theorem isMinOn_iff : IsMinOn f s a ↔ ∀ x ∈ s, f a ≤ f x 
Arguments: {α : Type u} {β : Type v} [Preorder β] {f : α → β} {s : Set α} {a : α}
Goal: IsMinOn f s a ↔ ∀ x ∈ s, f a ≤ f x
-- isMaxOn_iff
theorem isMaxOn_iff : IsMaxOn f s a ↔ ∀ x ∈ s, f x ≤ f a 
Arguments: {α : Type u} {β : Type v} [Preorder β] {f : α → β} {s : Set α} {a : α}
Goal: IsMaxOn f s a ↔ ∀ x ∈ s, f x ≤ f a
-- isMinOn_univ_iff
theorem isMinOn_univ_iff : IsMinOn f univ a ↔ ∀ x, f a ≤ f x 
Arguments: {α : Type u} {β : Type v} [Preorder β] {f : α → β} {a : α}
Goal: IsMinOn f Set.univ a ↔ ∀ (x : α), f a ≤ f x
-- isMaxOn_univ_iff
theorem isMaxOn_univ_iff : IsMaxOn f univ a ↔ ∀ x, f x ≤ f a 
Arguments: {α : Type u} {β : Type v} [Preorder β] {f : α → β} {a : α}
Goal: IsMaxOn f Set.univ a ↔ ∀ (x : α), f x ≤ f a
-- IsMinFilter.tendsto_principal_Ici
theorem IsMinFilter.tendsto_principal_Ici (h : IsMinFilter f l a) : Tendsto f l (𝓟 <| Ici (f a)) 
Arguments: {α : Type u} {β : Type v} [Preorder β] {f : α → β} {l : Filter α} {a : α} (h : IsMinFilter f l a)
Goal: Filter.Tendsto f l (𝓟 (Set.Ici (f a)))
-- IsMaxFilter.tendsto_principal_Iic
theorem IsMaxFilter.tendsto_principal_Iic (h : IsMaxFilter f l a) : Tendsto f l (𝓟 <| Iic (f a)) 
Arguments: {α : Type u} {β : Type v} [Preorder β] {f : α → β} {l : Filter α} {a : α} (h : IsMaxFilter f l a)
Goal: Filter.Tendsto f l (𝓟 (Set.Iic (f a)))
-- IsMinFilter.isExtr
theorem IsMinFilter.isExtr : IsMinFilter f l a → IsExtrFilter f l a 
Arguments: {α : Type u} {β : Type v} [Preorder β] {f : α → β} {l : Filter α} {a : α}
Goal: IsMinFilter f l a → IsExtrFilter f l a
-- IsMaxFilter.isExtr
theorem IsMaxFilter.isExtr : IsMaxFilter f l a → IsExtrFilter f l a 
Arguments: {α : Type u} {β : Type v} [Preorder β] {f : α → β} {l : Filter α} {a : α}
Goal: IsMaxFilter f l a → IsExtrFilter f l a
-- IsMinOn.isExtr
theorem IsMinOn.isExtr (h : IsMinOn f s a) : IsExtrOn f s a 
Arguments: {α : Type u} {β : Type v} [Preorder β] {f : α → β} {s : Set α} {a : α} (h : IsMinOn f s a)
Goal: IsExtrOn f s a
-- IsMaxOn.isExtr
theorem IsMaxOn.isExtr (h : IsMaxOn f s a) : IsExtrOn f s a 
Arguments: {α : Type u} {β : Type v} [Preorder β] {f : α → β} {s : Set α} {a : α} (h : IsMaxOn f s a)
Goal: IsExtrOn f s a
-- isMinFilter_const
theorem isMinFilter_const {b : β} : IsMinFilter (fun _ => b) l a 
Arguments: {α : Type u} {β : Type v} [Preorder β] {l : Filter α} {a : α} {b : β}
Goal: IsMinFilter (fun x => b) l a
-- isMaxFilter_const
theorem isMaxFilter_const {b : β} : IsMaxFilter (fun _ => b) l a 
Arguments: {α : Type u} {β : Type v} [Preorder β] {l : Filter α} {a : α} {b : β}
Goal: IsMaxFilter (fun x => b) l a
-- isExtrFilter_const
theorem isExtrFilter_const {b : β} : IsExtrFilter (fun _ => b) l a 
Arguments: {α : Type u} {β : Type v} [Preorder β] {l : Filter α} {a : α} {b : β}
Goal: IsExtrFilter (fun x => b) l a
-- isMinOn_const
theorem isMinOn_const {b : β} : IsMinOn (fun _ => b) s a 
Arguments: {α : Type u} {β : Type v} [Preorder β] {s : Set α} {a : α} {b : β}
Goal: IsMinOn (fun x => b) s a
-- isMaxOn_const
theorem isMaxOn_const {b : β} : IsMaxOn (fun _ => b) s a 
Arguments: {α : Type u} {β : Type v} [Preorder β] {s : Set α} {a : α} {b : β}
Goal: IsMaxOn (fun x => b) s a
-- isExtrOn_const
theorem isExtrOn_const {b : β} : IsExtrOn (fun _ => b) s a 
Arguments: {α : Type u} {β : Type v} [Preorder β] {s : Set α} {a : α} {b : β}
Goal: IsExtrOn (fun x => b) s a
-- isMinFilter_dual_iff
theorem isMinFilter_dual_iff : IsMinFilter (toDual ∘ f) l a ↔ IsMaxFilter f l a 
Arguments: {α : Type u} {β : Type v} [Preorder β] {f : α → β} {l : Filter α} {a : α}
Goal: IsMinFilter (⇑OrderDual.toDual ∘ f) l a ↔ IsMaxFilter f l a
-- isMaxFilter_dual_iff
theorem isMaxFilter_dual_iff : IsMaxFilter (toDual ∘ f) l a ↔ IsMinFilter f l a 
Arguments: {α : Type u} {β : Type v} [Preorder β] {f : α → β} {l : Filter α} {a : α}
Goal: IsMaxFilter (⇑OrderDual.toDual ∘ f) l a ↔ IsMinFilter f l a
-- isExtrFilter_dual_iff
theorem isExtrFilter_dual_iff : IsExtrFilter (toDual ∘ f) l a ↔ IsExtrFilter f l a 
Arguments: {α : Type u} {β : Type v} [Preorder β] {f : α → β} {l : Filter α} {a : α}
Goal: IsExtrFilter (⇑OrderDual.toDual ∘ f) l a ↔ IsExtrFilter f l a
-- isMinOn_dual_iff
theorem isMinOn_dual_iff : IsMinOn (toDual ∘ f) s a ↔ IsMaxOn f s a 
Arguments: {α : Type u} {β : Type v} [Preorder β] {f : α → β} {s : Set α} {a : α}
Goal: IsMinOn (⇑OrderDual.toDual ∘ f) s a ↔ IsMaxOn f s a
-- isMaxOn_dual_iff
theorem isMaxOn_dual_iff : IsMaxOn (toDual ∘ f) s a ↔ IsMinOn f s a 
Arguments: {α : Type u} {β : Type v} [Preorder β] {f : α → β} {s : Set α} {a : α}
Goal: IsMaxOn (⇑OrderDual.toDual ∘ f) s a ↔ IsMinOn f s a
-- isExtrOn_dual_iff
theorem isExtrOn_dual_iff : IsExtrOn (toDual ∘ f) s a ↔ IsExtrOn f s a 
Arguments: {α : Type u} {β : Type v} [Preorder β] {f : α → β} {s : Set α} {a : α}
Goal: IsExtrOn (⇑OrderDual.toDual ∘ f) s a ↔ IsExtrOn f s a
-- IsMinFilter.filter_mono
theorem IsMinFilter.filter_mono (h : IsMinFilter f l a) (hl : l' ≤ l) : IsMinFilter f l' a 
Arguments: {α : Type u} {β : Type v} [Preorder β] {f : α → β} {l : Filter α} {a : α} {l' : Filter α} (h : IsMinFilter f l a) (hl : l' ≤ l)
Goal: IsMinFilter f l' a
-- IsMaxFilter.filter_mono
theorem IsMaxFilter.filter_mono (h : IsMaxFilter f l a) (hl : l' ≤ l) : IsMaxFilter f l' a 
Arguments: {α : Type u} {β : Type v} [Preorder β] {f : α → β} {l : Filter α} {a : α} {l' : Filter α} (h : IsMaxFilter f l a) (hl : l' ≤ l)
Goal: IsMaxFilter f l' a
-- IsExtrFilter.filter_mono
theorem IsExtrFilter.filter_mono (h : IsExtrFilter f l a) (hl : l' ≤ l) : IsExtrFilter f l' a 
Arguments: {α : Type u} {β : Type v} [Preorder β] {f : α → β} {l : Filter α} {a : α} {l' : Filter α} (h : IsExtrFilter f l a) (hl : l' ≤ l)
Goal: IsExtrFilter f l' a
-- IsMinFilter.filter_inf
theorem IsMinFilter.filter_inf (h : IsMinFilter f l a) (l') : IsMinFilter f (l ⊓ l') a 
Arguments: {α : Type u} {β : Type v} [Preorder β] {f : α → β} {l : Filter α} {a : α} (h : IsMinFilter f l a) (l' : Filter α)
Goal: IsMinFilter f (l ⊓ l') a
-- IsMaxFilter.filter_inf
theorem IsMaxFilter.filter_inf (h : IsMaxFilter f l a) (l') : IsMaxFilter f (l ⊓ l') a 
Arguments: {α : Type u} {β : Type v} [Preorder β] {f : α → β} {l : Filter α} {a : α} (h : IsMaxFilter f l a) (l' : Filter α)
Goal: IsMaxFilter f (l ⊓ l') a
-- IsExtrFilter.filter_inf
theorem IsExtrFilter.filter_inf (h : IsExtrFilter f l a) (l') : IsExtrFilter f (l ⊓ l') a 
Arguments: {α : Type u} {β : Type v} [Preorder β] {f : α → β} {l : Filter α} {a : α} (h : IsExtrFilter f l a) (l' : Filter α)
Goal: IsExtrFilter f (l ⊓ l') a
-- IsMinOn.on_subset
theorem IsMinOn.on_subset (hf : IsMinOn f t a) (h : s ⊆ t) : IsMinOn f s a 
Arguments: {α : Type u} {β : Type v} [Preorder β] {f : α → β} {s : Set α} {a : α} {t : Set α} (hf : IsMinOn f t a) (h : s ⊆ t)
Goal: IsMinOn f s a