ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Filter.ZeroAtFilter.smul
theorem ZeroAtFilter.smul [TopologicalSpace β] [Zero 𝕜] [Zero β]
    [SMulWithZero 𝕜 β] [ContinuousConstSMul 𝕜 β] {l : Filter α} {f : α → β} (c : 𝕜)
    (hf : ZeroAtFilter l f) : ZeroAtFilter l (c • f) 
Arguments: {𝕜 : Type u_1} {α : Type u_2} {β : Type u_3} [TopologicalSpace β] [Zero 𝕜] [Zero β] [SMulWithZero 𝕜 β] [ContinuousConstSMul 𝕜 β] {l : Filter α} {f : α → β} (c : 𝕜) (hf : l.ZeroAtFilter f)
Goal: l.ZeroAtFilter (c • f)
-- Filter.ZeroAtFilter.boundedAtFilter
theorem ZeroAtFilter.boundedAtFilter [NormedAddCommGroup β] {l : Filter α} {f : α → β}
    (hf : ZeroAtFilter l f) : BoundedAtFilter l f 
Arguments: {α : Type u_2} {β : Type u_3} [NormedAddCommGroup β] {l : Filter α} {f : α → β} (hf : l.ZeroAtFilter f)
Goal: l.BoundedAtFilter f
-- Filter.const_boundedAtFilter
theorem const_boundedAtFilter [Norm β] (l : Filter α) (c : β) :
    BoundedAtFilter l (Function.const α c : α → β) 
Arguments: {α : Type u_2} {β : Type u_3} [Norm β] (l : Filter α) (c : β)
Goal: l.BoundedAtFilter (Function.const α c)
-- Filter.BoundedAtFilter.add
nonrec theorem BoundedAtFilter.add [SeminormedAddCommGroup β] {l : Filter α} {f g : α → β}
    (hf : BoundedAtFilter l f) (hg : BoundedAtFilter l g) : BoundedAtFilter l (f + g) 
Arguments: {α : Type u_2} {β : Type u_3} [SeminormedAddCommGroup β] {l : Filter α} {f g : α → β} (hf : l.BoundedAtFilter f) (hg : l.BoundedAtFilter g)
Goal: l.BoundedAtFilter (f + g)
-- Filter.BoundedAtFilter.neg
theorem BoundedAtFilter.neg [SeminormedAddCommGroup β] {l : Filter α} {f : α → β}
    (hf : BoundedAtFilter l f) : BoundedAtFilter l (-f) 
Arguments: {α : Type u_2} {β : Type u_3} [SeminormedAddCommGroup β] {l : Filter α} {f : α → β} (hf : l.BoundedAtFilter f)
Goal: l.BoundedAtFilter (-f)
-- Filter.BoundedAtFilter.smul
theorem BoundedAtFilter.smul
    [SeminormedRing 𝕜] [SeminormedAddCommGroup β] [Module 𝕜 β] [BoundedSMul 𝕜 β]
    {l : Filter α} {f : α → β} (c : 𝕜) (hf : BoundedAtFilter l f) : BoundedAtFilter l (c • f) 
Arguments: {𝕜 : Type u_1} {α : Type u_2} {β : Type u_3} [SeminormedRing 𝕜] [SeminormedAddCommGroup β] [Module 𝕜 β] [BoundedSMul 𝕜 β] {l : Filter α} {f : α → β} (c : 𝕜) (hf : l.BoundedAtFilter f)
Goal: l.BoundedAtFilter (c • f)
-- Filter.BoundedAtFilter.mul
nonrec theorem BoundedAtFilter.mul [SeminormedRing β] {l : Filter α} {f g : α → β}
    (hf : BoundedAtFilter l f) (hg : BoundedAtFilter l g) : BoundedAtFilter l (f * g) 
Arguments: {α : Type u_2} {β : Type u_3} [SeminormedRing β] {l : Filter α} {f g : α → β} (hf : l.BoundedAtFilter f) (hg : l.BoundedAtFilter g)
Goal: l.BoundedAtFilter (f * g)
-- Filter.smallSets_eq_generate
theorem smallSets_eq_generate {f : Filter α} : f.smallSets = generate (powerset '' f.sets) 
Arguments: {α : Type u_1} {f : Filter α}
Goal: f.smallSets = Filter.generate (Set.powerset '' f.sets)
-- Filter.bind_smallSets_gc
theorem bind_smallSets_gc :
    GaloisConnection (fun L : Filter (Set α) ↦ L.bind principal) smallSets 
