ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Filter.HasBasis.tendsto_right_iff
theorem HasBasis.tendsto_right_iff (hlb : lb.HasBasis pb sb) :
    Tendsto f la lb ↔ ∀ i, pb i → ∀ᶠ x in la, f x ∈ sb i 
Arguments: {α : Type u_1} {β : Type u_2} {ι' : Sort u_5} {la : Filter α} {lb : Filter β} {pb : ι' → Prop} {sb : ι' → Set β} {f : α → β} (hlb : lb.HasBasis pb sb)
Goal: Filter.Tendsto f la lb ↔ ∀ (i : ι'), pb i → ∀ᶠ (x : α) in la, f x ∈ sb i
-- Filter.HasBasis.tendsto_iff
theorem HasBasis.tendsto_iff (hla : la.HasBasis pa sa) (hlb : lb.HasBasis pb sb) :
    Tendsto f la lb ↔ ∀ ib, pb ib → ∃ ia, pa ia ∧ ∀ x ∈ sa ia, f x ∈ sb ib 
Arguments: {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {ι' : Sort u_5} {la : Filter α} {pa : ι → Prop} {sa : ι → Set α} {lb : Filter β} {pb : ι' → Prop} {sb : ι' → Set β} {f : α → β} (hla : la.HasBasis pa sa) (hlb : lb.HasBasis pb sb)
Goal: Filter.Tendsto f la lb ↔ ∀ (ib : ι'), pb ib → ∃ ia, pa ia ∧ ∀ x ∈ sa ia, f x ∈ sb ib
-- Filter.Tendsto.basis_left
theorem Tendsto.basis_left (H : Tendsto f la lb) (hla : la.HasBasis pa sa) :
    ∀ t ∈ lb, ∃ i, pa i ∧ MapsTo f (sa i) t 
Arguments: {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {la : Filter α} {pa : ι → Prop} {sa : ι → Set α} {lb : Filter β} {f : α → β} (H : Filter.Tendsto f la lb) (hla : la.HasBasis pa sa) (t : Set β)
Goal: t ∈ lb → ∃ i, pa i ∧ Set.MapsTo f (sa i) t
-- Filter.Tendsto.basis_right
theorem Tendsto.basis_right (H : Tendsto f la lb) (hlb : lb.HasBasis pb sb) :
    ∀ i, pb i → ∀ᶠ x in la, f x ∈ sb i 
Arguments: {α : Type u_1} {β : Type u_2} {ι' : Sort u_5} {la : Filter α} {lb : Filter β} {pb : ι' → Prop} {sb : ι' → Set β} {f : α → β} (H : Filter.Tendsto f la lb) (hlb : lb.HasBasis pb sb) (i : ι')
Goal: pb i → ∀ᶠ (x : α) in la, f x ∈ sb i
-- Filter.Tendsto.basis_both
theorem Tendsto.basis_both (H : Tendsto f la lb) (hla : la.HasBasis pa sa)
    (hlb : lb.HasBasis pb sb) :
    ∀ ib, pb ib → ∃ ia, pa ia ∧ MapsTo f (sa ia) (sb ib) 
Arguments: {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {ι' : Sort u_5} {la : Filter α} {pa : ι → Prop} {sa : ι → Set α} {lb : Filter β} {pb : ι' → Prop} {sb : ι' → Set β} {f : α → β} (H : Filter.Tendsto f la lb) (hla : la.HasBasis pa sa) (hlb : lb.HasBasis pb sb) (ib : ι')
Goal: pb ib → ∃ ia, pa ia ∧ Set.MapsTo f (sa ia) (sb ib)
-- Filter.HasBasis.prod_pprod
theorem HasBasis.prod_pprod (hla : la.HasBasis pa sa) (hlb : lb.HasBasis pb sb) :
    (la ×ˢ lb).HasBasis (fun i : PProd ι ι' => pa i.1 ∧ pb i.2) fun i => sa i.1 ×ˢ sb i.2 
Arguments: {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {ι' : Sort u_5} {la : Filter α} {pa : ι → Prop} {sa : ι → Set α} {lb : Filter β} {pb : ι' → Prop} {sb : ι' → Set β} (hla : la.HasBasis pa sa) (hlb : lb.HasBasis pb sb)
Goal: (la ×ˢ lb).HasBasis (fun i => pa i.fst ∧ pb i.snd) fun i => sa i.fst ×ˢ sb i.snd
-- Filter.HasBasis.prod
theorem HasBasis.prod {ι ι' : Type*} {pa : ι → Prop} {sa : ι → Set α} {pb : ι' → Prop}
    {sb : ι' → Set β} (hla : la.HasBasis pa sa) (hlb : lb.HasBasis pb sb) :
    (la ×ˢ lb).HasBasis (fun i : ι × ι' => pa i.1 ∧ pb i.2) fun i => sa i.1 ×ˢ sb i.2 
Arguments: {α : Type u_1} {β : Type u_2} {la : Filter α} {lb : Filter β} {ι : Type u_6} {ι' : Type u_7} {pa : ι → Prop} {sa : ι → Set α} {pb : ι' → Prop} {sb : ι' → Set β} (hla : la.HasBasis pa sa) (hlb : lb.HasBasis pb sb)
Goal: (la ×ˢ lb).HasBasis (fun i => pa i.1 ∧ pb i.2) fun i => sa i.1 ×ˢ sb i.2
-- Filter.HasBasis.prod_same_index
theorem HasBasis.prod_same_index {p : ι → Prop} {sb : ι → Set β} (hla : la.HasBasis p sa)
    (hlb : lb.HasBasis p sb) (h_dir : ∀ {i j}, p i → p j → ∃ k, p k ∧ sa k ⊆ sa i ∧ sb k ⊆ sb j) :
    (la ×ˢ lb).HasBasis p fun i => sa i ×ˢ sb i 
Arguments: {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {la : Filter α} {sa : ι → Set α} {lb : Filter β} {p : ι → Prop} {sb : ι → Set β} (hla : la.HasBasis p sa) (hlb : lb.HasBasis p sb) (h_dir : ∀ {i j : ι}, p i → p j → ∃ k, p k ∧ sa k ⊆ sa i ∧ sb k ⊆ sb j)
Goal: (la ×ˢ lb).HasBasis p fun i => sa i ×ˢ sb i
-- Filter.HasBasis.prod_same_index_mono
theorem HasBasis.prod_same_index_mono {ι : Type*} [LinearOrder ι] {p : ι → Prop} {sa : ι → Set α}
    {sb : ι → Set β} (hla : la.HasBasis p sa) (hlb : lb.HasBasis p sb)
    (hsa : MonotoneOn sa { i | p i }) (hsb : MonotoneOn sb { i | p i }) :
    (la ×ˢ lb).HasBasis p fun i => sa i ×ˢ sb i 
Arguments: {α : Type u_1} {β : Type u_2} {la : Filter α} {lb : Filter β} {ι : Type u_6} [LinearOrder ι] {p : ι → Prop} {sa : ι → Set α} {sb : ι → Set β} (hla : la.HasBasis p sa) (hlb : lb.HasBasis p sb) (hsa : MonotoneOn sa {i | p i}) (hsb : MonotoneOn sb {i | p i})
Goal: (la ×ˢ lb).HasBasis p fun i => sa i ×ˢ sb i
-- Filter.HasBasis.prod_same_index_anti
theorem HasBasis.prod_same_index_anti {ι : Type*} [LinearOrder ι] {p : ι → Prop} {sa : ι → Set α}
    {sb : ι → Set β} (hla : la.HasBasis p sa) (hlb : lb.HasBasis p sb)
    (hsa : AntitoneOn sa { i | p i }) (hsb : AntitoneOn sb { i | p i }) :
    (la ×ˢ lb).HasBasis p fun i => sa i ×ˢ sb i 
Arguments: {α : Type u_1} {β : Type u_2} {la : Filter α} {lb : Filter β} {ι : Type u_6} [LinearOrder ι] {p : ι → Prop} {sa : ι → Set α} {sb : ι → Set β} (hla : la.HasBasis p sa) (hlb : lb.HasBasis p sb) (hsa : AntitoneOn sa {i | p i}) (hsb : AntitoneOn sb {i | p i})
Goal: (la ×ˢ lb).HasBasis p fun i => sa i ×ˢ sb i
-- Filter.HasBasis.prod_self
theorem HasBasis.prod_self (hl : la.HasBasis pa sa) :
    (la ×ˢ la).HasBasis pa fun i => sa i ×ˢ sa i 
Arguments: {α : Type u_1} {ι : Sort u_4} {la : Filter α} {pa : ι → Prop} {sa : ι → Set α} (hl : la.HasBasis pa sa)
Goal: (la ×ˢ la).HasBasis pa fun i => sa i ×ˢ sa i
-- Filter.mem_prod_self_iff
theorem mem_prod_self_iff {s} : s ∈ la ×ˢ la ↔ ∃ t ∈ la, t ×ˢ t ⊆ s 
Arguments: {α : Type u_1} {la : Filter α} {s : Set (α × α)}
Goal: s ∈ la ×ˢ la ↔ ∃ t ∈ la, t ×ˢ t ⊆ s
-- Filter.eventually_prod_self_iff
lemma eventually_prod_self_iff {r : α → α → Prop} :
    (∀ᶠ x in la ×ˢ la, r x.1 x.2) ↔ ∃ t ∈ la, ∀ x ∈ t, ∀ y ∈ t, r x y 
Arguments: {α : Type u_1} {la : Filter α} {r : α → α → Prop}
Goal: (∀ᶠ (x : α × α) in la ×ˢ la, r x.1 x.2) ↔ ∃ t ∈ la, ∀ x ∈ t, ∀ y ∈ t, r x y
-- Filter.HasAntitoneBasis.prod
theorem HasAntitoneBasis.prod {ι : Type*} [LinearOrder ι] {f : Filter α} {g : Filter β}
    {s : ι → Set α} {t : ι → Set β} (hf : HasAntitoneBasis f s) (hg : HasAntitoneBasis g t) :
    HasAntitoneBasis (f ×ˢ g) fun n => s n ×ˢ t n 
Arguments: {α : Type u_1} {β : Type u_2} {ι : Type u_6} [LinearOrder ι] {f : Filter α} {g : Filter β} {s : ι → Set α} {t : ι → Set β} (hf : f.HasAntitoneBasis s) (hg : g.HasAntitoneBasis t)
Goal: (f ×ˢ g).HasAntitoneBasis fun n => s n ×ˢ t n
-- Filter.HasBasis.coprod
theorem HasBasis.coprod {ι ι' : Type*} {pa : ι → Prop} {sa : ι → Set α} {pb : ι' → Prop}
    {sb : ι' → Set β} (hla : la.HasBasis pa sa) (hlb : lb.HasBasis pb sb) :
    (la.coprod lb).HasBasis (fun i : ι × ι' => pa i.1 ∧ pb i.2) fun i =>
      Prod.fst ⁻¹' sa i.1 ∪ Prod.snd ⁻¹' sb i.2 
Arguments: {α : Type u_1} {β : Type u_2} {la : Filter α} {lb : Filter β} {ι : Type u_6} {ι' : Type u_7} {pa : ι → Prop} {sa : ι → Set α} {pb : ι' → Prop} {sb : ι' → Set β} (hla : la.HasBasis pa sa) (hlb : lb.HasBasis pb sb)
Goal: (la.coprod lb).HasBasis (fun i => pa i.1 ∧ pb i.2) fun i => Prod.fst ⁻¹' sa i.1 ∪ Prod.snd ⁻¹' sb i.2
-- Filter.map_sigma_mk_comap
theorem map_sigma_mk_comap {π : α → Type*} {π' : β → Type*} {f : α → β}
    (hf : Function.Injective f) (g : ∀ a, π a → π' (f a)) (a : α) (l : Filter (π' (f a))) :
    map (Sigma.mk a) (comap (g a) l) = comap (Sigma.map f g) (map (Sigma.mk (f a)) l) 
Arguments: {α : Type u_1} {β : Type u_2} {π : α → Type u_6} {π' : β → Type u_7} {f : α → β} (hf : Function.Injective f) (g : (a : α) → π a → π' (f a)) (a : α) (l : Filter (π' (f a)))
Goal: Filter.map (Sigma.mk a) (Filter.comap (g a) l) = Filter.comap (Sigma.map f g) (Filter.map (Sigma.mk (f a)) l)
-- Filter.IsCountablyGenerated.out
class IsCountablyGenerated (f : Filter α) : Prop where
    out : ∃ s : Set (Set α), s.Countable ∧ f = generate s
Arguments: {α : Type u_1} {f : Filter α} [self : f.IsCountablyGenerated]
Goal: ∃ s, s.Countable ∧ f = Filter.generate s
-- Filter.IsCountableBasis.countable
structure IsCountableBasis (p : ι → Prop) (s : ι → Set α) extends IsBasis p s : Prop where
    countable : (setOf p).Countable
Arguments: {α : Type u_1} {ι : Type u_4} {p : ι → Prop} {s : ι → Set α} (self : Filter.IsCountableBasis p s)
Goal: (setOf p).Countable
-- Filter.HasCountableBasis.countable
structure HasCountableBasis (l : Filter α) (p : ι → Prop) (s : ι → Set α)
    extends HasBasis l p s : Prop where
    countable : (setOf p).Countable
Arguments: {α : Type u_1} {ι : Type u_4} {l : Filter α} {p : ι → Prop} {s : ι → Set α} (self : l.HasCountableBasis p s)
Goal: (setOf p).Countable
-- Filter.CountableFilterBasis.countable
structure CountableFilterBasis (α : Type*) extends FilterBasis α where
    countable : sets.Countable
Arguments: {α : Type u_6} (self : Filter.CountableFilterBasis α)
Goal: self.sets.Countable
-- Filter.HasCountableBasis.isCountablyGenerated
theorem HasCountableBasis.isCountablyGenerated {f : Filter α} {p : ι → Prop} {s : ι → Set α}
    (h : f.HasCountableBasis p s) : f.IsCountablyGenerated 
Arguments: {α : Type u_1} {ι : Type u_4} {f : Filter α} {p : ι → Prop} {s : ι → Set α} (h : f.HasCountableBasis p s)
Goal: f.IsCountablyGenerated
-- Filter.HasBasis.isCountablyGenerated
theorem HasBasis.isCountablyGenerated [Countable ι] {f : Filter α} {p : ι → Prop} {s : ι → Set α}
    (h : f.HasBasis p s) : f.IsCountablyGenerated 
Arguments: {α : Type u_1} {ι : Type u_4} [Countable ι] {f : Filter α} {p : ι → Prop} {s : ι → Set α} (h : f.HasBasis p s)
Goal: f.IsCountablyGenerated
-- Filter.antitone_seq_of_seq
theorem antitone_seq_of_seq (s : ℕ → Set α) :
    ∃ t : ℕ → Set α, Antitone t ∧ ⨅ i, 𝓟 (s i) = ⨅ i, 𝓟 (t i) 
Arguments: {α : Type u_1} (s : ℕ → Set α)
Goal: ∃ t, Antitone t ∧ ⨅ i, 𝓟 (s i) = ⨅ i, 𝓟 (t i)
-- Filter.countable_biInf_eq_iInf_seq
theorem countable_biInf_eq_iInf_seq [CompleteLattice α] {B : Set ι} (Bcbl : B.Countable)
    (Bne : B.Nonempty) (f : ι → α) : ∃ x : ℕ → ι, ⨅ t ∈ B, f t = ⨅ i, f (x i) 
Arguments: {α : Type u_1} {ι : Type u_4} [CompleteLattice α] {B : Set ι} (Bcbl : B.Countable) (Bne : B.Nonempty) (f : ι → α)
Goal: ∃ x, ⨅ t ∈ B, f t = ⨅ i, f (x i)
-- Filter.countable_biInf_eq_iInf_seq'
theorem countable_biInf_eq_iInf_seq' [CompleteLattice α] {B : Set ι} (Bcbl : B.Countable)
    (f : ι → α) {i₀ : ι} (h : f i₀ = ⊤) : ∃ x : ℕ → ι, ⨅ t ∈ B, f t = ⨅ i, f (x i) 
Arguments: {α : Type u_1} {ι : Type u_4} [CompleteLattice α] {B : Set ι} (Bcbl : B.Countable) (f : ι → α) {i₀ : ι} (h : f i₀ = ⊤)
Goal: ∃ x, ⨅ t ∈ B, f t = ⨅ i, f (x i)
-- Filter.countable_biInf_principal_eq_seq_iInf
theorem countable_biInf_principal_eq_seq_iInf {B : Set (Set α)} (Bcbl : B.Countable) :
    ∃ x : ℕ → Set α, ⨅ t ∈ B, 𝓟 t = ⨅ i, 𝓟 (x i) 
Arguments: {α : Type u_1} {B : Set (Set α)} (Bcbl : B.Countable)
Goal: ∃ x, ⨅ t ∈ B, 𝓟 t = ⨅ i, 𝓟 (x i)
-- Filter.HasAntitoneBasis.mem_iff
protected theorem HasAntitoneBasis.mem_iff [Preorder ι] {l : Filter α} {s : ι → Set α}
    (hs : l.HasAntitoneBasis s) {t : Set α} : t ∈ l ↔ ∃ i, s i ⊆ t 
Arguments: {α : Type u_1} {ι : Type u_4} [Preorder ι] {l : Filter α} {s : ι → Set α} (hs : l.HasAntitoneBasis s) {t : Set α}
Goal: t ∈ l ↔ ∃ i, s i ⊆ t
-- Filter.HasAntitoneBasis.mem
protected theorem HasAntitoneBasis.mem [Preorder ι] {l : Filter α} {s : ι → Set α}
    (hs : l.HasAntitoneBasis s) (i : ι) : s i ∈ l 
Arguments: {α : Type u_1} {ι : Type u_4} [Preorder ι] {l : Filter α} {s : ι → Set α} (hs : l.HasAntitoneBasis s) (i : ι)
Goal: s i ∈ l
-- Filter.HasAntitoneBasis.hasBasis_ge
theorem HasAntitoneBasis.hasBasis_ge [Preorder ι] [IsDirected ι (· ≤ ·)] {l : Filter α}
    {s : ι → Set α} (hs : l.HasAntitoneBasis s) (i : ι) : l.HasBasis (fun j => i ≤ j) s 
Arguments: {α : Type u_1} {ι : Type u_4} [Preorder ι] [IsDirected ι fun x x_1 => x ≤ x_1] {l : Filter α} {s : ι → Set α} (hs : l.HasAntitoneBasis s) (i : ι)
Goal: l.HasBasis (fun j => i ≤ j) s
-- Filter.HasBasis.exists_antitone_subbasis
theorem HasBasis.exists_antitone_subbasis {f : Filter α} [h : f.IsCountablyGenerated]
    {p : ι' → Prop} {s : ι' → Set α} (hs : f.HasBasis p s) :
    ∃ x : ℕ → ι', (∀ i, p (x i)) ∧ f.HasAntitoneBasis fun i => s (x i) 
Arguments: {α : Type u_1} {ι' : Sort u_5} {f : Filter α} [h : f.IsCountablyGenerated] {p : ι' → Prop} {s : ι' → Set α} (hs : f.HasBasis p s)
Goal: ∃ x, (∀ (i : ℕ), p (x i)) ∧ f.HasAntitoneBasis fun i => s (x i)
-- Filter.exists_antitone_basis
theorem exists_antitone_basis (f : Filter α) [f.IsCountablyGenerated] :
    ∃ x : ℕ → Set α, f.HasAntitoneBasis x 
Arguments: {α : Type u_1} (f : Filter α) [f.IsCountablyGenerated]
Goal: ∃ x, f.HasAntitoneBasis x
-- Filter.exists_antitone_seq
theorem exists_antitone_seq (f : Filter α) [f.IsCountablyGenerated] :
    ∃ x : ℕ → Set α, Antitone x ∧ ∀ {s}, s ∈ f ↔ ∃ i, x i ⊆ s 
Arguments: {α : Type u_1} (f : Filter α) [f.IsCountablyGenerated]
Goal: ∃ x, Antitone x ∧ ∀ {s : Set α}, s ∈ f ↔ ∃ i, x i ⊆ s
-- Filter.isCountablyGenerated_seq
theorem isCountablyGenerated_seq [Countable ι'] (x : ι' → Set α) :
    IsCountablyGenerated (⨅ i, 𝓟 (x i)) 
Arguments: {α : Type u_1} {ι' : Sort u_5} [Countable ι'] (x : ι' → Set α)
Goal: (⨅ i, 𝓟 (x i)).IsCountablyGenerated
-- Filter.isCountablyGenerated_of_seq
theorem isCountablyGenerated_of_seq {f : Filter α} (h : ∃ x : ℕ → Set α, f = ⨅ i, 𝓟 (x i)) :
    f.IsCountablyGenerated 
Arguments: {α : Type u_1} {f : Filter α} (h : ∃ x, f = ⨅ i, 𝓟 (x i))
Goal: f.IsCountablyGenerated
-- Filter.isCountablyGenerated_biInf_principal
theorem isCountablyGenerated_biInf_principal {B : Set (Set α)} (h : B.Countable) :
    IsCountablyGenerated (⨅ s ∈ B, 𝓟 s) 
Arguments: {α : Type u_1} {B : Set (Set α)} (h : B.Countable)
Goal: (⨅ s ∈ B, 𝓟 s).IsCountablyGenerated
-- Filter.isCountablyGenerated_iff_exists_antitone_basis
theorem isCountablyGenerated_iff_exists_antitone_basis {f : Filter α} :
    IsCountablyGenerated f ↔ ∃ x : ℕ → Set α, f.HasAntitoneBasis x 
Arguments: {α : Type u_1} {f : Filter α}
Goal: f.IsCountablyGenerated ↔ ∃ x, f.HasAntitoneBasis x
-- Filter.isCountablyGenerated_principal
@[instance]
theorem isCountablyGenerated_principal (s : Set α) : IsCountablyGenerated (𝓟 s) 
Arguments: {α : Type u_1} (s : Set α)
Goal: (𝓟 s).IsCountablyGenerated
-- Filter.isCountablyGenerated_pure
@[instance]
theorem isCountablyGenerated_pure (a : α) : IsCountablyGenerated (pure a) 
Arguments: {α : Type u_1} (a : α)
Goal: (pure a).IsCountablyGenerated
-- Filter.isCountablyGenerated_bot
@[instance]
theorem isCountablyGenerated_bot : IsCountablyGenerated (⊥ : Filter α) 
Arguments: {α : Type u_1}
Goal: ⊥.IsCountablyGenerated
-- Filter.isCountablyGenerated_top
@[instance]
theorem isCountablyGenerated_top : IsCountablyGenerated (⊤ : Filter α) 
Arguments: {α : Type u_1}
Goal: ⊤.IsCountablyGenerated
-- CardinalInterFilter.cardinal_sInter_mem
class CardinalInterFilter (l : Filter α) (c : Cardinal.{u}) : Prop where
    cardinal_sInter_mem : ∀ S : Set (Set α), (#S < c) → (∀ s ∈ S, s ∈ l) → ⋂₀ S ∈ l
Arguments: {α : Type u} {l : Filter α} {c : Cardinal.{u}} [self : CardinalInterFilter l c] (S : Set (Set α))
Goal: #↑S < c → (∀ s ∈ S, s ∈ l) → ⋂₀ S ∈ l
-- cardinal_sInter_mem
theorem cardinal_sInter_mem {S : Set (Set α)} [CardinalInterFilter l c] (hSc : #S < c) :
    ⋂₀ S ∈ l ↔ ∀ s ∈ S, s ∈ l 
Arguments: {α : Type u} {c : Cardinal.{u}} {l : Filter α} {S : Set (Set α)} [CardinalInterFilter l c] (hSc : #↑S < c)
Goal: ⋂₀ S ∈ l ↔ ∀ s ∈ S, s ∈ l
-- Filter.cardinalInterFilter_aleph0
theorem _root_.Filter.cardinalInterFilter_aleph0 (l : Filter α) : CardinalInterFilter l aleph0 
Arguments: {α : Type u} (l : Filter α)
Goal: CardinalInterFilter l ℵ₀
-- CardinalInterFilter.toCountableInterFilter
theorem CardinalInterFilter.toCountableInterFilter (l : Filter α) [CardinalInterFilter l c]
    (hc : aleph0 < c) : CountableInterFilter l 
Arguments: {α : Type u} {c : Cardinal.{u}} (l : Filter α) [CardinalInterFilter l c] (hc : ℵ₀ < c)
Goal: CountableInterFilter l
-- cardinalInterFilter_aleph_one_iff
theorem cardinalInterFilter_aleph_one_iff :
    CardinalInterFilter l (aleph 1) ↔ CountableInterFilter l 
Arguments: {α : Type u} {l : Filter α}
Goal: CardinalInterFilter l (Cardinal.aleph 1) ↔ CountableInterFilter l
-- CardinalInterFilter.of_cardinalInterFilter_of_le
theorem CardinalInterFilter.of_cardinalInterFilter_of_le (l : Filter α) [CardinalInterFilter l c]
    {a : Cardinal.{u}} (hac : a ≤ c) :
    CardinalInterFilter l a 
Arguments: {α : Type u} {c : Cardinal.{u}} (l : Filter α) [CardinalInterFilter l c] {a : Cardinal.{u}} (hac : a ≤ c)
Goal: CardinalInterFilter l a
-- CardinalInterFilter.of_cardinalInterFilter_of_lt
theorem CardinalInterFilter.of_cardinalInterFilter_of_lt (l : Filter α) [CardinalInterFilter l c]
    {a : Cardinal.{u}} (hac : a < c) : CardinalInterFilter l a 
Arguments: {α : Type u} {c : Cardinal.{u}} (l : Filter α) [CardinalInterFilter l c] {a : Cardinal.{u}} (hac : a < c)
Goal: CardinalInterFilter l a
-- Filter.cardinal_iInter_mem
theorem cardinal_iInter_mem {s : ι → Set α} (hic : #ι < c) :
    (⋂ i, s i) ∈ l ↔ ∀ i, s i ∈ l 
Arguments: {ι α : Type u} {c : Cardinal.{u}} {l : Filter α} [CardinalInterFilter l c] {s : ι → Set α} (hic : #ι < c)
Goal: ⋂ i, s i ∈ l ↔ ∀ (i : ι), s i ∈ l
-- Filter.cardinal_bInter_mem
theorem cardinal_bInter_mem {S : Set ι} (hS : #S < c)
    {s : ∀ i ∈ S, Set α} :
    (⋂ i, ⋂ hi : i ∈ S, s i ‹_›) ∈ l ↔ ∀ i, ∀ hi : i ∈ S, s i ‹_› ∈ l 
Arguments: {ι α : Type u} {c : Cardinal.{u}} {l : Filter α} [CardinalInterFilter l c] {S : Set ι} (hS : #↑S < c) {s : (i : ι) → i ∈ S → Set α}
Goal: ⋂ i, ⋂ (hi : i ∈ S), s i hi ∈ l ↔ ∀ (i : ι) (hi : i ∈ S), s i hi ∈ l
-- Filter.eventually_cardinal_forall
theorem eventually_cardinal_forall {p : α → ι → Prop} (hic : #ι < c) :
    (∀ᶠ x in l, ∀ i, p x i) ↔ ∀ i, ∀ᶠ x in l, p x i 
Arguments: {ι α : Type u} {c : Cardinal.{u}} {l : Filter α} [CardinalInterFilter l c] {p : α → ι → Prop} (hic : #ι < c)
Goal: (∀ᶠ (x : α) in l, ∀ (i : ι), p x i) ↔ ∀ (i : ι), ∀ᶠ (x : α) in l, p x i
-- Filter.eventually_cardinal_ball
theorem eventually_cardinal_ball {S : Set ι} (hS : #S < c)
    {p : α → ∀ i ∈ S, Prop} :
    (∀ᶠ x in l, ∀ i hi, p x i hi) ↔ ∀ i hi, ∀ᶠ x in l, p x i hi 
Arguments: {ι α : Type u} {c : Cardinal.{u}} {l : Filter α} [CardinalInterFilter l c] {S : Set ι} (hS : #↑S < c) {p : α → (i : ι) → i ∈ S → Prop}
Goal: (∀ᶠ (x : α) in l, ∀ (i : ι) (hi : i ∈ S), p x i hi) ↔ ∀ (i : ι) (hi : i ∈ S), ∀ᶠ (x : α) in l, p x i hi
-- Filter.EventuallyLE.cardinal_iUnion
theorem EventuallyLE.cardinal_iUnion {s t : ι → Set α} (hic : #ι < c)
    (h : ∀ i, s i ≤ᶠ[l] t i) : ⋃ i, s i ≤ᶠ[l] ⋃ i, t i 
Arguments: {ι α : Type u} {c : Cardinal.{u}} {l : Filter α} [CardinalInterFilter l c] {s t : ι → Set α} (hic : #ι < c) (h : ∀ (i : ι), s i ≤ᶠ[l] t i)
Goal: ⋃ i, s i ≤ᶠ[l] ⋃ i, t i
-- Filter.EventuallyEq.cardinal_iUnion
theorem EventuallyEq.cardinal_iUnion {s t : ι → Set α} (hic : #ι < c)
    (h : ∀ i, s i =ᶠ[l] t i) : ⋃ i, s i =ᶠ[l] ⋃ i, t i 
Arguments: {ι α : Type u} {c : Cardinal.{u}} {l : Filter α} [CardinalInterFilter l c] {s t : ι → Set α} (hic : #ι < c) (h : ∀ (i : ι), s i =ᶠ[l] t i)
Goal: ⋃ i, s i =ᶠ[l] ⋃ i, t i
-- Filter.EventuallyLE.cardinal_bUnion
theorem EventuallyLE.cardinal_bUnion {S : Set ι} (hS : #S < c)
    {s t : ∀ i ∈ S, Set α} (h : ∀ i hi, s i hi ≤ᶠ[l] t i hi) :
    ⋃ i ∈ S, s i ‹_› ≤ᶠ[l] ⋃ i ∈ S, t i ‹_› 
Arguments: {ι α : Type u} {c : Cardinal.{u}} {l : Filter α} [CardinalInterFilter l c] {S : Set ι} (hS : #↑S < c) {s t : (i : ι) → i ∈ S → Set α} (h : ∀ (i : ι) (hi : i ∈ S), s i hi ≤ᶠ[l] t i hi)
Goal: ⋃ i, ⋃ (h : i ∈ S), s i h ≤ᶠ[l] ⋃ i, ⋃ (h : i ∈ S), t i h
-- Filter.EventuallyEq.cardinal_bUnion
theorem EventuallyEq.cardinal_bUnion {S : Set ι} (hS : #S < c)
    {s t : ∀ i ∈ S, Set α} (h : ∀ i hi, s i hi =ᶠ[l] t i hi) :
    ⋃ i ∈ S, s i ‹_› =ᶠ[l] ⋃ i ∈ S, t i ‹_› 
Arguments: {ι α : Type u} {c : Cardinal.{u}} {l : Filter α} [CardinalInterFilter l c] {S : Set ι} (hS : #↑S < c) {s t : (i : ι) → i ∈ S → Set α} (h : ∀ (i : ι) (hi : i ∈ S), s i hi =ᶠ[l] t i hi)
Goal: ⋃ i, ⋃ (h : i ∈ S), s i h =ᶠ[l] ⋃ i, ⋃ (h : i ∈ S), t i h
-- Filter.EventuallyLE.cardinal_iInter
theorem EventuallyLE.cardinal_iInter {s t : ι → Set α} (hic : #ι < c)
    (h : ∀ i, s i ≤ᶠ[l] t i) : ⋂ i, s i ≤ᶠ[l] ⋂ i, t i 
Arguments: {ι α : Type u} {c : Cardinal.{u}} {l : Filter α} [CardinalInterFilter l c] {s t : ι → Set α} (hic : #ι < c) (h : ∀ (i : ι), s i ≤ᶠ[l] t i)
Goal: ⋂ i, s i ≤ᶠ[l] ⋂ i, t i
-- Filter.EventuallyEq.cardinal_iInter
theorem EventuallyEq.cardinal_iInter {s t : ι → Set α} (hic : #ι < c)
    (h : ∀ i, s i =ᶠ[l] t i) : ⋂ i, s i =ᶠ[l] ⋂ i, t i 
Arguments: {ι α : Type u} {c : Cardinal.{u}} {l : Filter α} [CardinalInterFilter l c] {s t : ι → Set α} (hic : #ι < c) (h : ∀ (i : ι), s i =ᶠ[l] t i)
Goal: ⋂ i, s i =ᶠ[l] ⋂ i, t i
-- Filter.EventuallyLE.cardinal_bInter
theorem EventuallyLE.cardinal_bInter {S : Set ι} (hS : #S < c)
    {s t : ∀ i ∈ S, Set α} (h : ∀ i hi, s i hi ≤ᶠ[l] t i hi) :
    ⋂ i ∈ S, s i ‹_› ≤ᶠ[l] ⋂ i ∈ S, t i ‹_› 
Arguments: {ι α : Type u} {c : Cardinal.{u}} {l : Filter α} [CardinalInterFilter l c] {S : Set ι} (hS : #↑S < c) {s t : (i : ι) → i ∈ S → Set α} (h : ∀ (i : ι) (hi : i ∈ S), s i hi ≤ᶠ[l] t i hi)
Goal: ⋂ i, ⋂ (h : i ∈ S), s i h ≤ᶠ[l] ⋂ i, ⋂ (h : i ∈ S), t i h
-- Filter.EventuallyEq.cardinal_bInter
theorem EventuallyEq.cardinal_bInter {S : Set ι} (hS : #S < c)
    {s t : ∀ i ∈ S, Set α} (h : ∀ i hi, s i hi =ᶠ[l] t i hi) :
    ⋂ i ∈ S, s i ‹_› =ᶠ[l] ⋂ i ∈ S, t i ‹_› 
Arguments: {ι α : Type u} {c : Cardinal.{u}} {l : Filter α} [CardinalInterFilter l c] {S : Set ι} (hS : #↑S < c) {s t : (i : ι) → i ∈ S → Set α} (h : ∀ (i : ι) (hi : i ∈ S), s i hi =ᶠ[l] t i hi)
Goal: ⋂ i, ⋂ (h : i ∈ S), s i h =ᶠ[l] ⋂ i, ⋂ (h : i ∈ S), t i h
-- Filter.mem_ofCardinalInter
@[simp]
theorem mem_ofCardinalInter {l : Set (Set α)} (hc : 2 < c)
    (hl : ∀ S : Set (Set α), (#S < c) → S ⊆ l → ⋂₀ S ∈ l) (h_mono : ∀ s t, s ∈ l → s ⊆ t → t ∈ l)
    {s : Set α} : s ∈ Filter.ofCardinalInter l hc hl h_mono ↔ s ∈ l 
Arguments: {α : Type u} {c : Cardinal.{u}} {l : Set (Set α)} (hc : 2 < c) (hl : ∀ (S : Set (Set α)), #↑S < c → S ⊆ l → ⋂₀ S ∈ l) (h_mono : ∀ (s t : Set α), s ∈ l → s ⊆ t → t ∈ l) {s : Set α}
Goal: s ∈ Filter.ofCardinalInter l hc hl h_mono ↔ s ∈ l
-- Filter.mem_ofCardinalUnion
@[simp]
theorem mem_ofCardinalUnion {l : Set (Set α)} (hc : 2 < c) {hunion hmono s} :
    s ∈ ofCardinalUnion l hc hunion hmono ↔ l sᶜ 
Arguments: {α : Type u} {c : Cardinal.{u}} {l : Set (Set α)} (hc : 2 < c) {hunion : ∀ (S : Set (Set α)), #↑S < c → (∀ s ∈ S, s ∈ l) → ⋃₀ S ∈ l} {hmono : ∀ t ∈ l, ∀ s ⊆ t, s ∈ l} {s : Set α}
Goal: s ∈ Filter.ofCardinalUnion l hc hunion hmono ↔ l sᶜ
-- Filter.cardinalInter_ofCardinalGenerate
lemma cardinalInter_ofCardinalGenerate (hc : 2 < c) :
    CardinalInterFilter (cardinalGenerate g hc) c 
Arguments: {α : Type u} {c : Cardinal.{u}} (g : Set (Set α)) (hc : 2 < c)
Goal: CardinalInterFilter (Filter.cardinalGenerate g hc) c
-- Filter.mem_cardinaleGenerate_iff
theorem mem_cardinaleGenerate_iff {s : Set α} {hreg : c.IsRegular} :
    s ∈ cardinalGenerate g (IsRegular.nat_lt hreg 2) ↔
    ∃ S : Set (Set α), S ⊆ g ∧ (#S < c) ∧ ⋂₀ S ⊆ s 
Arguments: {α : Type u} {c : Cardinal.{u}} {g : Set (Set α)} {s : Set α} {hreg : c.IsRegular}
Goal: s ∈ Filter.cardinalGenerate g ⋯ ↔ ∃ S ⊆ g, #↑S < c ∧ ⋂₀ S ⊆ s
-- Filter.le_cardinalGenerate_iff_of_cardinalInterFilter
theorem le_cardinalGenerate_iff_of_cardinalInterFilter {f : Filter α} [CardinalInterFilter f c]
    (hc : 2 < c) : f ≤ cardinalGenerate g hc ↔ g ⊆ f.sets 
Arguments: {α : Type u} {c : Cardinal.{u}} {g : Set (Set α)} {f : Filter α} [CardinalInterFilter f c] (hc : 2 < c)
Goal: f ≤ Filter.cardinalGenerate g hc ↔ g ⊆ f.sets
-- Filter.cardinalGenerate_isGreatest
theorem cardinalGenerate_isGreatest (hc : 2 < c) :
    IsGreatest { f : Filter α | CardinalInterFilter f c ∧ g ⊆ f.sets } (cardinalGenerate g hc) 
Arguments: {α : Type u} {c : Cardinal.{u}} {g : Set (Set α)} (hc : 2 < c)
Goal: IsGreatest {f | CardinalInterFilter f c ∧ g ⊆ f.sets} (Filter.cardinalGenerate g hc)
-- Filter.lift_top
@[simp]
theorem lift_top (g : Set α → Filter β) : (⊤ : Filter α).lift g = g univ 
Arguments: {α : Type u_1} {β : Type u_2} (g : Set α → Filter β)
Goal: ⊤.lift g = g Set.univ