File: Mathlib/Order/Filter/Prod.lean

full_name: Filter.prod
code: /-- Product of filters. This is the filter generated by cartesian products
of elements of the component filters. -/
protected def prod (f : Filter α) (g : Filter β) : Filter (α × β) 
goal: Filter (α × β)

full_name: Filter.instSProd
code: instance instSProd : SProd (Filter α) (Filter β) (Filter (α × β)) 
goal: SProd (Filter α) (Filter β) (Filter (α × β))

full_name: Filter.prod_mem_prod
code: theorem prod_mem_prod (hs : s ∈ f) (ht : t ∈ g) : s ×ˢ t ∈ f ×ˢ g 
goal: s ×ˢ t ∈ f ×ˢ g

full_name: Filter.mem_prod_iff
code: theorem mem_prod_iff {s : Set (α × β)} {f : Filter α} {g : Filter β} :
    s ∈ f ×ˢ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ ×ˢ t₂ ⊆ s 
goal: s ∈ f ×ˢ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ ×ˢ t₂ ⊆ s

full_name: Filter.prod_mem_prod_iff
code: @[simp]
theorem prod_mem_prod_iff [f.NeBot] [g.NeBot] : s ×ˢ t ∈ f ×ˢ g ↔ s ∈ f ∧ t ∈ g 
goal: s ×ˢ t ∈ f ×ˢ g ↔ s ∈ f ∧ t ∈ g

full_name: Filter.mem_prod_principal
code: theorem mem_prod_principal {s : Set (α × β)} :
    s ∈ f ×ˢ 𝓟 t ↔ { a | ∀ b ∈ t, (a, b) ∈ s } ∈ f 
goal: s ∈ f ×ˢ 𝓟 t ↔ {a | ∀ b ∈ t, (a, b) ∈ s} ∈ f

full_name: Filter.mem_prod_top
code: theorem mem_prod_top {s : Set (α × β)} :
    s ∈ f ×ˢ (⊤ : Filter β) ↔ { a | ∀ b, (a, b) ∈ s } ∈ f 
goal: s ∈ f ×ˢ ⊤ ↔ {a | ∀ (b : β), (a, b) ∈ s} ∈ f

full_name: Filter.eventually_prod_principal_iff
code: theorem eventually_prod_principal_iff {p : α × β → Prop} {s : Set β} :
    (∀ᶠ x : α × β in f ×ˢ 𝓟 s, p x) ↔ ∀ᶠ x : α in f, ∀ y : β, y ∈ s → p (x, y) 
goal: (∀ᶠ (x : α × β) in f ×ˢ 𝓟 s, p x) ↔ ∀ᶠ (x : α) in f, ∀ y ∈ s, p (x, y)

full_name: Filter.comap_prod
code: theorem comap_prod (f : α → β × γ) (b : Filter β) (c : Filter γ) :
    comap f (b ×ˢ c) = comap (Prod.fst ∘ f) b ⊓ comap (Prod.snd ∘ f) c 
goal: Filter.comap f (b ×ˢ c) = Filter.comap (Prod.fst ∘ f) b ⊓ Filter.comap (Prod.snd ∘ f) c

full_name: Filter.prod_top
code: theorem prod_top : f ×ˢ (⊤ : Filter β) = f.comap Prod.fst 
goal: f ×ˢ ⊤ = Filter.comap Prod.fst f

full_name: Filter.top_prod
code: theorem top_prod : (⊤ : Filter α) ×ˢ g = g.comap Prod.snd 
goal: ⊤ ×ˢ g = Filter.comap Prod.snd g

full_name: Filter.sup_prod
code: theorem sup_prod (f₁ f₂ : Filter α) (g : Filter β) : (f₁ ⊔ f₂) ×ˢ g = (f₁ ×ˢ g) ⊔ (f₂ ×ˢ g) 
goal: (f₁ ⊔ f₂) ×ˢ g = f₁ ×ˢ g ⊔ f₂ ×ˢ g

full_name: Filter.prod_sup
code: theorem prod_sup (f : Filter α) (g₁ g₂ : Filter β) : f ×ˢ (g₁ ⊔ g₂) = (f ×ˢ g₁) ⊔ (f ×ˢ g₂) 
goal: f ×ˢ (g₁ ⊔ g₂) = f ×ˢ g₁ ⊔ f ×ˢ g₂