Arguments: {α : Type u_1}
Goal: GaloisConnection (fun L => L.bind 𝓟) Filter.smallSets
-- Filter.HasBasis.smallSets
protected theorem HasBasis.smallSets {p : ι → Prop} {s : ι → Set α} (h : HasBasis l p s) :
    HasBasis l.smallSets p fun i => 𝒫 s i 
Arguments: {α : Type u_1} {ι : Sort u_3} {l : Filter α} {p : ι → Prop} {s : ι → Set α} (h : l.HasBasis p s)
Goal: l.smallSets.HasBasis p fun i => 𝒫 s i
-- Filter.hasBasis_smallSets
theorem hasBasis_smallSets (l : Filter α) :
    HasBasis l.smallSets (fun t : Set α => t ∈ l) powerset 
Arguments: {α : Type u_1} (l : Filter α)
Goal: l.smallSets.HasBasis (fun t => t ∈ l) Set.powerset
-- Filter.tendsto_smallSets_iff
theorem tendsto_smallSets_iff {f : α → Set β} :
    Tendsto f la lb.smallSets ↔ ∀ t ∈ lb, ∀ᶠ x in la, f x ⊆ t 
Arguments: {α : Type u_1} {β : Type u_2} {la : Filter α} {lb : Filter β} {f : α → Set β}
Goal: Filter.Tendsto f la lb.smallSets ↔ ∀ t ∈ lb, ∀ᶠ (x : α) in la, f x ⊆ t
-- Filter.eventually_smallSets
theorem eventually_smallSets {p : Set α → Prop} :
    (∀ᶠ s in l.smallSets, p s) ↔ ∃ s ∈ l, ∀ t, t ⊆ s → p t 
Arguments: {α : Type u_1} {l : Filter α} {p : Set α → Prop}
Goal: (∀ᶠ (s : Set α) in l.smallSets, p s) ↔ ∃ s ∈ l, ∀ t ⊆ s, p t
-- Filter.eventually_smallSets'
theorem eventually_smallSets' {p : Set α → Prop} (hp : ∀ ⦃s t⦄, s ⊆ t → p t → p s) :
    (∀ᶠ s in l.smallSets, p s) ↔ ∃ s ∈ l, p s 
Arguments: {α : Type u_1} {l : Filter α} {p : Set α → Prop} (hp : ∀ ⦃s t : Set α⦄, s ⊆ t → p t → p s)
Goal: (∀ᶠ (s : Set α) in l.smallSets, p s) ↔ ∃ s ∈ l, p s
-- Filter.frequently_smallSets
theorem frequently_smallSets {p : Set α → Prop} :
    (∃ᶠ s in l.smallSets, p s) ↔ ∀ t ∈ l, ∃ s, s ⊆ t ∧ p s 
Arguments: {α : Type u_1} {l : Filter α} {p : Set α → Prop}
Goal: (∃ᶠ (s : Set α) in l.smallSets, p s) ↔ ∀ t ∈ l, ∃ s ⊆ t, p s
-- Filter.frequently_smallSets_mem
theorem frequently_smallSets_mem (l : Filter α) : ∃ᶠ s in l.smallSets, s ∈ l 
Arguments: {α : Type u_1} (l : Filter α)
Goal: ∃ᶠ (s : Set α) in l.smallSets, s ∈ l
-- Filter.tendsto_image_smallSets
@[simp]
lemma tendsto_image_smallSets {f : α → β} :
    Tendsto (f '' ·) la.smallSets lb.smallSets ↔ Tendsto f la lb 
Arguments: {α : Type u_1} {β : Type u_2} {la : Filter α} {lb : Filter β} {f : α → β}
Goal: Filter.Tendsto (fun x => f '' x) la.smallSets lb.smallSets ↔ Filter.Tendsto f la lb
-- Filter.HasAntitoneBasis.tendsto_smallSets
theorem HasAntitoneBasis.tendsto_smallSets {ι} [Preorder ι] {s : ι → Set α}
    (hl : l.HasAntitoneBasis s) : Tendsto s atTop l.smallSets 
Arguments: {α : Type u_1} {l : Filter α} {ι : Type u_4} [Preorder ι] {s : ι → Set α} (hl : l.HasAntitoneBasis s)
Goal: Filter.Tendsto s Filter.atTop l.smallSets
-- Filter.monotone_smallSets
@[mono]
theorem monotone_smallSets : Monotone (@smallSets α) 
Arguments: {α : Type u_1}
Goal: Monotone Filter.smallSets
-- Filter.smallSets_bot
@[simp]
theorem smallSets_bot : (⊥ : Filter α).smallSets = pure ∅ 
Arguments: {α : Type u_1}
Goal: ⊥.smallSets = pure ∅
-- Filter.smallSets_top
@[simp]
theorem smallSets_top : (⊤ : Filter α).smallSets = ⊤ 
Arguments: {α : Type u_1}
Goal: ⊤.smallSets = ⊤
-- Filter.smallSets_principal
@[simp]
theorem smallSets_principal (s : Set α) : (𝓟 s).smallSets = 𝓟 (𝒫 s) 
Arguments: {α : Type u_1} (s : Set α)
Goal: (𝓟 s).smallSets = 𝓟 (𝒫 s)
-- Filter.smallSets_comap_eq_comap_image
theorem smallSets_comap_eq_comap_image (l : Filter β) (f : α → β) :
    (comap f l).smallSets = comap (image f) l.smallSets 
Arguments: {α : Type u_1} {β : Type u_2} (l : Filter β) (f : α → β)
Goal: (Filter.comap f l).smallSets = Filter.comap (Set.image f) l.smallSets
-- Filter.smallSets_comap
theorem smallSets_comap (l : Filter β) (f : α → β) :
    (comap f l).smallSets = l.lift' (powerset ∘ preimage f) 
Arguments: {α : Type u_1} {β : Type u_2} (l : Filter β) (f : α → β)
Goal: (Filter.comap f l).smallSets = l.lift' (Set.powerset ∘ Set.preimage f)
-- Filter.comap_smallSets
theorem comap_smallSets (l : Filter β) (f : α → Set β) :
    comap f l.smallSets = l.lift' (preimage f ∘ powerset) 
Arguments: {α : Type u_1} {β : Type u_2} (l : Filter β) (f : α → Set β)
Goal: Filter.comap f l.smallSets = l.lift' (Set.preimage f ∘ Set.powerset)
-- Filter.smallSets_iInf
theorem smallSets_iInf {f : ι → Filter α} : (iInf f).smallSets = ⨅ i, (f i).smallSets 
Arguments: {α : Type u_1} {ι : Sort u_3} {f : ι → Filter α}
Goal: (iInf f).smallSets = ⨅ i, (f i).smallSets
-- Filter.smallSets_inf
theorem smallSets_inf (l₁ l₂ : Filter α) : (l₁ ⊓ l₂).smallSets = l₁.smallSets ⊓ l₂.smallSets 
Arguments: {α : Type u_1} (l₁ l₂ : Filter α)
Goal: (l₁ ⊓ l₂).smallSets = l₁.smallSets ⊓ l₂.smallSets
-- Filter.Tendsto.smallSets_mono
theorem Tendsto.smallSets_mono {s t : α → Set β} (ht : Tendsto t la lb.smallSets)
    (hst : ∀ᶠ x in la, s x ⊆ t x) : Tendsto s la lb.smallSets 
Arguments: {α : Type u_1} {β : Type u_2} {la : Filter α} {lb : Filter β} {s t : α → Set β} (ht : Filter.Tendsto t la lb.smallSets) (hst : ∀ᶠ (x : α) in la, s x ⊆ t x)
Goal: Filter.Tendsto s la lb.smallSets
-- Filter.Tendsto.of_smallSets
theorem Tendsto.of_smallSets {s : α → Set β} {f : α → β} (hs : Tendsto s la lb.smallSets)
    (hf : ∀ᶠ x in la, f x ∈ s x) : Tendsto f la lb 