full_name: Filter.eventually_prod_iff
code: theorem eventually_prod_iff {p : α × β → Prop} :
    (∀ᶠ x in f ×ˢ g, p x) ↔
      ∃ pa : α → Prop, (∀ᶠ x in f, pa x) ∧ ∃ pb : β → Prop, (∀ᶠ y in g, pb y) ∧
        ∀ {x}, pa x → ∀ {y}, pb y → p (x, y) 
goal: (∀ᶠ (x : α × β) in f ×ˢ g, p x) ↔
  ∃ pa, (∀ᶠ (x : α) in f, pa x) ∧ ∃ pb, (∀ᶠ (y : β) in g, pb y) ∧ ∀ {x : α}, pa x → ∀ {y : β}, pb y → p (x, y)

full_name: Filter.tendsto_fst
code: theorem tendsto_fst : Tendsto Prod.fst (f ×ˢ g) f 
goal: Filter.Tendsto Prod.fst (f ×ˢ g) f

full_name: Filter.tendsto_snd
code: theorem tendsto_snd : Tendsto Prod.snd (f ×ˢ g) g 
goal: Filter.Tendsto Prod.snd (f ×ˢ g) g

full_name: Filter.Tendsto.fst
code: /-- If a function tends to a product `g ×ˢ h` of filters, then its first component tends to
`g`. See also `Filter.Tendsto.fst_nhds` for the special case of converging to a point in a
product of two topological spaces. -/
theorem Tendsto.fst {h : Filter γ} {m : α → β × γ} (H : Tendsto m f (g ×ˢ h)) :
    Tendsto (fun a ↦ (m a).1) f g 
goal: Filter.Tendsto (fun a => (m a).1) f g

full_name: Filter.Tendsto.snd
code: /-- If a function tends to a product `g ×ˢ h` of filters, then its second component tends to
`h`. See also `Filter.Tendsto.snd_nhds` for the special case of converging to a point in a
product of two topological spaces. -/
theorem Tendsto.snd {h : Filter γ} {m : α → β × γ} (H : Tendsto m f (g ×ˢ h)) :
    Tendsto (fun a ↦ (m a).2) f h 
goal: Filter.Tendsto (fun a => (m a).2) f h

full_name: Filter.Tendsto.prod_mk
code: theorem Tendsto.prod_mk {h : Filter γ} {m₁ : α → β} {m₂ : α → γ}
    (h₁ : Tendsto m₁ f g) (h₂ : Tendsto m₂ f h) : Tendsto (fun x => (m₁ x, m₂ x)) f (g ×ˢ h) 
goal: Filter.Tendsto (fun x => (m₁ x, m₂ x)) f (g ×ˢ h)

full_name: Filter.tendsto_prod_swap
code: theorem tendsto_prod_swap : Tendsto (Prod.swap : α × β → β × α) (f ×ˢ g) (g ×ˢ f) 
goal: Filter.Tendsto Prod.swap (f ×ˢ g) (g ×ˢ f)

full_name: Filter.Eventually.prod_inl
code: theorem Eventually.prod_inl {la : Filter α} {p : α → Prop} (h : ∀ᶠ x in la, p x) (lb : Filter β) :
    ∀ᶠ x in la ×ˢ lb, p (x : α × β).1 
goal: ∀ᶠ (x : α × β) in la ×ˢ lb, p x.1

full_name: Filter.Eventually.prod_inr
code: theorem Eventually.prod_inr {lb : Filter β} {p : β → Prop} (h : ∀ᶠ x in lb, p x) (la : Filter α) :
    ∀ᶠ x in la ×ˢ lb, p (x : α × β).2 
goal: ∀ᶠ (x : α × β) in la ×ˢ lb, p x.2

full_name: Filter.Eventually.prod_mk
code: theorem Eventually.prod_mk {la : Filter α} {pa : α → Prop} (ha : ∀ᶠ x in la, pa x) {lb : Filter β}
    {pb : β → Prop} (hb : ∀ᶠ y in lb, pb y) : ∀ᶠ p in la ×ˢ lb, pa (p : α × β).1 ∧ pb p.2 