Arguments: {α : Type u_1} {β : Type u_2} {la : Filter α} {lb : Filter β} {s : α → Set β} {f : α → β} (hs : Filter.Tendsto s la lb.smallSets) (hf : ∀ᶠ (x : α) in la, f x ∈ s x)
Goal: Filter.Tendsto f la lb
-- Filter.eventually_smallSets_eventually
@[simp]
theorem eventually_smallSets_eventually {p : α → Prop} :
    (∀ᶠ s in l.smallSets, ∀ᶠ x in l', x ∈ s → p x) ↔ ∀ᶠ x in l ⊓ l', p x 
Arguments: {α : Type u_1} {l l' : Filter α} {p : α → Prop}
Goal: (∀ᶠ (s : Set α) in l.smallSets, ∀ᶠ (x : α) in l', x ∈ s → p x) ↔ ∀ᶠ (x : α) in l ⊓ l', p x
-- Filter.eventually_smallSets_forall
@[simp]
theorem eventually_smallSets_forall {p : α → Prop} :
    (∀ᶠ s in l.smallSets, ∀ x ∈ s, p x) ↔ ∀ᶠ x in l, p x 
Arguments: {α : Type u_1} {l : Filter α} {p : α → Prop}
Goal: (∀ᶠ (s : Set α) in l.smallSets, ∀ x ∈ s, p x) ↔ ∀ᶠ (x : α) in l, p x
-- Filter.eventually_smallSets_subset
@[simp]
theorem eventually_smallSets_subset {s : Set α} : (∀ᶠ t in l.smallSets, t ⊆ s) ↔ s ∈ l 
Arguments: {α : Type u_1} {l : Filter α} {s : Set α}
Goal: (∀ᶠ (t : Set α) in l.smallSets, t ⊆ s) ↔ s ∈ l
-- Filter.prod_mem_prod
theorem prod_mem_prod (hs : s ∈ f) (ht : t ∈ g) : s ×ˢ t ∈ f ×ˢ g 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : Filter α} {g : Filter β} (hs : s ∈ f) (ht : t ∈ g)
Goal: s ×ˢ t ∈ f ×ˢ g
-- Filter.mem_prod_iff
theorem mem_prod_iff {s : Set (α × β)} {f : Filter α} {g : Filter β} :
    s ∈ f ×ˢ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ ×ˢ t₂ ⊆ s 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set (α × β)} {f : Filter α} {g : Filter β}
Goal: s ∈ f ×ˢ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ ×ˢ t₂ ⊆ s
-- Filter.prod_mem_prod_iff
@[simp]
theorem prod_mem_prod_iff [f.NeBot] [g.NeBot] : s ×ˢ t ∈ f ×ˢ g ↔ s ∈ f ∧ t ∈ g 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : Filter α} {g : Filter β} [f.NeBot] [g.NeBot]
Goal: s ×ˢ t ∈ f ×ˢ g ↔ s ∈ f ∧ t ∈ g
-- Filter.mem_prod_principal
theorem mem_prod_principal {s : Set (α × β)} :
    s ∈ f ×ˢ 𝓟 t ↔ { a | ∀ b ∈ t, (a, b) ∈ s } ∈ f 
Arguments: {α : Type u_1} {β : Type u_2} {t : Set β} {f : Filter α} {s : Set (α × β)}
Goal: s ∈ f ×ˢ 𝓟 t ↔ {a | ∀ b ∈ t, (a, b) ∈ s} ∈ f
-- Filter.mem_prod_top
theorem mem_prod_top {s : Set (α × β)} :
    s ∈ f ×ˢ (⊤ : Filter β) ↔ { a | ∀ b, (a, b) ∈ s } ∈ f 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {s : Set (α × β)}
Goal: s ∈ f ×ˢ ⊤ ↔ {a | ∀ (b : β), (a, b) ∈ s} ∈ f
-- Filter.eventually_prod_principal_iff
theorem eventually_prod_principal_iff {p : α × β → Prop} {s : Set β} :
    (∀ᶠ x : α × β in f ×ˢ 𝓟 s, p x) ↔ ∀ᶠ x : α in f, ∀ y : β, y ∈ s → p (x, y) 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {p : α × β → Prop} {s : Set β}
Goal: (∀ᶠ (x : α × β) in f ×ˢ 𝓟 s, p x) ↔ ∀ᶠ (x : α) in f, ∀ y ∈ s, p (x, y)
-- Filter.comap_prod
theorem comap_prod (f : α → β × γ) (b : Filter β) (c : Filter γ) :
    comap f (b ×ˢ c) = comap (Prod.fst ∘ f) b ⊓ comap (Prod.snd ∘ f) c 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β × γ) (b : Filter β) (c : Filter γ)
Goal: Filter.comap f (b ×ˢ c) = Filter.comap (Prod.fst ∘ f) b ⊓ Filter.comap (Prod.snd ∘ f) c
-- Filter.prod_top
theorem prod_top : f ×ˢ (⊤ : Filter β) = f.comap Prod.fst 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α}
Goal: f ×ˢ ⊤ = Filter.comap Prod.fst f
-- Filter.top_prod
theorem top_prod : (⊤ : Filter α) ×ˢ g = g.comap Prod.snd 
Arguments: {α : Type u_1} {β : Type u_2} {g : Filter β}
Goal: ⊤ ×ˢ g = Filter.comap Prod.snd g
-- Filter.sup_prod
theorem sup_prod (f₁ f₂ : Filter α) (g : Filter β) : (f₁ ⊔ f₂) ×ˢ g = (f₁ ×ˢ g) ⊔ (f₂ ×ˢ g) 
Arguments: {α : Type u_1} {β : Type u_2} (f₁ f₂ : Filter α) (g : Filter β)
Goal: (f₁ ⊔ f₂) ×ˢ g = f₁ ×ˢ g ⊔ f₂ ×ˢ g
-- Filter.prod_sup
theorem prod_sup (f : Filter α) (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.eventually_prod_iff
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) 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β} {p : α × β → Prop}
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)
-- Filter.tendsto_fst
theorem tendsto_fst : Tendsto Prod.fst (f ×ˢ g) f 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β}
Goal: Filter.Tendsto Prod.fst (f ×ˢ g) f
-- Filter.tendsto_snd
theorem tendsto_snd : Tendsto Prod.snd (f ×ˢ g) g 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β}
Goal: Filter.Tendsto Prod.snd (f ×ˢ g) g
-- Filter.Tendsto.fst
theorem Tendsto.fst {h : Filter γ} {m : α → β × γ} (H : Tendsto m f (g ×ˢ h)) :
    Tendsto (fun a ↦ (m a).1) f g 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {g : Filter β} {h : Filter γ} {m : α → β × γ} (H : Filter.Tendsto m f (g ×ˢ h))
Goal: Filter.Tendsto (fun a => (m a).1) f g
-- Filter.Tendsto.snd
theorem Tendsto.snd {h : Filter γ} {m : α → β × γ} (H : Tendsto m f (g ×ˢ h)) :
    Tendsto (fun a ↦ (m a).2) f h 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {g : Filter β} {h : Filter γ} {m : α → β × γ} (H : Filter.Tendsto m f (g ×ˢ h))
Goal: Filter.Tendsto (fun a => (m a).2) f h
-- Filter.Tendsto.prod_mk
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) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {g : Filter β} {h : Filter γ} {m₁ : α → β} {m₂ : α → γ} (h₁ : Filter.Tendsto m₁ f g) (h₂ : Filter.Tendsto m₂ f h)
Goal: Filter.Tendsto (fun x => (m₁ x, m₂ x)) f (g ×ˢ h)
-- Filter.tendsto_prod_swap
theorem tendsto_prod_swap : Tendsto (Prod.swap : α × β → β × α) (f ×ˢ g) (g ×ˢ f) 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β}
Goal: Filter.Tendsto Prod.swap (f ×ˢ g) (g ×ˢ f)
-- Filter.Eventually.prod_inl
theorem Eventually.prod_inl {la : Filter α} {p : α → Prop} (h : ∀ᶠ x in la, p x) (lb : Filter β) :
    ∀ᶠ x in la ×ˢ lb, p (x : α × β).1 
Arguments: {α : Type u_1} {β : Type u_2} {la : Filter α} {p : α → Prop} (h : ∀ᶠ (x : α) in la, p x) (lb : Filter β)
Goal: ∀ᶠ (x : α × β) in la ×ˢ lb, p x.1
-- Filter.Eventually.prod_inr
theorem Eventually.prod_inr {lb : Filter β} {p : β → Prop} (h : ∀ᶠ x in lb, p x) (la : Filter α) :
    ∀ᶠ x in la ×ˢ lb, p (x : α × β).2 