goal: ∀ᶠ (p : α × β) in la ×ˢ lb, pa p.1 ∧ pb p.2

full_name: Filter.EventuallyEq.prod_map
code: theorem EventuallyEq.prod_map {δ} {la : Filter α} {fa ga : α → γ} (ha : fa =ᶠ[la] ga)
    {lb : Filter β} {fb gb : β → δ} (hb : fb =ᶠ[lb] gb) :
    Prod.map fa fb =ᶠ[la ×ˢ lb] Prod.map ga gb 
goal: Prod.map fa fb =ᶠ[la ×ˢ lb] Prod.map ga gb

full_name: Filter.EventuallyLE.prod_map
code: theorem EventuallyLE.prod_map {δ} [LE γ] [LE δ] {la : Filter α} {fa ga : α → γ} (ha : fa ≤ᶠ[la] ga)
    {lb : Filter β} {fb gb : β → δ} (hb : fb ≤ᶠ[lb] gb) :
    Prod.map fa fb ≤ᶠ[la ×ˢ lb] Prod.map ga gb 
goal: Prod.map fa fb ≤ᶠ[la ×ˢ lb] Prod.map ga gb

full_name: Filter.Eventually.curry
code: theorem Eventually.curry {la : Filter α} {lb : Filter β} {p : α × β → Prop}
    (h : ∀ᶠ x in la ×ˢ lb, p x) : ∀ᶠ x in la, ∀ᶠ y in lb, p (x, y) 
goal: ∀ᶠ (x : α) in la, ∀ᶠ (y : β) in lb, p (x, y)

full_name: Filter.Frequently.uncurry
code: protected lemma Frequently.uncurry {la : Filter α} {lb : Filter β} {p : α → β → Prop}
    (h : ∃ᶠ x in la, ∃ᶠ y in lb, p x y) : ∃ᶠ xy in la ×ˢ lb, p xy.1 xy.2 
goal: ∃ᶠ (xy : α × β) in la ×ˢ lb, p xy.1 xy.2

full_name: Filter.Eventually.diag_of_prod
code: /-- A fact that is eventually true about all pairs `l ×ˢ l` is eventually true about
all diagonal pairs `(i, i)` -/
theorem Eventually.diag_of_prod {p : α × α → Prop} (h : ∀ᶠ i in f ×ˢ f, p i) :
    ∀ᶠ i in f, p (i, i) 
goal: ∀ᶠ (i : α) in f, p (i, i)

full_name: Filter.Eventually.diag_of_prod_left
code: theorem Eventually.diag_of_prod_left {f : Filter α} {g : Filter γ} {p : (α × α) × γ → Prop} :
    (∀ᶠ x in (f ×ˢ f) ×ˢ g, p x) → ∀ᶠ x : α × γ in f ×ˢ g, p ((x.1, x.1), x.2) 
goal: (∀ᶠ (x : (α × α) × γ) in (f ×ˢ f) ×ˢ g, p x) → ∀ᶠ (x : α × γ) in f ×ˢ g, p ((x.1, x.1), x.2)

full_name: Filter.Eventually.diag_of_prod_right
code: theorem Eventually.diag_of_prod_right {f : Filter α} {g : Filter γ} {p : α × γ × γ → Prop} :
    (∀ᶠ x in f ×ˢ (g ×ˢ g), p x) → ∀ᶠ x : α × γ in f ×ˢ g, p (x.1, x.2, x.2) 
goal: (∀ᶠ (x : α × γ × γ) in f ×ˢ g ×ˢ g, p x) → ∀ᶠ (x : α × γ) in f ×ˢ g, p (x.1, x.2, x.2)

full_name: Filter.tendsto_diag
code: theorem tendsto_diag : Tendsto (fun i => (i, i)) f (f ×ˢ f) 
goal: Filter.Tendsto (fun i => (i, i)) f (f ×ˢ f)

full_name: Filter.prod_iInf_left
code: theorem prod_iInf_left [Nonempty ι] {f : ι → Filter α} {g : Filter β} :
    (⨅ i, f i) ×ˢ g = ⨅ i, f i ×ˢ g 
goal: (⨅ i, f i) ×ˢ g = ⨅ i, f i ×ˢ g