Arguments: {α : Type u_1} {β : Type u_2} {lb : Filter β} {p : β → Prop} (h : ∀ᶠ (x : β) in lb, p x) (la : Filter α)
Goal: ∀ᶠ (x : α × β) in la ×ˢ lb, p x.2
-- Filter.Eventually.prod_mk
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 
Arguments: {α : Type u_1} {β : Type u_2} {la : Filter α} {pa : α → Prop} (ha : ∀ᶠ (x : α) in la, pa x) {lb : Filter β} {pb : β → Prop} (hb : ∀ᶠ (y : β) in lb, pb y)
Goal: ∀ᶠ (p : α × β) in la ×ˢ lb, pa p.1 ∧ pb p.2
-- Filter.EventuallyEq.prod_map
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 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_6} {la : Filter α} {fa ga : α → γ} (ha : fa =ᶠ[la] ga) {lb : Filter β} {fb gb : β → δ} (hb : fb =ᶠ[lb] gb)
Goal: Prod.map fa fb =ᶠ[la ×ˢ lb] Prod.map ga gb
-- Filter.EventuallyLE.prod_map
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 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_6} [LE γ] [LE δ] {la : Filter α} {fa ga : α → γ} (ha : fa ≤ᶠ[la] ga) {lb : Filter β} {fb gb : β → δ} (hb : fb ≤ᶠ[lb] gb)
Goal: Prod.map fa fb ≤ᶠ[la ×ˢ lb] Prod.map ga gb
-- Filter.Eventually.curry
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) 
Arguments: {α : Type u_1} {β : Type u_2} {la : Filter α} {lb : Filter β} {p : α × β → Prop} (h : ∀ᶠ (x : α × β) in la ×ˢ lb, p x)
Goal: ∀ᶠ (x : α) in la, ∀ᶠ (y : β) in lb, p (x, y)
-- Filter.Frequently.uncurry
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 
Arguments: {α : Type u_1} {β : Type u_2} {la : Filter α} {lb : Filter β} {p : α → β → Prop} (h : ∃ᶠ (x : α) in la, ∃ᶠ (y : β) in lb, p x y)
Goal: ∃ᶠ (xy : α × β) in la ×ˢ lb, p xy.1 xy.2
-- Filter.Eventually.diag_of_prod
theorem Eventually.diag_of_prod {p : α × α → Prop} (h : ∀ᶠ i in f ×ˢ f, p i) :
    ∀ᶠ i in f, p (i, i) 
Arguments: {α : Type u_1} {f : Filter α} {p : α × α → Prop} (h : ∀ᶠ (i : α × α) in f ×ˢ f, p i)
Goal: ∀ᶠ (i : α) in f, p (i, i)
-- Filter.Eventually.diag_of_prod_left
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) 
Arguments: {α : Type u_1} {γ : Type u_3} {f : Filter α} {g : Filter γ} {p : (α × α) × γ → Prop}
Goal: (∀ᶠ (x : (α × α) × γ) in (f ×ˢ f) ×ˢ g, p x) → ∀ᶠ (x : α × γ) in f ×ˢ g, p ((x.1, x.1), x.2)
-- Filter.Eventually.diag_of_prod_right
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) 
Arguments: {α : Type u_1} {γ : Type u_3} {f : Filter α} {g : Filter γ} {p : α × γ × γ → Prop}
Goal: (∀ᶠ (x : α × γ × γ) in f ×ˢ g ×ˢ g, p x) → ∀ᶠ (x : α × γ) in f ×ˢ g, p (x.1, x.2, x.2)
-- Filter.tendsto_diag
theorem tendsto_diag : Tendsto (fun i => (i, i)) f (f ×ˢ f) 
Arguments: {α : Type u_1} {f : Filter α}
Goal: Filter.Tendsto (fun i => (i, i)) f (f ×ˢ f)
-- Filter.prod_iInf_left
theorem prod_iInf_left [Nonempty ι] {f : ι → Filter α} {g : Filter β} :
    (⨅ i, f i) ×ˢ g = ⨅ i, f i ×ˢ g 
Arguments: {α : Type u_1} {β : Type u_2} {ι : Sort u_5} [Nonempty ι] {f : ι → Filter α} {g : Filter β}
Goal: (⨅ i, f i) ×ˢ g = ⨅ i, f i ×ˢ g
-- Filter.prod_iInf_right
theorem prod_iInf_right [Nonempty ι] {f : Filter α} {g : ι → Filter β} :
    (f ×ˢ ⨅ i, g i) = ⨅ i, f ×ˢ g i 
Arguments: {α : Type u_1} {β : Type u_2} {ι : Sort u_5} [Nonempty ι] {f : Filter α} {g : ι → Filter β}
Goal: f ×ˢ ⨅ i, g i = ⨅ i, f ×ˢ g i
-- Filter.prod_mono
@[mono, gcongr]
theorem prod_mono {f₁ f₂ : Filter α} {g₁ g₂ : Filter β} (hf : f₁ ≤ f₂) (hg : g₁ ≤ g₂) :
    f₁ ×ˢ g₁ ≤ f₂ ×ˢ g₂ 
Arguments: {α : Type u_1} {β : Type u_2} {f₁ f₂ : Filter α} {g₁ g₂ : Filter β} (hf : f₁ ≤ f₂) (hg : g₁ ≤ g₂)
Goal: f₁ ×ˢ g₁ ≤ f₂ ×ˢ g₂
-- Filter.prod_mono_left
@[gcongr]
theorem prod_mono_left (g : Filter β) {f₁ f₂ : Filter α} (hf : f₁ ≤ f₂) : f₁ ×ˢ g ≤ f₂ ×ˢ g 
Arguments: {α : Type u_1} {β : Type u_2} (g : Filter β) {f₁ f₂ : Filter α} (hf : f₁ ≤ f₂)
Goal: f₁ ×ˢ g ≤ f₂ ×ˢ g
-- Filter.prod_mono_right
@[gcongr]
theorem prod_mono_right (f : Filter α) {g₁ g₂ : Filter β} (hf : g₁ ≤ g₂) : f ×ˢ g₁ ≤ f ×ˢ g₂ 
Arguments: {α : Type u_1} {β : Type u_2} (f : Filter α) {g₁ g₂ : Filter β} (hf : g₁ ≤ g₂)
Goal: f ×ˢ g₁ ≤ f ×ˢ g₂
-- Filter.prod_comap_comap_eq
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₂) 
Arguments: {α₁ : Type u} {α₂ : Type v} {β₁ : Type w} {β₂ : Type x} {f₁ : Filter α₁} {f₂ : Filter α₂} {m₁ : β₁ → α₁} {m₂ : β₂ → α₂}
Goal: Filter.comap m₁ f₁ ×ˢ Filter.comap m₂ f₂ = Filter.comap (fun p => (m₁ p.1, m₂ p.2)) (f₁ ×ˢ f₂)
-- Filter.prod_comm'
theorem prod_comm' : f ×ˢ g = comap Prod.swap (g ×ˢ f) 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β}
Goal: f ×ˢ g = Filter.comap Prod.swap (g ×ˢ f)
-- Filter.prod_comm
theorem prod_comm : f ×ˢ g = map (fun p : β × α => (p.2, p.1)) (g ×ˢ f) 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β}
Goal: f ×ˢ g = Filter.map (fun p => (p.2, p.1)) (g ×ˢ f)
-- Filter.mem_prod_iff_left
theorem mem_prod_iff_left {s : Set (α × β)} :
    s ∈ f ×ˢ g ↔ ∃ t ∈ f, ∀ᶠ y in g, ∀ x ∈ t, (x, y) ∈ s 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β} {s : Set (α × β)}
Goal: s ∈ f ×ˢ g ↔ ∃ t ∈ f, ∀ᶠ (y : β) in g, ∀ x ∈ t, (x, y) ∈ s
-- Filter.mem_prod_iff_right
theorem mem_prod_iff_right {s : Set (α × β)} :
    s ∈ f ×ˢ g ↔ ∃ t ∈ g, ∀ᶠ x in f, ∀ y ∈ t, (x, y) ∈ s 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β} {s : Set (α × β)}