full_name: Filter.prod_iInf_right
code: theorem prod_iInf_right [Nonempty ι] {f : Filter α} {g : ι → Filter β} :
    (f ×ˢ ⨅ i, g i) = ⨅ i, f ×ˢ g i 
goal: f ×ˢ ⨅ i, g i = ⨅ i, f ×ˢ g i

full_name: Filter.prod_mono
code: @[mono, gcongr]
theorem prod_mono {f₁ f₂ : Filter α} {g₁ g₂ : Filter β} (hf : f₁ ≤ f₂) (hg : g₁ ≤ g₂) :
    f₁ ×ˢ g₁ ≤ f₂ ×ˢ g₂ 
goal: f₁ ×ˢ g₁ ≤ f₂ ×ˢ g₂

full_name: Filter.prod_mono_left
code: @[gcongr]
theorem prod_mono_left (g : Filter β) {f₁ f₂ : Filter α} (hf : f₁ ≤ f₂) : f₁ ×ˢ g ≤ f₂ ×ˢ g 
goal: f₁ ×ˢ g ≤ f₂ ×ˢ g

full_name: Filter.prod_mono_right
code: @[gcongr]
theorem prod_mono_right (f : Filter α) {g₁ g₂ : Filter β} (hf : g₁ ≤ g₂) : f ×ˢ g₁ ≤ f ×ˢ g₂ 
goal: f ×ˢ g₁ ≤ f ×ˢ g₂

full_name: Filter.prod_comap_comap_eq
code: theorem prod_comap_comap_eq.{u, v, w, x} {α₁ : Type u} {α₂ : Type v} {β₁ : Type w} {β₂ : Type x}
    {f₁ : Filter α₁} {f₂ : Filter α₂} {m₁ : β₁ → α₁} {m₂ : β₂ → α₂} :
    comap m₁ f₁ ×ˢ comap m₂ f₂ = comap (fun p : β₁ × β₂ => (m₁ p.1, m₂ p.2)) (f₁ ×ˢ f₂) 
goal: Filter.comap m₁ f₁ ×ˢ Filter.comap m₂ f₂ = Filter.comap (fun p => (m₁ p.1, m₂ p.2)) (f₁ ×ˢ f₂)

full_name: Filter.prod_comm'
code: theorem prod_comm' : f ×ˢ g = comap Prod.swap (g ×ˢ f) 
goal: f ×ˢ g = Filter.comap Prod.swap (g ×ˢ f)

full_name: Filter.prod_comm
code: theorem prod_comm : f ×ˢ g = map (fun p : β × α => (p.2, p.1)) (g ×ˢ f) 
goal: f ×ˢ g = Filter.map (fun p => (p.2, p.1)) (g ×ˢ f)

full_name: Filter.mem_prod_iff_left
code: theorem mem_prod_iff_left {s : Set (α × β)} :
    s ∈ f ×ˢ g ↔ ∃ t ∈ f, ∀ᶠ y in g, ∀ x ∈ t, (x, y) ∈ s 
goal: s ∈ f ×ˢ g ↔ ∃ t ∈ f, ∀ᶠ (y : β) in g, ∀ x ∈ t, (x, y) ∈ s

full_name: Filter.mem_prod_iff_right
code: theorem mem_prod_iff_right {s : Set (α × β)} :
    s ∈ f ×ˢ g ↔ ∃ t ∈ g, ∀ᶠ x in f, ∀ y ∈ t, (x, y) ∈ s 
goal: s ∈ f ×ˢ g ↔ ∃ t ∈ g, ∀ᶠ (x : α) in f, ∀ y ∈ t, (x, y) ∈ s

full_name: Filter.map_fst_prod
code: @[simp]
theorem map_fst_prod (f : Filter α) (g : Filter β) [NeBot g] : map Prod.fst (f ×ˢ g) = f 
goal: Filter.map Prod.fst (f ×ˢ g) = f

full_name: Filter.map_snd_prod
code: @[simp]
theorem map_snd_prod (f : Filter α) (g : Filter β) [NeBot f] : map Prod.snd (f ×ˢ g) = g 
goal: Filter.map Prod.snd (f ×ˢ g) = g

full_name: Filter.prod_le_prod
code: @[simp]
theorem prod_le_prod {f₁ f₂ : Filter α} {g₁ g₂ : Filter β} [NeBot f₁] [NeBot g₁] :
    f₁ ×ˢ g₁ ≤ f₂ ×ˢ g₂ ↔ f₁ ≤ f₂ ∧ g₁ ≤ g₂ 
goal: f₁ ×ˢ g₁ ≤ f₂ ×ˢ g₂ ↔ f₁ ≤ f₂ ∧ g₁ ≤ g₂

full_name: Filter.prod_inj
code: @[simp]
theorem prod_inj {f₁ f₂ : Filter α} {g₁ g₂ : Filter β} [NeBot f₁] [NeBot g₁] :
    f₁ ×ˢ g₁ = f₂ ×ˢ g₂ ↔ f₁ = f₂ ∧ g₁ = g₂ 
goal: f₁ ×ˢ g₁ = f₂ ×ˢ g₂ ↔ f₁ = f₂ ∧ g₁ = g₂

full_name: Filter.eventually_swap_iff
code: theorem eventually_swap_iff {p : α × β → Prop} :
    (∀ᶠ x : α × β in f ×ˢ g, p x) ↔ ∀ᶠ y : β × α in g ×ˢ f, p y.swap 
goal: (∀ᶠ (x : α × β) in f ×ˢ g, p x) ↔ ∀ᶠ (y : β × α) in g ×ˢ f, p y.swap

full_name: Filter.prod_assoc
code: theorem prod_assoc (f : Filter α) (g : Filter β) (h : Filter γ) :
    map (Equiv.prodAssoc α β γ) ((f ×ˢ g) ×ˢ h) = f ×ˢ (g ×ˢ h) 
goal: Filter.map (⇑(Equiv.prodAssoc α β γ)) ((f ×ˢ g) ×ˢ h) = f ×ˢ g ×ˢ h

full_name: Filter.prod_assoc_symm
code: theorem prod_assoc_symm (f : Filter α) (g : Filter β) (h : Filter γ) :
    map (Equiv.prodAssoc α β γ).symm (f ×ˢ (g ×ˢ h)) = (f ×ˢ g) ×ˢ h 
goal: Filter.map (⇑(Equiv.prodAssoc α β γ).symm) (f ×ˢ g ×ˢ h) = (f ×ˢ g) ×ˢ h

full_name: Filter.tendsto_prodAssoc
code: theorem tendsto_prodAssoc {h : Filter γ} :
    Tendsto (Equiv.prodAssoc α β γ) ((f ×ˢ g) ×ˢ h) (f ×ˢ (g ×ˢ h)) 
goal: Filter.Tendsto (⇑(Equiv.prodAssoc α β γ)) ((f ×ˢ g) ×ˢ h) (f ×ˢ g ×ˢ h)

full_name: Filter.tendsto_prodAssoc_symm
code: theorem tendsto_prodAssoc_symm {h : Filter γ} :
    Tendsto (Equiv.prodAssoc α β γ).symm (f ×ˢ (g ×ˢ h)) ((f ×ˢ g) ×ˢ h) 
goal: Filter.Tendsto (⇑(Equiv.prodAssoc α β γ).symm) (f ×ˢ g ×ˢ h) ((f ×ˢ g) ×ˢ h)

full_name: Filter.map_swap4_prod
code: /-- A useful lemma when dealing with uniformities. -/
theorem map_swap4_prod {h : Filter γ} {k : Filter δ} :
    map (fun p : (α × β) × γ × δ => ((p.1.1, p.2.1), (p.1.2, p.2.2))) ((f ×ˢ g) ×ˢ (h ×ˢ k)) =
      (f ×ˢ h) ×ˢ (g ×ˢ k) 
goal: Filter.map (fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) ((f ×ˢ g) ×ˢ h ×ˢ k) = (f ×ˢ h) ×ˢ g ×ˢ k

full_name: Filter.tendsto_swap4_prod
code: 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)) 
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)

full_name: Filter.prod_map_map_eq
code: 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₂) 
goal: Filter.map m₁ f₁ ×ˢ Filter.map m₂ f₂ = Filter.map (fun p => (m₁ p.1, m₂ p.2)) (f₁ ×ˢ f₂)

full_name: Filter.prod_map_map_eq'
code: 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) 
goal: Filter.map f F ×ˢ Filter.map g G = Filter.map (Prod.map f g) (F ×ˢ G)