Goal: s ∈ f ×ˢ g ↔ ∃ t ∈ g, ∀ᶠ (x : α) in f, ∀ y ∈ t, (x, y) ∈ s
-- Filter.map_fst_prod
@[simp]
theorem map_fst_prod (f : Filter α) (g : Filter β) [NeBot g] : map Prod.fst (f ×ˢ g) = f 
Arguments: {α : Type u_1} {β : Type u_2} (f : Filter α) (g : Filter β) [g.NeBot]
Goal: Filter.map Prod.fst (f ×ˢ g) = f
-- Filter.map_snd_prod
@[simp]
theorem map_snd_prod (f : Filter α) (g : Filter β) [NeBot f] : map Prod.snd (f ×ˢ g) = g 
Arguments: {α : Type u_1} {β : Type u_2} (f : Filter α) (g : Filter β) [f.NeBot]
Goal: Filter.map Prod.snd (f ×ˢ g) = g
-- Filter.prod_le_prod
@[simp]
theorem prod_le_prod {f₁ f₂ : Filter α} {g₁ g₂ : Filter β} [NeBot f₁] [NeBot g₁] :
    f₁ ×ˢ g₁ ≤ f₂ ×ˢ g₂ ↔ f₁ ≤ f₂ ∧ g₁ ≤ g₂ 
Arguments: {α : Type u_1} {β : Type u_2} {f₁ f₂ : Filter α} {g₁ g₂ : Filter β} [f₁.NeBot] [g₁.NeBot]
Goal: f₁ ×ˢ g₁ ≤ f₂ ×ˢ g₂ ↔ f₁ ≤ f₂ ∧ g₁ ≤ g₂
-- Filter.prod_inj
@[simp]
theorem prod_inj {f₁ f₂ : Filter α} {g₁ g₂ : Filter β} [NeBot f₁] [NeBot g₁] :
    f₁ ×ˢ g₁ = f₂ ×ˢ g₂ ↔ f₁ = f₂ ∧ g₁ = g₂ 
Arguments: {α : Type u_1} {β : Type u_2} {f₁ f₂ : Filter α} {g₁ g₂ : Filter β} [f₁.NeBot] [g₁.NeBot]
Goal: f₁ ×ˢ g₁ = f₂ ×ˢ g₂ ↔ f₁ = f₂ ∧ g₁ = g₂
-- Filter.eventually_swap_iff
theorem eventually_swap_iff {p : α × β → Prop} :
    (∀ᶠ x : α × β in f ×ˢ g, p x) ↔ ∀ᶠ y : β × α in g ×ˢ f, p y.swap 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β} {p : α × β → Prop}
Goal: (∀ᶠ (x : α × β) in f ×ˢ g, p x) ↔ ∀ᶠ (y : β × α) in g ×ˢ f, p y.swap
-- Filter.prod_assoc
theorem prod_assoc (f : Filter α) (g : Filter β) (h : Filter γ) :
    map (Equiv.prodAssoc α β γ) ((f ×ˢ g) ×ˢ h) = f ×ˢ (g ×ˢ h) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : Filter α) (g : Filter β) (h : Filter γ)
Goal: Filter.map (⇑(Equiv.prodAssoc α β γ)) ((f ×ˢ g) ×ˢ h) = f ×ˢ g ×ˢ h
-- Filter.prod_assoc_symm
theorem prod_assoc_symm (f : Filter α) (g : Filter β) (h : Filter γ) :
    map (Equiv.prodAssoc α β γ).symm (f ×ˢ (g ×ˢ h)) = (f ×ˢ g) ×ˢ h 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : Filter α) (g : Filter β) (h : Filter γ)
Goal: Filter.map (⇑(Equiv.prodAssoc α β γ).symm) (f ×ˢ g ×ˢ h) = (f ×ˢ g) ×ˢ h
-- Filter.tendsto_prodAssoc
theorem tendsto_prodAssoc {h : Filter γ} :
    Tendsto (Equiv.prodAssoc α β γ) ((f ×ˢ g) ×ˢ h) (f ×ˢ (g ×ˢ h)) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {g : Filter β} {h : Filter γ}
Goal: Filter.Tendsto (⇑(Equiv.prodAssoc α β γ)) ((f ×ˢ g) ×ˢ h) (f ×ˢ g ×ˢ h)
-- Filter.tendsto_prodAssoc_symm
theorem tendsto_prodAssoc_symm {h : Filter γ} :
    Tendsto (Equiv.prodAssoc α β γ).symm (f ×ˢ (g ×ˢ h)) ((f ×ˢ g) ×ˢ h) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {g : Filter β} {h : Filter γ}
Goal: Filter.Tendsto (⇑(Equiv.prodAssoc α β γ).symm) (f ×ˢ g ×ˢ h) ((f ×ˢ g) ×ˢ h)
-- Filter.map_swap4_prod
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) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {f : Filter α} {g : Filter β} {h : Filter γ} {k : Filter δ}
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