full_name: Filter.prod_map_left
code: theorem prod_map_left (f : α → β) (F : Filter α) (G : Filter γ) :
    map f F ×ˢ G = map (Prod.map f id) (F ×ˢ G) 
goal: Filter.map f F ×ˢ G = Filter.map (Prod.map f id) (F ×ˢ G)

full_name: Filter.prod_map_right
code: theorem prod_map_right (f : β → γ) (F : Filter α) (G : Filter β) :
    F ×ˢ map f G = map (Prod.map id f) (F ×ˢ G) 
goal: F ×ˢ Filter.map f G = Filter.map (Prod.map id f) (F ×ˢ G)

full_name: Filter.le_prod_map_fst_snd
code: theorem le_prod_map_fst_snd {f : Filter (α × β)} : f ≤ map Prod.fst f ×ˢ map Prod.snd f 
goal: f ≤ Filter.map Prod.fst f ×ˢ Filter.map Prod.snd f

full_name: Filter.Tendsto.prod_map
code: 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) 
goal: Filter.Tendsto (Prod.map f g) (a ×ˢ b) (c ×ˢ d)

full_name: Filter.map_prod
code: protected theorem map_prod (m : α × β → γ) (f : Filter α) (g : Filter β) :
    map m (f ×ˢ g) = (f.map fun a b => m (a, b)).seq g 
goal: Filter.map m (f ×ˢ g) = (Filter.map (fun a b => m (a, b)) f).seq g

full_name: Filter.prod_eq
code: theorem prod_eq : f ×ˢ g = (f.map Prod.mk).seq g 
goal: f ×ˢ g = (Filter.map Prod.mk f).seq g

full_name: Filter.prod_inf_prod
code: theorem prod_inf_prod {f₁ f₂ : Filter α} {g₁ g₂ : Filter β} :
    (f₁ ×ˢ g₁) ⊓ (f₂ ×ˢ g₂) = (f₁ ⊓ f₂) ×ˢ (g₁ ⊓ g₂) 
goal: f₁ ×ˢ g₁ ⊓ f₂ ×ˢ g₂ = (f₁ ⊓ f₂) ×ˢ (g₁ ⊓ g₂)

full_name: Filter.inf_prod
code: theorem inf_prod {f₁ f₂ : Filter α} : (f₁ ⊓ f₂) ×ˢ g = (f₁ ×ˢ g) ⊓ (f₂ ×ˢ g) 
goal: (f₁ ⊓ f₂) ×ˢ g = f₁ ×ˢ g ⊓ f₂ ×ˢ g

full_name: Filter.prod_inf
code: theorem prod_inf {g₁ g₂ : Filter β} : f ×ˢ (g₁ ⊓ g₂) = (f ×ˢ g₁) ⊓ (f ×ˢ g₂) 
goal: f ×ˢ (g₁ ⊓ g₂) = f ×ˢ g₁ ⊓ f ×ˢ g₂

full_name: Filter.prod_principal_principal
code: @[simp]
theorem prod_principal_principal {s : Set α} {t : Set β} : 𝓟 s ×ˢ 𝓟 t = 𝓟 (s ×ˢ t) 
goal: 𝓟 s ×ˢ 𝓟 t = 𝓟 (s ×ˢ t)

full_name: Filter.pure_prod
code: @[simp]
theorem pure_prod {a : α} {f : Filter β} : pure a ×ˢ f = map (Prod.mk a) f 
goal: pure a ×ˢ f = Filter.map (Prod.mk a) f

full_name: Filter.map_pure_prod
code: theorem map_pure_prod (f : α → β → γ) (a : α) (B : Filter β) :
    map (Function.uncurry f) (pure a ×ˢ B) = map (f a) B 
goal: Filter.map (Function.uncurry f) (pure a ×ˢ B) = Filter.map (f a) B

full_name: Filter.prod_pure
code: @[simp]
theorem prod_pure {b : β} : f ×ˢ pure b = map (fun a => (a, b)) f 
goal: f ×ˢ pure b = Filter.map (fun a => (a, b)) f

full_name: Filter.prod_pure_pure
code: theorem prod_pure_pure {a : α} {b : β} :
    (pure a : Filter α) ×ˢ (pure b : Filter β) = pure (a, b) 
goal: pure a ×ˢ pure b = pure (a, b)

full_name: Filter.prod_eq_bot
code: @[simp]
theorem prod_eq_bot : f ×ˢ g = ⊥ ↔ f = ⊥ ∨ g = ⊥ 
goal: f ×ˢ g = ⊥ ↔ f = ⊥ ∨ g = ⊥

full_name: Filter.prod_bot
code: @[simp] theorem prod_bot : f ×ˢ (⊥ : Filter β) = ⊥ 
goal: f ×ˢ ⊥ = ⊥

full_name: Filter.bot_prod
code: @[simp] theorem bot_prod : (⊥ : Filter α) ×ˢ g = ⊥ 
goal: ⊥ ×ˢ g = ⊥

full_name: Filter.prod_neBot
code: theorem prod_neBot : NeBot (f ×ˢ g) ↔ NeBot f ∧ NeBot g 
goal: (f ×ˢ g).NeBot ↔ f.NeBot ∧ g.NeBot

full_name: Filter.NeBot.prod
code: protected theorem NeBot.prod (hf : NeBot f) (hg : NeBot g) : NeBot (f ×ˢ g) 
goal: (f ×ˢ g).NeBot

full_name: Filter.prod.instNeBot
code: instance prod.instNeBot [hf : NeBot f] [hg : NeBot g] : NeBot (f ×ˢ g) 
goal: (f ×ˢ g).NeBot

full_name: Filter.disjoint_prod
code: @[simp]
lemma disjoint_prod {f' : Filter α} {g' : Filter β} :
    Disjoint (f ×ˢ g) (f' ×ˢ g') ↔ Disjoint f f' ∨ Disjoint g g' 
goal: Disjoint (f ×ˢ g) (f' ×ˢ g') ↔ Disjoint f f' ∨ Disjoint g g'

full_name: Filter.frequently_prod_and
code: /-- `p ∧ q` occurs frequently along the product of two filters
iff both `p` and `q` occur frequently along the corresponding filters. -/
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 
goal: (∃ᶠ (x : α × β) in f ×ˢ g, p x.1 ∧ q x.2) ↔ (∃ᶠ (a : α) in f, p a) ∧ ∃ᶠ (b : β) in g, q b

full_name: Filter.tendsto_prod_iff
code: 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 
goal: Filter.Tendsto f (x ×ˢ y) z ↔ ∀ W ∈ z, ∃ U ∈ x, ∃ V ∈ y, ∀ (x : α) (y : β), x ∈ U → y ∈ V → f (x, y) ∈ W

full_name: Filter.tendsto_prod_iff'
code: 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' 
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'

full_name: Filter.le_prod
code: theorem le_prod {f : Filter (α × β)} {g : Filter α} {g' : Filter β} :
    (f ≤ g ×ˢ g') ↔ Tendsto Prod.fst f g ∧ Tendsto Prod.snd f g' 
goal: f ≤ g ×ˢ g' ↔ Filter.Tendsto Prod.fst f g ∧ Filter.Tendsto Prod.snd f g'

full_name: Filter.coprod
code: /-- Coproduct of filters. -/
protected def coprod (f : Filter α) (g : Filter β) : Filter (α × β) 
goal: Filter (α × β)

full_name: Filter.coprod_eq_prod_top_sup_top_prod
code: theorem coprod_eq_prod_top_sup_top_prod (f : Filter α) (g : Filter β) :
    Filter.coprod f g = f ×ˢ ⊤ ⊔ ⊤ ×ˢ g 
goal: f.coprod g = f ×ˢ ⊤ ⊔ ⊤ ×ˢ g

full_name: Filter.mem_coprod_iff
code: 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 
goal: s ∈ f.coprod g ↔ (∃ t₁ ∈ f, Prod.fst ⁻¹' t₁ ⊆ s) ∧ ∃ t₂ ∈ g, Prod.snd ⁻¹' t₂ ⊆ s

full_name: Filter.bot_coprod
code: @[simp]
theorem bot_coprod (l : Filter β) : (⊥ : Filter α).coprod l = comap Prod.snd l 
goal: ⊥.coprod l = Filter.comap Prod.snd l

full_name: Filter.coprod_bot
code: @[simp]
theorem coprod_bot (l : Filter α) : l.coprod (⊥ : Filter β) = comap Prod.fst l 
goal: l.coprod ⊥ = Filter.comap Prod.fst l

full_name: Filter.bot_coprod_bot
code: theorem bot_coprod_bot : (⊥ : Filter α).coprod (⊥ : Filter β) = ⊥ 
goal: ⊥.coprod ⊥ = ⊥

full_name: Filter.compl_mem_coprod
code: theorem compl_mem_coprod {s : Set (α × β)} {la : Filter α} {lb : Filter β} :
    sᶜ ∈ la.coprod lb ↔ (Prod.fst '' s)ᶜ ∈ la ∧ (Prod.snd '' s)ᶜ ∈ lb 
goal: sᶜ ∈ la.coprod lb ↔ (Prod.fst '' s)ᶜ ∈ la ∧ (Prod.snd '' s)ᶜ ∈ lb

full_name: Filter.coprod_mono
code: @[mono]
theorem coprod_mono {f₁ f₂ : Filter α} {g₁ g₂ : Filter β} (hf : f₁ ≤ f₂) (hg : g₁ ≤ g₂) :
    f₁.coprod g₁ ≤ f₂.coprod g₂ 
goal: f₁.coprod g₁ ≤ f₂.coprod g₂

full_name: Filter.coprod_neBot_iff
code: theorem coprod_neBot_iff : (f.coprod g).NeBot ↔ f.NeBot ∧ Nonempty β ∨ Nonempty α ∧ g.NeBot 
goal: (f.coprod g).NeBot ↔ f.NeBot ∧ Nonempty β ∨ Nonempty α ∧ g.NeBot

full_name: Filter.coprod_neBot_left
code: @[instance]
theorem coprod_neBot_left [NeBot f] [Nonempty β] : (f.coprod g).NeBot 
goal: (f.coprod g).NeBot

full_name: Filter.coprod_neBot_right
code: @[instance]
theorem coprod_neBot_right [NeBot g] [Nonempty α] : (f.coprod g).NeBot 
goal: (f.coprod g).NeBot

full_name: Filter.principal_coprod_principal
code: theorem principal_coprod_principal (s : Set α) (t : Set β) :
    (𝓟 s).coprod (𝓟 t) = 𝓟 (sᶜ ×ˢ tᶜ)ᶜ 
goal: (𝓟 s).coprod (𝓟 t) = 𝓟 (sᶜ ×ˢ tᶜ)ᶜ

full_name: Filter.map_prod_map_coprod_le
code: 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₂) 
goal: Filter.map (Prod.map m₁ m₂) (f₁.coprod f₂) ≤ (Filter.map m₁ f₁).coprod (Filter.map m₂ f₂)

full_name: Filter.map_const_principal_coprod_map_id_principal
code: /-- Characterization of the coproduct of the `Filter.map`s of two principal filters `𝓟 {a}` and
`𝓟 {i}`, the first under the constant function `fun a => b` and the second under the identity
function. Together with the next lemma, `map_prod_map_const_id_principal_coprod_principal`, this
provides an example showing that the inequality in the lemma `map_prod_map_coprod_le` can be strict.
-/
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 ι))) 
goal: (Filter.map (fun x => b) (𝓟 {a})).coprod (Filter.map id (𝓟 {i})) = 𝓟 ({b} ×ˢ Set.univ ∪ Set.univ ×ˢ {i})

full_name: Filter.map_prod_map_const_id_principal_coprod_principal
code: /-- Characterization of the `Filter.map` of the coproduct of two principal filters `𝓟 {a}` and
`𝓟 {i}`, under the `Prod.map` of two functions, respectively the constant function `fun a => b` and
the identity function.  Together with the previous lemma,
`map_const_principal_coprod_map_id_principal`, this provides an example showing that the inequality
in the lemma `map_prod_map_coprod_le` can be strict. -/
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 ι)) 
goal: Filter.map (Prod.map (fun x => b) id) ((𝓟 {a}).coprod (𝓟 {i})) = 𝓟 ({b} ×ˢ Set.univ)

full_name: Filter.Tendsto.prod_map_coprod
code: 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) 
goal: Filter.Tendsto (Prod.map f g) (a.coprod b) (c.coprod d)