File: Mathlib/Order/Filter/Bases.lean

full_name: FilterBasis
code: /-- A filter basis `B` on a type `α` is a nonempty collection of sets of `α`
such that the intersection of two elements of this collection contains some element
of the collection. -/
structure FilterBasis (α : Type*) where
  /-- Sets of a filter basis. -/
  sets : Set (Set α)
  /-- The set of filter basis sets is nonempty. -/
  nonempty : sets.Nonempty
  /-- The set of filter basis sets is directed downwards. -/
  inter_sets {x y} : x ∈ sets → y ∈ sets → ∃ z ∈ sets, z ⊆ x ∩ y
goal: Type u_6

full_name: FilterBasis.inter_sets
code: /-- A filter basis `B` on a type `α` is a nonempty collection of sets of `α`
such that the intersection of two elements of this collection contains some element
of the collection. -/
structure FilterBasis (α : Type*) where
  /-- Sets of a filter basis. -/
  sets : Set (Set α)
  /-- The set of filter basis sets is nonempty. -/
  nonempty : sets.Nonempty
  /-- The set of filter basis sets is directed downwards. -/
  inter_sets {x y} : x ∈ sets → y ∈ sets → ∃ z ∈ sets, z ⊆ x ∩ y
goal: x ∈ self.sets → y ∈ self.sets → ∃ z ∈ self.sets, z ⊆ x ∩ y

full_name: FilterBasis.nonempty
code: /-- A filter basis `B` on a type `α` is a nonempty collection of sets of `α`
such that the intersection of two elements of this collection contains some element
of the collection. -/
structure FilterBasis (α : Type*) where
  /-- Sets of a filter basis. -/
  sets : Set (Set α)
  /-- The set of filter basis sets is nonempty. -/
  nonempty : sets.Nonempty
  /-- The set of filter basis sets is directed downwards. -/
  inter_sets {x y} : x ∈ sets → y ∈ sets → ∃ z ∈ sets, z ⊆ x ∩ y
goal: self.sets.Nonempty

full_name: FilterBasis.sets
code: /-- A filter basis `B` on a type `α` is a nonempty collection of sets of `α`
such that the intersection of two elements of this collection contains some element
of the collection. -/
structure FilterBasis (α : Type*) where
  /-- Sets of a filter basis. -/
  sets : Set (Set α)
  /-- The set of filter basis sets is nonempty. -/
  nonempty : sets.Nonempty
  /-- The set of filter basis sets is directed downwards. -/
  inter_sets {x y} : x ∈ sets → y ∈ sets → ∃ z ∈ sets, z ⊆ x ∩ y
goal: Set (Set α)

full_name: FilterBasis.nonempty_sets
code: instance FilterBasis.nonempty_sets (B : FilterBasis α) : Nonempty B.sets 
goal: Nonempty ↑B.sets

full_name: instMembershipSetFilterBasis
code: /-- If `B` is a filter basis on `α`, and `U` a subset of `α` then we can write `U ∈ B` as
on paper. -/
instance {α : Type*} : Membership (Set α) (FilterBasis α) 
goal: Membership (Set α) (FilterBasis α)

full_name: FilterBasis.mem_sets
code: @[simp] theorem FilterBasis.mem_sets {s : Set α} {B : FilterBasis α} : s ∈ B.sets ↔ s ∈ B 
goal: s ∈ B.sets ↔ s ∈ B

full_name: instInhabitedFilterBasisNat
code: instance : Inhabited (FilterBasis ℕ) 
goal: Inhabited (FilterBasis ℕ)

full_name: Filter.asBasis
code: /-- View a filter as a filter basis. -/
def Filter.asBasis (f : Filter α) : FilterBasis α 
goal: FilterBasis α

full_name: Filter.IsBasis.nonempty
code: /-- `is_basis p s` means the image of `s` bounded by `p` is a filter basis. -/
structure Filter.IsBasis (p : ι → Prop) (s : ι → Set α) : Prop where
  /-- There exists at least one `i` that satisfies `p`. -/
  nonempty : ∃ i, p i
  /-- `s` is directed downwards on `i` such that `p i`. -/
  inter : ∀ {i j}, p i → p j → ∃ k, p k ∧ s k ⊆ s i ∩ s j
goal: ∃ i, p i

full_name: Filter.IsBasis.inter
code: /-- `is_basis p s` means the image of `s` bounded by `p` is a filter basis. -/
structure Filter.IsBasis (p : ι → Prop) (s : ι → Set α) : Prop where
  /-- There exists at least one `i` that satisfies `p`. -/
  nonempty : ∃ i, p i
  /-- `s` is directed downwards on `i` such that `p i`. -/
  inter : ∀ {i j}, p i → p j → ∃ k, p k ∧ s k ⊆ s i ∩ s j
goal: p i → p j → ∃ k, p k ∧ s k ⊆ s i ∩ s j

full_name: Filter.IsBasis
code: /-- `is_basis p s` means the image of `s` bounded by `p` is a filter basis. -/
structure Filter.IsBasis (p : ι → Prop) (s : ι → Set α) : Prop where
  /-- There exists at least one `i` that satisfies `p`. -/
  nonempty : ∃ i, p i
  /-- `s` is directed downwards on `i` such that `p i`. -/
  inter : ∀ {i j}, p i → p j → ∃ k, p k ∧ s k ⊆ s i ∩ s j
goal: Prop

full_name: Filter.IsBasis.filterBasis
code: /-- Constructs a filter basis from an indexed family of sets satisfying `IsBasis`. -/
protected def filterBasis {p : ι → Prop} {s : ι → Set α} (h : IsBasis p s) : FilterBasis α 
goal: FilterBasis α

full_name: Filter.IsBasis.mem_filterBasis_iff
code: theorem mem_filterBasis_iff {U : Set α} : U ∈ h.filterBasis ↔ ∃ i, p i ∧ s i = U 
goal: U ∈ h.filterBasis ↔ ∃ i, p i ∧ s i = U

full_name: FilterBasis.filter
code: /-- The filter associated to a filter basis. -/
protected def filter (B : FilterBasis α) : Filter α 
goal: Filter α

full_name: FilterBasis.mem_filter_iff
code: theorem mem_filter_iff (B : FilterBasis α) {U : Set α} : U ∈ B.filter ↔ ∃ s ∈ B, s ⊆ U 
goal: U ∈ B.filter ↔ ∃ s ∈ B, s ⊆ U

full_name: FilterBasis.mem_filter_of_mem
code: theorem mem_filter_of_mem (B : FilterBasis α) {U : Set α} : U ∈ B → U ∈ B.filter 
goal: U ∈ B → U ∈ B.filter

full_name: FilterBasis.eq_iInf_principal
code: theorem eq_iInf_principal (B : FilterBasis α) : B.filter = ⨅ s : B.sets, 𝓟 s 
goal: B.filter = ⨅ s, 𝓟 ↑s

full_name: FilterBasis.generate
code: protected theorem generate (B : FilterBasis α) : generate B.sets = B.filter 
goal: Filter.generate B.sets = B.filter

full_name: Filter.IsBasis.filter
code: /-- Constructs a filter from an indexed family of sets satisfying `IsBasis`. -/
protected def filter (h : IsBasis p s) : Filter α 
goal: Filter α

full_name: Filter.IsBasis.mem_filter_iff
code: protected theorem mem_filter_iff (h : IsBasis p s) {U : Set α} :
    U ∈ h.filter ↔ ∃ i, p i ∧ s i ⊆ U 
goal: U ∈ h.filter ↔ ∃ i, p i ∧ s i ⊆ U

full_name: Filter.IsBasis.filter_eq_generate
code: theorem filter_eq_generate (h : IsBasis p s) : h.filter = generate { U | ∃ i, p i ∧ s i = U } 
goal: h.filter = Filter.generate {U | ∃ i, p i ∧ s i = U}

full_name: Filter.HasBasis
code: /-- We say that a filter `l` has a basis `s : ι → Set α` bounded by `p : ι → Prop`,
if `t ∈ l` if and only if `t` includes `s i` for some `i` such that `p i`. -/
structure HasBasis (l : Filter α) (p : ι → Prop) (s : ι → Set α) : Prop where
  /-- A set `t` belongs to a filter `l` iff it includes an element of the basis. -/
  mem_iff' : ∀ t : Set α, t ∈ l ↔ ∃ i, p i ∧ s i ⊆ t
goal: Prop

full_name: Filter.HasBasis.mem_iff'
code: /-- We say that a filter `l` has a basis `s : ι → Set α` bounded by `p : ι → Prop`,
if `t ∈ l` if and only if `t` includes `s i` for some `i` such that `p i`. -/
structure HasBasis (l : Filter α) (p : ι → Prop) (s : ι → Set α) : Prop where
  /-- A set `t` belongs to a filter `l` iff it includes an element of the basis. -/
  mem_iff' : ∀ t : Set α, t ∈ l ↔ ∃ i, p i ∧ s i ⊆ t
goal: t ∈ l ↔ ∃ i, p i ∧ s i ⊆ t

full_name: Filter.hasBasis_generate
code: theorem hasBasis_generate (s : Set (Set α)) :
    (generate s).HasBasis (fun t => Set.Finite t ∧ t ⊆ s) fun t => ⋂₀ t 
goal: (Filter.generate s).HasBasis (fun t => t.Finite ∧ t ⊆ s) fun t => ⋂₀ t

full_name: Filter.FilterBasis.ofSets
code: /-- The smallest filter basis containing a given collection of sets. -/
def FilterBasis.ofSets (s : Set (Set α)) : FilterBasis α 
goal: FilterBasis α

full_name: Filter.FilterBasis.ofSets_sets
code: lemma FilterBasis.ofSets_sets (s : Set (Set α)) :
    (FilterBasis.ofSets s).sets = sInter '' { t | Set.Finite t ∧ t ⊆ s } 
goal: (Filter.FilterBasis.ofSets s).sets = Set.sInter '' {t | t.Finite ∧ t ⊆ s}

full_name: Filter.HasBasis.mem_iff
code: /-- Definition of `HasBasis` unfolded with implicit set argument. -/
theorem HasBasis.mem_iff (hl : l.HasBasis p s) : t ∈ l ↔ ∃ i, p i ∧ s i ⊆ t 
goal: t ∈ l ↔ ∃ i, p i ∧ s i ⊆ t

full_name: Filter.HasBasis.eq_of_same_basis
code: theorem HasBasis.eq_of_same_basis (hl : l.HasBasis p s) (hl' : l'.HasBasis p s) : l = l' 
goal: l = l'

full_name: Filter.hasBasis_iff
code: theorem hasBasis_iff : l.HasBasis p s ↔ ∀ t, t ∈ l ↔ ∃ i, p i ∧ s i ⊆ t 
goal: l.HasBasis p s ↔ ∀ (t : Set α), t ∈ l ↔ ∃ i, p i ∧ s i ⊆ t

full_name: Filter.HasBasis.ex_mem
code: theorem HasBasis.ex_mem (h : l.HasBasis p s) : ∃ i, p i 
goal: ∃ i, p i

full_name: Filter.HasBasis.nonempty
code: protected theorem HasBasis.nonempty (h : l.HasBasis p s) : Nonempty ι 
goal: Nonempty ι

full_name: Filter.IsBasis.hasBasis
code: protected theorem IsBasis.hasBasis (h : IsBasis p s) : HasBasis h.filter p s 
goal: h.filter.HasBasis p s

full_name: Filter.HasBasis.mem_of_superset
code: protected theorem HasBasis.mem_of_superset (hl : l.HasBasis p s) (hi : p i) (ht : s i ⊆ t) :
    t ∈ l 
goal: t ∈ l

full_name: Filter.HasBasis.mem_of_mem
code: theorem HasBasis.mem_of_mem (hl : l.HasBasis p s) (hi : p i) : s i ∈ l 
goal: s i ∈ l

full_name: Filter.HasBasis.index
code: /-- Index of a basis set such that `s i ⊆ t` as an element of `Subtype p`. -/
noncomputable def HasBasis.index (h : l.HasBasis p s) (t : Set α) (ht : t ∈ l) : { i : ι // p i } 
goal: { i // p i }

full_name: Filter.HasBasis.property_index
code: theorem HasBasis.property_index (h : l.HasBasis p s) (ht : t ∈ l) : p (h.index t ht) 
goal: p ↑(h.index t ht)

full_name: Filter.HasBasis.set_index_mem
code: theorem HasBasis.set_index_mem (h : l.HasBasis p s) (ht : t ∈ l) : s (h.index t ht) ∈ l 
goal: s ↑(h.index t ht) ∈ l

full_name: Filter.HasBasis.set_index_subset
code: theorem HasBasis.set_index_subset (h : l.HasBasis p s) (ht : t ∈ l) : s (h.index t ht) ⊆ t 
goal: s ↑(h.index t ht) ⊆ t

full_name: Filter.HasBasis.isBasis
code: theorem HasBasis.isBasis (h : l.HasBasis p s) : IsBasis p s 
goal: Filter.IsBasis p s

full_name: Filter.HasBasis.filter_eq
code: theorem HasBasis.filter_eq (h : l.HasBasis p s) : h.isBasis.filter = l 
goal: ⋯.filter = l

full_name: Filter.HasBasis.eq_generate
code: theorem HasBasis.eq_generate (h : l.HasBasis p s) : l = generate { U | ∃ i, p i ∧ s i = U } 
goal: l = Filter.generate {U | ∃ i, p i ∧ s i = U}

full_name: Filter.generate_eq_generate_inter
code: theorem generate_eq_generate_inter (s : Set (Set α)) :
    generate s = generate (sInter '' { t | Set.Finite t ∧ t ⊆ s }) 
goal: Filter.generate s = Filter.generate (Set.sInter '' {t | t.Finite ∧ t ⊆ s})

full_name: Filter.ofSets_filter_eq_generate
code: theorem ofSets_filter_eq_generate (s : Set (Set α)) :
    (FilterBasis.ofSets s).filter = generate s 
goal: (Filter.FilterBasis.ofSets s).filter = Filter.generate s

full_name: FilterBasis.hasBasis
code: protected theorem _root_.FilterBasis.hasBasis (B : FilterBasis α) :
    HasBasis B.filter (fun s : Set α => s ∈ B) id 
goal: B.filter.HasBasis (fun s => s ∈ B) id

full_name: Filter.HasBasis.to_hasBasis'
code: theorem HasBasis.to_hasBasis' (hl : l.HasBasis p s) (h : ∀ i, p i → ∃ i', p' i' ∧ s' i' ⊆ s i)
    (h' : ∀ i', p' i' → s' i' ∈ l) : l.HasBasis p' s' 
goal: l.HasBasis p' s'

full_name: Filter.HasBasis.to_hasBasis
code: theorem HasBasis.to_hasBasis (hl : l.HasBasis p s) (h : ∀ i, p i → ∃ i', p' i' ∧ s' i' ⊆ s i)
    (h' : ∀ i', p' i' → ∃ i, p i ∧ s i ⊆ s' i') : l.HasBasis p' s' 
goal: l.HasBasis p' s'

full_name: Filter.HasBasis.congr
code: protected lemma HasBasis.congr (hl : l.HasBasis p s) {p' s'} (hp : ∀ i, p i ↔ p' i)
    (hs : ∀ i, p i → s i = s' i) : l.HasBasis p' s' 
goal: l.HasBasis p' s'

full_name: Filter.HasBasis.to_subset
code: theorem HasBasis.to_subset (hl : l.HasBasis p s) {t : ι → Set α} (h : ∀ i, p i → t i ⊆ s i)
    (ht : ∀ i, p i → t i ∈ l) : l.HasBasis p t 
goal: l.HasBasis p t

full_name: Filter.HasBasis.eventually_iff
code: theorem HasBasis.eventually_iff (hl : l.HasBasis p s) {q : α → Prop} :
    (∀ᶠ x in l, q x) ↔ ∃ i, p i ∧ ∀ ⦃x⦄, x ∈ s i → q x 
goal: (∀ᶠ (x : α) in l, q x) ↔ ∃ i, p i ∧ ∀ ⦃x : α⦄, x ∈ s i → q x

full_name: Filter.HasBasis.frequently_iff
code: theorem HasBasis.frequently_iff (hl : l.HasBasis p s) {q : α → Prop} :
    (∃ᶠ x in l, q x) ↔ ∀ i, p i → ∃ x ∈ s i, q x 
goal: (∃ᶠ (x : α) in l, q x) ↔ ∀ (i : ι), p i → ∃ x ∈ s i, q x

full_name: Filter.HasBasis.exists_iff
code: theorem HasBasis.exists_iff (hl : l.HasBasis p s) {P : Set α → Prop}
    (mono : ∀ ⦃s t⦄, s ⊆ t → P t → P s) : (∃ s ∈ l, P s) ↔ ∃ i, p i ∧ P (s i) 
goal: (∃ s ∈ l, P s) ↔ ∃ i, p i ∧ P (s i)

full_name: Filter.HasBasis.forall_iff
code: theorem HasBasis.forall_iff (hl : l.HasBasis p s) {P : Set α → Prop}
    (mono : ∀ ⦃s t⦄, s ⊆ t → P s → P t) : (∀ s ∈ l, P s) ↔ ∀ i, p i → P (s i) 
goal: (∀ s ∈ l, P s) ↔ ∀ (i : ι), p i → P (s i)

full_name: Filter.HasBasis.neBot_iff
code: protected theorem HasBasis.neBot_iff (hl : l.HasBasis p s) :
    NeBot l ↔ ∀ {i}, p i → (s i).Nonempty 
goal: l.NeBot ↔ ∀ {i : ι}, p i → (s i).Nonempty

full_name: Filter.HasBasis.eq_bot_iff
code: theorem HasBasis.eq_bot_iff (hl : l.HasBasis p s) : l = ⊥ ↔ ∃ i, p i ∧ s i = ∅ 
goal: l = ⊥ ↔ ∃ i, p i ∧ s i = ∅

full_name: Filter.generate_neBot_iff
code: theorem generate_neBot_iff {s : Set (Set α)} :
    NeBot (generate s) ↔ ∀ t, t ⊆ s → t.Finite → (⋂₀ t).Nonempty 
goal: (Filter.generate s).NeBot ↔ ∀ t ⊆ s, t.Finite → (⋂₀ t).Nonempty

full_name: Filter.basis_sets
code: theorem basis_sets (l : Filter α) : l.HasBasis (fun s : Set α => s ∈ l) id 
goal: l.HasBasis (fun s => s ∈ l) id

full_name: Filter.asBasis_filter
code: theorem asBasis_filter (f : Filter α) : f.asBasis.filter = f 
goal: f.asBasis.filter = f

full_name: Filter.hasBasis_self
code: theorem hasBasis_self {l : Filter α} {P : Set α → Prop} :
    HasBasis l (fun s => s ∈ l ∧ P s) id ↔ ∀ t ∈ l, ∃ r ∈ l, P r ∧ r ⊆ t 
goal: l.HasBasis (fun s => s ∈ l ∧ P s) id ↔ ∀ t ∈ l, ∃ r ∈ l, P r ∧ r ⊆ t

full_name: Filter.HasBasis.comp_surjective
code: theorem HasBasis.comp_surjective (h : l.HasBasis p s) {g : ι' → ι} (hg : Function.Surjective g) :
    l.HasBasis (p ∘ g) (s ∘ g) 
goal: l.HasBasis (p ∘ g) (s ∘ g)

full_name: Filter.HasBasis.comp_equiv
code: theorem HasBasis.comp_equiv (h : l.HasBasis p s) (e : ι' ≃ ι) : l.HasBasis (p ∘ e) (s ∘ e) 
goal: l.HasBasis (p ∘ ⇑e) (s ∘ ⇑e)

full_name: Filter.HasBasis.to_image_id'
code: theorem HasBasis.to_image_id' (h : l.HasBasis p s) : l.HasBasis (fun t ↦ ∃ i, p i ∧ s i = t) id 
goal: l.HasBasis (fun t => ∃ i, p i ∧ s i = t) id

full_name: Filter.HasBasis.to_image_id
code: theorem HasBasis.to_image_id {ι : Type*} {p : ι → Prop} {s : ι → Set α} (h : l.HasBasis p s) :
    l.HasBasis (· ∈ s '' {i | p i}) id 
goal: l.HasBasis (fun x => x ∈ s '' {i | p i}) id

full_name: Filter.HasBasis.restrict
code: /-- If `{s i | p i}` is a basis of a filter `l` and each `s i` includes `s j` such that
`p j ∧ q j`, then `{s j | p j ∧ q j}` is a basis of `l`. -/
theorem HasBasis.restrict (h : l.HasBasis p s) {q : ι → Prop}
    (hq : ∀ i, p i → ∃ j, p j ∧ q j ∧ s j ⊆ s i) : l.HasBasis (fun i => p i ∧ q i) s 
goal: l.HasBasis (fun i => p i ∧ q i) s

full_name: Filter.HasBasis.restrict_subset
code: /-- If `{s i | p i}` is a basis of a filter `l` and `V ∈ l`, then `{s i | p i ∧ s i ⊆ V}`
is a basis of `l`. -/
theorem HasBasis.restrict_subset (h : l.HasBasis p s) {V : Set α} (hV : V ∈ l) :
    l.HasBasis (fun i => p i ∧ s i ⊆ V) s 
goal: l.HasBasis (fun i => p i ∧ s i ⊆ V) s

full_name: Filter.HasBasis.hasBasis_self_subset
code: theorem HasBasis.hasBasis_self_subset {p : Set α → Prop} (h : l.HasBasis (fun s => s ∈ l ∧ p s) id)
    {V : Set α} (hV : V ∈ l) : l.HasBasis (fun s => s ∈ l ∧ p s ∧ s ⊆ V) id 
goal: l.HasBasis (fun s => s ∈ l ∧ p s ∧ s ⊆ V) id

full_name: Filter.HasBasis.ge_iff
code: theorem HasBasis.ge_iff (hl' : l'.HasBasis p' s') : l ≤ l' ↔ ∀ i', p' i' → s' i' ∈ l 
goal: l ≤ l' ↔ ∀ (i' : ι'), p' i' → s' i' ∈ l

full_name: Filter.HasBasis.le_iff
code: theorem HasBasis.le_iff (hl : l.HasBasis p s) : l ≤ l' ↔ ∀ t ∈ l', ∃ i, p i ∧ s i ⊆ t 
goal: l ≤ l' ↔ ∀ t ∈ l', ∃ i, p i ∧ s i ⊆ t

full_name: Filter.HasBasis.le_basis_iff
code: theorem HasBasis.le_basis_iff (hl : l.HasBasis p s) (hl' : l'.HasBasis p' s') :
    l ≤ l' ↔ ∀ i', p' i' → ∃ i, p i ∧ s i ⊆ s' i' 
goal: l ≤ l' ↔ ∀ (i' : ι'), p' i' → ∃ i, p i ∧ s i ⊆ s' i'

full_name: Filter.HasBasis.ext
code: theorem HasBasis.ext (hl : l.HasBasis p s) (hl' : l'.HasBasis p' s')
    (h : ∀ i, p i → ∃ i', p' i' ∧ s' i' ⊆ s i) (h' : ∀ i', p' i' → ∃ i, p i ∧ s i ⊆ s' i') :
    l = l' 
goal: l = l'

full_name: Filter.HasBasis.inf'
code: theorem HasBasis.inf' (hl : l.HasBasis p s) (hl' : l'.HasBasis p' s') :
    (l ⊓ l').HasBasis (fun i : PProd ι ι' => p i.1 ∧ p' i.2) fun i => s i.1 ∩ s' i.2 
goal: (l ⊓ l').HasBasis (fun i => p i.fst ∧ p' i.snd) fun i => s i.fst ∩ s' i.snd

full_name: Filter.HasBasis.inf
code: theorem HasBasis.inf {ι ι' : Type*} {p : ι → Prop} {s : ι → Set α} {p' : ι' → Prop}
    {s' : ι' → Set α} (hl : l.HasBasis p s) (hl' : l'.HasBasis p' s') :
    (l ⊓ l').HasBasis (fun i : ι × ι' => p i.1 ∧ p' i.2) fun i => s i.1 ∩ s' i.2 
goal: (l ⊓ l').HasBasis (fun i => p i.1 ∧ p' i.2) fun i => s i.1 ∩ s' i.2

full_name: Filter.hasBasis_iInf'
code: theorem hasBasis_iInf' {ι : Type*} {ι' : ι → Type*} {l : ι → Filter α} {p : ∀ i, ι' i → Prop}
    {s : ∀ i, ι' i → Set α} (hl : ∀ i, (l i).HasBasis (p i) (s i)) :
    (⨅ i, l i).HasBasis (fun If : Set ι × ∀ i, ι' i => If.1.Finite ∧ ∀ i ∈ If.1, p i (If.2 i))
      fun If : Set ι × ∀ i, ι' i => ⋂ i ∈ If.1, s i (If.2 i) 
goal: (⨅ i, l i).HasBasis (fun If => If.1.Finite ∧ ∀ i ∈ If.1, p i (If.2 i)) fun If => ⋂ i ∈ If.1, s i (If.2 i)

full_name: Filter.hasBasis_iInf
code: theorem hasBasis_iInf {ι : Type*} {ι' : ι → Type*} {l : ι → Filter α} {p : ∀ i, ι' i → Prop}
    {s : ∀ i, ι' i → Set α} (hl : ∀ i, (l i).HasBasis (p i) (s i)) :
    (⨅ i, l i).HasBasis
      (fun If : Σ I : Set ι, ∀ i : I, ι' i => If.1.Finite ∧ ∀ i : If.1, p i (If.2 i)) fun If =>
      ⋂ i : If.1, s i (If.2 i) 
goal: (⨅ i, l i).HasBasis (fun If => If.fst.Finite ∧ ∀ (i : ↑If.fst), p (↑i) (If.snd i)) fun If => ⋂ i, s (↑i) (If.snd i)

full_name: Filter.hasBasis_iInf_of_directed'
code: theorem hasBasis_iInf_of_directed' {ι : Type*} {ι' : ι → Sort _} [Nonempty ι] {l : ι → Filter α}
    (s : ∀ i, ι' i → Set α) (p : ∀ i, ι' i → Prop) (hl : ∀ i, (l i).HasBasis (p i) (s i))
    (h : Directed (· ≥ ·) l) :
    (⨅ i, l i).HasBasis (fun ii' : Σi, ι' i => p ii'.1 ii'.2) fun ii' => s ii'.1 ii'.2 
goal: (⨅ i, l i).HasBasis (fun ii' => p ii'.fst ii'.snd) fun ii' => s ii'.fst ii'.snd

full_name: Filter.hasBasis_iInf_of_directed
code: theorem hasBasis_iInf_of_directed {ι : Type*} {ι' : Sort _} [Nonempty ι] {l : ι → Filter α}
    (s : ι → ι' → Set α) (p : ι → ι' → Prop) (hl : ∀ i, (l i).HasBasis (p i) (s i))
    (h : Directed (· ≥ ·) l) :
    (⨅ i, l i).HasBasis (fun ii' : ι × ι' => p ii'.1 ii'.2) fun ii' => s ii'.1 ii'.2 
goal: (⨅ i, l i).HasBasis (fun ii' => p ii'.1 ii'.2) fun ii' => s ii'.1 ii'.2

full_name: Filter.hasBasis_biInf_of_directed'
code: theorem hasBasis_biInf_of_directed' {ι : Type*} {ι' : ι → Sort _} {dom : Set ι}
    (hdom : dom.Nonempty) {l : ι → Filter α} (s : ∀ i, ι' i → Set α) (p : ∀ i, ι' i → Prop)
    (hl : ∀ i ∈ dom, (l i).HasBasis (p i) (s i)) (h : DirectedOn (l ⁻¹'o GE.ge) dom) :
    (⨅ i ∈ dom, l i).HasBasis (fun ii' : Σi, ι' i => ii'.1 ∈ dom ∧ p ii'.1 ii'.2) fun ii' =>
      s ii'.1 ii'.2 
goal: (⨅ i ∈ dom, l i).HasBasis (fun ii' => ii'.fst ∈ dom ∧ p ii'.fst ii'.snd) fun ii' => s ii'.fst ii'.snd

full_name: Filter.hasBasis_biInf_of_directed
code: theorem hasBasis_biInf_of_directed {ι : Type*} {ι' : Sort _} {dom : Set ι} (hdom : dom.Nonempty)
    {l : ι → Filter α} (s : ι → ι' → Set α) (p : ι → ι' → Prop)
    (hl : ∀ i ∈ dom, (l i).HasBasis (p i) (s i)) (h : DirectedOn (l ⁻¹'o GE.ge) dom) :
    (⨅ i ∈ dom, l i).HasBasis (fun ii' : ι × ι' => ii'.1 ∈ dom ∧ p ii'.1 ii'.2) fun ii' =>
      s ii'.1 ii'.2 
goal: (⨅ i ∈ dom, l i).HasBasis (fun ii' => ii'.1 ∈ dom ∧ p ii'.1 ii'.2) fun ii' => s ii'.1 ii'.2

full_name: Filter.hasBasis_principal
code: theorem hasBasis_principal (t : Set α) : (𝓟 t).HasBasis (fun _ : Unit => True) fun _ => t 
goal: (𝓟 t).HasBasis (fun x => True) fun x => t

full_name: Filter.hasBasis_pure
code: theorem hasBasis_pure (x : α) :
    (pure x : Filter α).HasBasis (fun _ : Unit => True) fun _ => {x} 
goal: (pure x).HasBasis (fun x => True) fun x_1 => {x}

full_name: Filter.HasBasis.sup'
code: theorem HasBasis.sup' (hl : l.HasBasis p s) (hl' : l'.HasBasis p' s') :
    (l ⊔ l').HasBasis (fun i : PProd ι ι' => p i.1 ∧ p' i.2) fun i => s i.1 ∪ s' i.2 
goal: (l ⊔ l').HasBasis (fun i => p i.fst ∧ p' i.snd) fun i => s i.fst ∪ s' i.snd

full_name: Filter.HasBasis.sup
code: theorem HasBasis.sup {ι ι' : Type*} {p : ι → Prop} {s : ι → Set α} {p' : ι' → Prop}
    {s' : ι' → Set α} (hl : l.HasBasis p s) (hl' : l'.HasBasis p' s') :
    (l ⊔ l').HasBasis (fun i : ι × ι' => p i.1 ∧ p' i.2) fun i => s i.1 ∪ s' i.2 
goal: (l ⊔ l').HasBasis (fun i => p i.1 ∧ p' i.2) fun i => s i.1 ∪ s' i.2

full_name: Filter.hasBasis_iSup
code: theorem hasBasis_iSup {ι : Sort*} {ι' : ι → Type*} {l : ι → Filter α} {p : ∀ i, ι' i → Prop}
    {s : ∀ i, ι' i → Set α} (hl : ∀ i, (l i).HasBasis (p i) (s i)) :
    (⨆ i, l i).HasBasis (fun f : ∀ i, ι' i => ∀ i, p i (f i)) fun f : ∀ i, ι' i => ⋃ i, s i (f i) 
goal: (⨆ i, l i).HasBasis (fun f => ∀ (i : ι), p i (f i)) fun f => ⋃ i, s i (f i)

full_name: Filter.HasBasis.sup_principal
code: theorem HasBasis.sup_principal (hl : l.HasBasis p s) (t : Set α) :
    (l ⊔ 𝓟 t).HasBasis p fun i => s i ∪ t 
goal: (l ⊔ 𝓟 t).HasBasis p fun i => s i ∪ t

full_name: Filter.HasBasis.sup_pure
code: theorem HasBasis.sup_pure (hl : l.HasBasis p s) (x : α) :
    (l ⊔ pure x).HasBasis p fun i => s i ∪ {x} 
goal: (l ⊔ pure x).HasBasis p fun i => s i ∪ {x}

full_name: Filter.HasBasis.inf_principal
code: theorem HasBasis.inf_principal (hl : l.HasBasis p s) (s' : Set α) :
    (l ⊓ 𝓟 s').HasBasis p fun i => s i ∩ s' 
goal: (l ⊓ 𝓟 s').HasBasis p fun i => s i ∩ s'

full_name: Filter.HasBasis.principal_inf
code: theorem HasBasis.principal_inf (hl : l.HasBasis p s) (s' : Set α) :
    (𝓟 s' ⊓ l).HasBasis p fun i => s' ∩ s i 
goal: (𝓟 s' ⊓ l).HasBasis p fun i => s' ∩ s i

full_name: Filter.HasBasis.inf_basis_neBot_iff
code: theorem HasBasis.inf_basis_neBot_iff (hl : l.HasBasis p s) (hl' : l'.HasBasis p' s') :
    NeBot (l ⊓ l') ↔ ∀ ⦃i⦄, p i → ∀ ⦃i'⦄, p' i' → (s i ∩ s' i').Nonempty 
goal: (l ⊓ l').NeBot ↔ ∀ ⦃i : ι⦄, p i → ∀ ⦃i' : ι'⦄, p' i' → (s i ∩ s' i').Nonempty

full_name: Filter.HasBasis.inf_neBot_iff
code: theorem HasBasis.inf_neBot_iff (hl : l.HasBasis p s) :
    NeBot (l ⊓ l') ↔ ∀ ⦃i⦄, p i → ∀ ⦃s'⦄, s' ∈ l' → (s i ∩ s').Nonempty 
goal: (l ⊓ l').NeBot ↔ ∀ ⦃i : ι⦄, p i → ∀ ⦃s' : Set α⦄, s' ∈ l' → (s i ∩ s').Nonempty

full_name: Filter.HasBasis.inf_principal_neBot_iff
code: theorem HasBasis.inf_principal_neBot_iff (hl : l.HasBasis p s) {t : Set α} :
    NeBot (l ⊓ 𝓟 t) ↔ ∀ ⦃i⦄, p i → (s i ∩ t).Nonempty 
goal: (l ⊓ 𝓟 t).NeBot ↔ ∀ ⦃i : ι⦄, p i → (s i ∩ t).Nonempty

full_name: Filter.HasBasis.disjoint_iff
code: theorem HasBasis.disjoint_iff (hl : l.HasBasis p s) (hl' : l'.HasBasis p' s') :
    Disjoint l l' ↔ ∃ i, p i ∧ ∃ i', p' i' ∧ Disjoint (s i) (s' i') 
goal: Disjoint l l' ↔ ∃ i, p i ∧ ∃ i', p' i' ∧ Disjoint (s i) (s' i')

full_name: Disjoint.exists_mem_filter_basis
code: theorem _root_.Disjoint.exists_mem_filter_basis (h : Disjoint l l') (hl : l.HasBasis p s)
    (hl' : l'.HasBasis p' s') : ∃ i, p i ∧ ∃ i', p' i' ∧ Disjoint (s i) (s' i') 
goal: ∃ i, p i ∧ ∃ i', p' i' ∧ Disjoint (s i) (s' i')

full_name: Pairwise.exists_mem_filter_basis_of_disjoint
code: theorem _root_.Pairwise.exists_mem_filter_basis_of_disjoint {I} [Finite I] {l : I → Filter α}
    {ι : I → Sort*} {p : ∀ i, ι i → Prop} {s : ∀ i, ι i → Set α} (hd : Pairwise (Disjoint on l))
    (h : ∀ i, (l i).HasBasis (p i) (s i)) :
    ∃ ind : ∀ i, ι i, (∀ i, p i (ind i)) ∧ Pairwise (Disjoint on fun i => s i (ind i)) 
goal: ∃ ind, (∀ (i : I), p i (ind i)) ∧ Pairwise (Disjoint on fun i => s i (ind i))

full_name: Set.PairwiseDisjoint.exists_mem_filter_basis
code: theorem _root_.Set.PairwiseDisjoint.exists_mem_filter_basis {I : Type*} {l : I → Filter α}
    {ι : I → Sort*} {p : ∀ i, ι i → Prop} {s : ∀ i, ι i → Set α} {S : Set I}
    (hd : S.PairwiseDisjoint l) (hS : S.Finite) (h : ∀ i, (l i).HasBasis (p i) (s i)) :
    ∃ ind : ∀ i, ι i, (∀ i, p i (ind i)) ∧ S.PairwiseDisjoint fun i => s i (ind i) 
goal: ∃ ind, (∀ (i : I), p i (ind i)) ∧ S.PairwiseDisjoint fun i => s i (ind i)

full_name: Filter.inf_neBot_iff
code: theorem inf_neBot_iff :
    NeBot (l ⊓ l') ↔ ∀ ⦃s : Set α⦄, s ∈ l → ∀ ⦃s'⦄, s' ∈ l' → (s ∩ s').Nonempty 
goal: (l ⊓ l').NeBot ↔ ∀ ⦃s : Set α⦄, s ∈ l → ∀ ⦃s' : Set α⦄, s' ∈ l' → (s ∩ s').Nonempty

full_name: Filter.inf_principal_neBot_iff
code: theorem inf_principal_neBot_iff {s : Set α} : NeBot (l ⊓ 𝓟 s) ↔ ∀ U ∈ l, (U ∩ s).Nonempty 
goal: (l ⊓ 𝓟 s).NeBot ↔ ∀ U ∈ l, (U ∩ s).Nonempty

full_name: Filter.mem_iff_inf_principal_compl
code: theorem mem_iff_inf_principal_compl {f : Filter α} {s : Set α} : s ∈ f ↔ f ⊓ 𝓟 sᶜ = ⊥ 
goal: s ∈ f ↔ f ⊓ 𝓟 sᶜ = ⊥

full_name: Filter.not_mem_iff_inf_principal_compl
code: theorem not_mem_iff_inf_principal_compl {f : Filter α} {s : Set α} : s ∉ f ↔ NeBot (f ⊓ 𝓟 sᶜ) 
goal: s ∉ f ↔ (f ⊓ 𝓟 sᶜ).NeBot

full_name: Filter.disjoint_principal_right
code: @[simp]
theorem disjoint_principal_right {f : Filter α} {s : Set α} : Disjoint f (𝓟 s) ↔ sᶜ ∈ f 
goal: Disjoint f (𝓟 s) ↔ sᶜ ∈ f

full_name: Filter.disjoint_principal_left
code: @[simp]
theorem disjoint_principal_left {f : Filter α} {s : Set α} : Disjoint (𝓟 s) f ↔ sᶜ ∈ f 
goal: Disjoint (𝓟 s) f ↔ sᶜ ∈ f

full_name: Filter.disjoint_principal_principal
code: @[simp 1100] -- Porting note: higher priority for linter
theorem disjoint_principal_principal {s t : Set α} : Disjoint (𝓟 s) (𝓟 t) ↔ Disjoint s t 
goal: Disjoint (𝓟 s) (𝓟 t) ↔ Disjoint s t

full_name: Filter.disjoint_pure_pure
code: @[simp]
theorem disjoint_pure_pure {x y : α} : Disjoint (pure x : Filter α) (pure y) ↔ x ≠ y 
goal: Disjoint (pure x) (pure y) ↔ x ≠ y

full_name: Filter.compl_diagonal_mem_prod
code: @[simp]
theorem compl_diagonal_mem_prod {l₁ l₂ : Filter α} : (diagonal α)ᶜ ∈ l₁ ×ˢ l₂ ↔ Disjoint l₁ l₂ 
goal: (Set.diagonal α)ᶜ ∈ l₁ ×ˢ l₂ ↔ Disjoint l₁ l₂

full_name: Filter.HasBasis.disjoint_iff_left
code: theorem HasBasis.disjoint_iff_left (h : l.HasBasis p s) :
    Disjoint l l' ↔ ∃ i, p i ∧ (s i)ᶜ ∈ l' 
goal: Disjoint l l' ↔ ∃ i, p i ∧ (s i)ᶜ ∈ l'

full_name: Filter.HasBasis.disjoint_iff_right
code: theorem HasBasis.disjoint_iff_right (h : l.HasBasis p s) :
    Disjoint l' l ↔ ∃ i, p i ∧ (s i)ᶜ ∈ l' 
goal: Disjoint l' l ↔ ∃ i, p i ∧ (s i)ᶜ ∈ l'

full_name: Filter.le_iff_forall_inf_principal_compl
code: theorem le_iff_forall_inf_principal_compl {f g : Filter α} : f ≤ g ↔ ∀ V ∈ g, f ⊓ 𝓟 Vᶜ = ⊥ 
goal: f ≤ g ↔ ∀ V ∈ g, f ⊓ 𝓟 Vᶜ = ⊥

full_name: Filter.inf_neBot_iff_frequently_left
code: theorem inf_neBot_iff_frequently_left {f g : Filter α} :
    NeBot (f ⊓ g) ↔ ∀ {p : α → Prop}, (∀ᶠ x in f, p x) → ∃ᶠ x in g, p x 
goal: (f ⊓ g).NeBot ↔ ∀ {p : α → Prop}, (∀ᶠ (x : α) in f, p x) → ∃ᶠ (x : α) in g, p x

full_name: Filter.inf_neBot_iff_frequently_right
code: theorem inf_neBot_iff_frequently_right {f g : Filter α} :
    NeBot (f ⊓ g) ↔ ∀ {p : α → Prop}, (∀ᶠ x in g, p x) → ∃ᶠ x in f, p x 
goal: (f ⊓ g).NeBot ↔ ∀ {p : α → Prop}, (∀ᶠ (x : α) in g, p x) → ∃ᶠ (x : α) in f, p x

full_name: Filter.HasBasis.eq_biInf
code: theorem HasBasis.eq_biInf (h : l.HasBasis p s) : l = ⨅ (i) (_ : p i), 𝓟 (s i) 
goal: l = ⨅ i, ⨅ (_ : p i), 𝓟 (s i)

full_name: Filter.HasBasis.eq_iInf
code: theorem HasBasis.eq_iInf (h : l.HasBasis (fun _ => True) s) : l = ⨅ i, 𝓟 (s i) 
goal: l = ⨅ i, 𝓟 (s i)

full_name: Filter.hasBasis_iInf_principal
code: theorem hasBasis_iInf_principal {s : ι → Set α} (h : Directed (· ≥ ·) s) [Nonempty ι] :
    (⨅ i, 𝓟 (s i)).HasBasis (fun _ => True) s 
goal: (⨅ i, 𝓟 (s i)).HasBasis (fun x => True) s

full_name: Filter.hasBasis_iInf_principal_finite
code: /-- If `s : ι → Set α` is an indexed family of sets, then finite intersections of `s i` form a basis
of `⨅ i, 𝓟 (s i)`.  -/
theorem hasBasis_iInf_principal_finite {ι : Type*} (s : ι → Set α) :
    (⨅ i, 𝓟 (s i)).HasBasis (fun t : Set ι => t.Finite) fun t => ⋂ i ∈ t, s i 
goal: (⨅ i, 𝓟 (s i)).HasBasis (fun t => t.Finite) fun t => ⋂ i ∈ t, s i

full_name: Filter.hasBasis_biInf_principal
code: theorem hasBasis_biInf_principal {s : β → Set α} {S : Set β} (h : DirectedOn (s ⁻¹'o (· ≥ ·)) S)
    (ne : S.Nonempty) : (⨅ i ∈ S, 𝓟 (s i)).HasBasis (fun i => i ∈ S) s 
goal: (⨅ i ∈ S, 𝓟 (s i)).HasBasis (fun i => i ∈ S) s

full_name: Filter.hasBasis_biInf_principal'
code: theorem hasBasis_biInf_principal' {ι : Type*} {p : ι → Prop} {s : ι → Set α}
    (h : ∀ i, p i → ∀ j, p j → ∃ k, p k ∧ s k ⊆ s i ∧ s k ⊆ s j) (ne : ∃ i, p i) :
    (⨅ (i) (_ : p i), 𝓟 (s i)).HasBasis p s 
goal: (⨅ i, ⨅ (_ : p i), 𝓟 (s i)).HasBasis p s

full_name: Filter.HasBasis.map
code: theorem HasBasis.map (f : α → β) (hl : l.HasBasis p s) : (l.map f).HasBasis p fun i => f '' s i 
goal: (Filter.map f l).HasBasis p fun i => f '' s i

full_name: Filter.HasBasis.comap
code: theorem HasBasis.comap (f : β → α) (hl : l.HasBasis p s) :
    (l.comap f).HasBasis p fun i => f ⁻¹' s i 
goal: (Filter.comap f l).HasBasis p fun i => f ⁻¹' s i

full_name: Filter.comap_hasBasis
code: theorem comap_hasBasis (f : α → β) (l : Filter β) :
    HasBasis (comap f l) (fun s : Set β => s ∈ l) fun s => f ⁻¹' s 
goal: (Filter.comap f l).HasBasis (fun s => s ∈ l) fun s => f ⁻¹' s

full_name: Filter.HasBasis.forall_mem_mem
code: theorem HasBasis.forall_mem_mem (h : HasBasis l p s) {x : α} :
    (∀ t ∈ l, x ∈ t) ↔ ∀ i, p i → x ∈ s i 
goal: (∀ t ∈ l, x ∈ t) ↔ ∀ (i : ι), p i → x ∈ s i

full_name: Filter.HasBasis.biInf_mem
code: protected theorem HasBasis.biInf_mem [CompleteLattice β] {f : Set α → β} (h : HasBasis l p s)
    (hf : Monotone f) : ⨅ t ∈ l, f t = ⨅ (i) (_ : p i), f (s i) 
goal: ⨅ t ∈ l, f t = ⨅ i, ⨅ (_ : p i), f (s i)

full_name: Filter.HasBasis.biInter_mem
code: protected theorem HasBasis.biInter_mem {f : Set α → Set β} (h : HasBasis l p s) (hf : Monotone f) :
    ⋂ t ∈ l, f t = ⋂ (i) (_ : p i), f (s i) 
goal: ⋂ t ∈ l, f t = ⋂ i, ⋂ (_ : p i), f (s i)

full_name: Filter.HasBasis.ker
code: protected theorem HasBasis.ker (h : HasBasis l p s) : l.ker = ⋂ (i) (_ : p i), s i 
goal: l.ker = ⋂ i, ⋂ (_ : p i), s i

full_name: Filter.IsAntitoneBasis.antitone
code: /-- `IsAntitoneBasis s` means the image of `s` is a filter basis such that `s` is decreasing. -/
structure IsAntitoneBasis extends IsBasis (fun _ => True) s'' : Prop where
  /-- The sequence of sets is antitone. -/
  protected antitone : Antitone s''
goal: Antitone s''

full_name: Filter.IsAntitoneBasis
code: /-- `IsAntitoneBasis s` means the image of `s` is a filter basis such that `s` is decreasing. -/
structure IsAntitoneBasis extends IsBasis (fun _ => True) s'' : Prop where
  /-- The sequence of sets is antitone. -/
  protected antitone : Antitone s''
goal: Prop

full_name: Filter.HasAntitoneBasis
code: /-- We say that a filter `l` has an antitone basis `s : ι → Set α`, if `t ∈ l` if and only if `t`
includes `s i` for some `i`, and `s` is decreasing. -/
structure HasAntitoneBasis (l : Filter α) (s : ι'' → Set α)
    extends HasBasis l (fun _ => True) s : Prop where
  /-- The sequence of sets is antitone. -/
  protected antitone : Antitone s
goal: Prop

full_name: Filter.HasAntitoneBasis.antitone
code: /-- We say that a filter `l` has an antitone basis `s : ι → Set α`, if `t ∈ l` if and only if `t`
includes `s i` for some `i`, and `s` is decreasing. -/
structure HasAntitoneBasis (l : Filter α) (s : ι'' → Set α)
    extends HasBasis l (fun _ => True) s : Prop where
  /-- The sequence of sets is antitone. -/
  protected antitone : Antitone s
goal: Antitone s

full_name: Filter.HasAntitoneBasis.map
code: protected theorem HasAntitoneBasis.map {l : Filter α} {s : ι'' → Set α}
    (hf : HasAntitoneBasis l s) (m : α → β) : HasAntitoneBasis (map m l) (m '' s ·) 
goal: (Filter.map m l).HasAntitoneBasis fun x => m '' s x

full_name: Filter.HasAntitoneBasis.comap
code: protected theorem HasAntitoneBasis.comap {l : Filter α} {s : ι'' → Set α}
    (hf : HasAntitoneBasis l s) (m : β → α) : HasAntitoneBasis (comap m l) (m ⁻¹' s ·) 
goal: (Filter.comap m l).HasAntitoneBasis fun x => m ⁻¹' s x

full_name: Filter.HasAntitoneBasis.iInf_principal
code: lemma HasAntitoneBasis.iInf_principal {ι : Type*} [Preorder ι] [Nonempty ι] [IsDirected ι (· ≤ ·)]
    {s : ι → Set α} (hs : Antitone s) : (⨅ i, 𝓟 (s i)).HasAntitoneBasis s 
goal: (⨅ i, 𝓟 (s i)).HasAntitoneBasis s

full_name: Filter.HasBasis.tendsto_left_iff
code: theorem HasBasis.tendsto_left_iff (hla : la.HasBasis pa sa) :
    Tendsto f la lb ↔ ∀ t ∈ lb, ∃ i, pa i ∧ MapsTo f (sa i) t 
goal: Filter.Tendsto f la lb ↔ ∀ t ∈ lb, ∃ i, pa i ∧ Set.MapsTo f (sa i) t

full_name: Filter.HasBasis.tendsto_right_iff
code: theorem HasBasis.tendsto_right_iff (hlb : lb.HasBasis pb sb) :
    Tendsto f la lb ↔ ∀ i, pb i → ∀ᶠ x in la, f x ∈ sb i 
goal: Filter.Tendsto f la lb ↔ ∀ (i : ι'), pb i → ∀ᶠ (x : α) in la, f x ∈ sb i

full_name: Filter.HasBasis.tendsto_iff
code: 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 
goal: Filter.Tendsto f la lb ↔ ∀ (ib : ι'), pb ib → ∃ ia, pa ia ∧ ∀ x ∈ sa ia, f x ∈ sb ib

full_name: Filter.Tendsto.basis_left
code: theorem Tendsto.basis_left (H : Tendsto f la lb) (hla : la.HasBasis pa sa) :
    ∀ t ∈ lb, ∃ i, pa i ∧ MapsTo f (sa i) t 
goal: t ∈ lb → ∃ i, pa i ∧ Set.MapsTo f (sa i) t

full_name: Filter.Tendsto.basis_right
code: theorem Tendsto.basis_right (H : Tendsto f la lb) (hlb : lb.HasBasis pb sb) :
    ∀ i, pb i → ∀ᶠ x in la, f x ∈ sb i 
goal: pb i → ∀ᶠ (x : α) in la, f x ∈ sb i

full_name: Filter.Tendsto.basis_both
code: 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) 
goal: pb ib → ∃ ia, pa ia ∧ Set.MapsTo f (sa ia) (sb ib)

full_name: Filter.HasBasis.prod_pprod
code: 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 
goal: (la ×ˢ lb).HasBasis (fun i => pa i.fst ∧ pb i.snd) fun i => sa i.fst ×ˢ sb i.snd

full_name: Filter.HasBasis.prod
code: 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 
goal: (la ×ˢ lb).HasBasis (fun i => pa i.1 ∧ pb i.2) fun i => sa i.1 ×ˢ sb i.2

full_name: Filter.HasBasis.prod_same_index
code: 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 
goal: (la ×ˢ lb).HasBasis p fun i => sa i ×ˢ sb i

full_name: Filter.HasBasis.prod_same_index_mono
code: 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 
goal: (la ×ˢ lb).HasBasis p fun i => sa i ×ˢ sb i

full_name: Filter.HasBasis.prod_same_index_anti
code: 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 
goal: (la ×ˢ lb).HasBasis p fun i => sa i ×ˢ sb i

full_name: Filter.HasBasis.prod_self
code: theorem HasBasis.prod_self (hl : la.HasBasis pa sa) :
    (la ×ˢ la).HasBasis pa fun i => sa i ×ˢ sa i 
goal: (la ×ˢ la).HasBasis pa fun i => sa i ×ˢ sa i

full_name: Filter.mem_prod_self_iff
code: theorem mem_prod_self_iff {s} : s ∈ la ×ˢ la ↔ ∃ t ∈ la, t ×ˢ t ⊆ s 
goal: s ∈ la ×ˢ la ↔ ∃ t ∈ la, t ×ˢ t ⊆ s

full_name: Filter.eventually_prod_self_iff
code: 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 
goal: (∀ᶠ (x : α × α) in la ×ˢ la, r x.1 x.2) ↔ ∃ t ∈ la, ∀ x ∈ t, ∀ y ∈ t, r x y

full_name: Filter.HasAntitoneBasis.prod
code: 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 
goal: (f ×ˢ g).HasAntitoneBasis fun n => s n ×ˢ t n

full_name: Filter.HasBasis.coprod
code: 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 
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

full_name: Filter.map_sigma_mk_comap
code: 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) 
goal: Filter.map (Sigma.mk a) (Filter.comap (g a) l) = Filter.comap (Sigma.map f g) (Filter.map (Sigma.mk (f a)) l)

full_name: Filter.IsCountablyGenerated.out
code: /-- `IsCountablyGenerated f` means `f = generate s` for some countable `s`. -/
class IsCountablyGenerated (f : Filter α) : Prop where
  /-- There exists a countable set that generates the filter. -/
  out : ∃ s : Set (Set α), s.Countable ∧ f = generate s
goal: ∃ s, s.Countable ∧ f = Filter.generate s

full_name: Filter.IsCountablyGenerated
code: /-- `IsCountablyGenerated f` means `f = generate s` for some countable `s`. -/
class IsCountablyGenerated (f : Filter α) : Prop where
  /-- There exists a countable set that generates the filter. -/
  out : ∃ s : Set (Set α), s.Countable ∧ f = generate s
goal: Prop

full_name: Filter.IsCountableBasis.countable
code: /-- `IsCountableBasis p s` means the image of `s` bounded by `p` is a countable filter basis. -/
structure IsCountableBasis (p : ι → Prop) (s : ι → Set α) extends IsBasis p s : Prop where
  /-- The set of `i` that satisfy the predicate `p` is countable. -/
  countable : (setOf p).Countable
goal: (setOf p).Countable

full_name: Filter.IsCountableBasis
code: /-- `IsCountableBasis p s` means the image of `s` bounded by `p` is a countable filter basis. -/
structure IsCountableBasis (p : ι → Prop) (s : ι → Set α) extends IsBasis p s : Prop where
  /-- The set of `i` that satisfy the predicate `p` is countable. -/
  countable : (setOf p).Countable
goal: Prop

full_name: Filter.HasCountableBasis
code: /-- We say that a filter `l` has a countable basis `s : ι → Set α` bounded by `p : ι → Prop`,
if `t ∈ l` if and only if `t` includes `s i` for some `i` such that `p i`, and the set
defined by `p` is countable. -/
structure HasCountableBasis (l : Filter α) (p : ι → Prop) (s : ι → Set α)
    extends HasBasis l p s : Prop where
  /-- The set of `i` that satisfy the predicate `p` is countable. -/
  countable : (setOf p).Countable
goal: Prop

full_name: Filter.HasCountableBasis.countable
code: /-- We say that a filter `l` has a countable basis `s : ι → Set α` bounded by `p : ι → Prop`,
if `t ∈ l` if and only if `t` includes `s i` for some `i` such that `p i`, and the set
defined by `p` is countable. -/
structure HasCountableBasis (l : Filter α) (p : ι → Prop) (s : ι → Set α)
    extends HasBasis l p s : Prop where
  /-- The set of `i` that satisfy the predicate `p` is countable. -/
  countable : (setOf p).Countable
goal: (setOf p).Countable

full_name: Filter.CountableFilterBasis.countable
code: /-- A countable filter basis `B` on a type `α` is a nonempty countable collection of sets of `α`
such that the intersection of two elements of this collection contains some element
of the collection. -/
structure CountableFilterBasis (α : Type*) extends FilterBasis α where
  /-- The set of sets of the filter basis is countable. -/
  countable : sets.Countable
goal: self.sets.Countable

full_name: Filter.CountableFilterBasis
code: /-- A countable filter basis `B` on a type `α` is a nonempty countable collection of sets of `α`
such that the intersection of two elements of this collection contains some element
of the collection. -/
structure CountableFilterBasis (α : Type*) extends FilterBasis α where
  /-- The set of sets of the filter basis is countable. -/
  countable : sets.Countable
goal: Type u_6

full_name: Filter.Nat.inhabitedCountableFilterBasis
code: instance Nat.inhabitedCountableFilterBasis : Inhabited (CountableFilterBasis ℕ) 
goal: Inhabited (Filter.CountableFilterBasis ℕ)

full_name: Filter.HasCountableBasis.isCountablyGenerated
code: theorem HasCountableBasis.isCountablyGenerated {f : Filter α} {p : ι → Prop} {s : ι → Set α}
    (h : f.HasCountableBasis p s) : f.IsCountablyGenerated 
goal: f.IsCountablyGenerated

full_name: Filter.HasBasis.isCountablyGenerated
code: theorem HasBasis.isCountablyGenerated [Countable ι] {f : Filter α} {p : ι → Prop} {s : ι → Set α}
    (h : f.HasBasis p s) : f.IsCountablyGenerated 
goal: f.IsCountablyGenerated

full_name: Filter.antitone_seq_of_seq
code: theorem antitone_seq_of_seq (s : ℕ → Set α) :
    ∃ t : ℕ → Set α, Antitone t ∧ ⨅ i, 𝓟 (s i) = ⨅ i, 𝓟 (t i) 
goal: ∃ t, Antitone t ∧ ⨅ i, 𝓟 (s i) = ⨅ i, 𝓟 (t i)

full_name: Filter.countable_biInf_eq_iInf_seq
code: 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) 
goal: ∃ x, ⨅ t ∈ B, f t = ⨅ i, f (x i)

full_name: Filter.countable_biInf_eq_iInf_seq'
code: 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) 
goal: ∃ x, ⨅ t ∈ B, f t = ⨅ i, f (x i)

full_name: Filter.countable_biInf_principal_eq_seq_iInf
code: theorem countable_biInf_principal_eq_seq_iInf {B : Set (Set α)} (Bcbl : B.Countable) :
    ∃ x : ℕ → Set α, ⨅ t ∈ B, 𝓟 t = ⨅ i, 𝓟 (x i) 
goal: ∃ x, ⨅ t ∈ B, 𝓟 t = ⨅ i, 𝓟 (x i)

full_name: Filter.HasAntitoneBasis.mem_iff
code: protected theorem HasAntitoneBasis.mem_iff [Preorder ι] {l : Filter α} {s : ι → Set α}
    (hs : l.HasAntitoneBasis s) {t : Set α} : t ∈ l ↔ ∃ i, s i ⊆ t 
goal: t ∈ l ↔ ∃ i, s i ⊆ t

full_name: Filter.HasAntitoneBasis.mem
code: protected theorem HasAntitoneBasis.mem [Preorder ι] {l : Filter α} {s : ι → Set α}
    (hs : l.HasAntitoneBasis s) (i : ι) : s i ∈ l 
goal: s i ∈ l

full_name: Filter.HasAntitoneBasis.hasBasis_ge
code: theorem HasAntitoneBasis.hasBasis_ge [Preorder ι] [IsDirected ι (· ≤ ·)] {l : Filter α}
    {s : ι → Set α} (hs : l.HasAntitoneBasis s) (i : ι) : l.HasBasis (fun j => i ≤ j) s 
goal: l.HasBasis (fun j => i ≤ j) s

full_name: Filter.HasBasis.exists_antitone_subbasis
code: /-- If `f` is countably generated and `f.HasBasis p s`, then `f` admits a decreasing basis
enumerated by natural numbers such that all sets have the form `s i`. More precisely, there is a
sequence `i n` such that `p (i n)` for all `n` and `s (i n)` is a decreasing sequence of sets which
forms a basis of `f`-/
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) 
goal: ∃ x, (∀ (i : ℕ), p (x i)) ∧ f.HasAntitoneBasis fun i => s (x i)

full_name: Filter.exists_antitone_basis
code: /-- A countably generated filter admits a basis formed by an antitone sequence of sets. -/
theorem exists_antitone_basis (f : Filter α) [f.IsCountablyGenerated] :
    ∃ x : ℕ → Set α, f.HasAntitoneBasis x 
goal: ∃ x, f.HasAntitoneBasis x

full_name: Filter.exists_antitone_seq
code: theorem exists_antitone_seq (f : Filter α) [f.IsCountablyGenerated] :
    ∃ x : ℕ → Set α, Antitone x ∧ ∀ {s}, s ∈ f ↔ ∃ i, x i ⊆ s 
goal: ∃ x, Antitone x ∧ ∀ {s : Set α}, s ∈ f ↔ ∃ i, x i ⊆ s

full_name: Filter.Inf.isCountablyGenerated
code: instance Inf.isCountablyGenerated (f g : Filter α) [IsCountablyGenerated f]
    [IsCountablyGenerated g] : IsCountablyGenerated (f ⊓ g) 
goal: (f ⊓ g).IsCountablyGenerated

full_name: Filter.map.isCountablyGenerated
code: instance map.isCountablyGenerated (l : Filter α) [l.IsCountablyGenerated] (f : α → β) :
    (map f l).IsCountablyGenerated 
goal: (Filter.map f l).IsCountablyGenerated

full_name: Filter.comap.isCountablyGenerated
code: instance comap.isCountablyGenerated (l : Filter β) [l.IsCountablyGenerated] (f : α → β) :
    (comap f l).IsCountablyGenerated 
goal: (Filter.comap f l).IsCountablyGenerated

full_name: Filter.Sup.isCountablyGenerated
code: instance Sup.isCountablyGenerated (f g : Filter α) [IsCountablyGenerated f]
    [IsCountablyGenerated g] : IsCountablyGenerated (f ⊔ g) 
goal: (f ⊔ g).IsCountablyGenerated

full_name: Filter.prod.isCountablyGenerated
code: instance prod.isCountablyGenerated (la : Filter α) (lb : Filter β) [IsCountablyGenerated la]
    [IsCountablyGenerated lb] : IsCountablyGenerated (la ×ˢ lb) 
goal: (la ×ˢ lb).IsCountablyGenerated

full_name: Filter.coprod.isCountablyGenerated
code: instance coprod.isCountablyGenerated (la : Filter α) (lb : Filter β) [IsCountablyGenerated la]
    [IsCountablyGenerated lb] : IsCountablyGenerated (la.coprod lb) 
goal: (la.coprod lb).IsCountablyGenerated

full_name: Filter.isCountablyGenerated_seq
code: theorem isCountablyGenerated_seq [Countable ι'] (x : ι' → Set α) :
    IsCountablyGenerated (⨅ i, 𝓟 (x i)) 
goal: (⨅ i, 𝓟 (x i)).IsCountablyGenerated

full_name: Filter.isCountablyGenerated_of_seq
code: theorem isCountablyGenerated_of_seq {f : Filter α} (h : ∃ x : ℕ → Set α, f = ⨅ i, 𝓟 (x i)) :
    f.IsCountablyGenerated 
goal: f.IsCountablyGenerated

full_name: Filter.isCountablyGenerated_biInf_principal
code: theorem isCountablyGenerated_biInf_principal {B : Set (Set α)} (h : B.Countable) :
    IsCountablyGenerated (⨅ s ∈ B, 𝓟 s) 
goal: (⨅ s ∈ B, 𝓟 s).IsCountablyGenerated

full_name: Filter.isCountablyGenerated_iff_exists_antitone_basis
code: theorem isCountablyGenerated_iff_exists_antitone_basis {f : Filter α} :
    IsCountablyGenerated f ↔ ∃ x : ℕ → Set α, f.HasAntitoneBasis x 
goal: f.IsCountablyGenerated ↔ ∃ x, f.HasAntitoneBasis x

full_name: Filter.isCountablyGenerated_principal
code: @[instance]
theorem isCountablyGenerated_principal (s : Set α) : IsCountablyGenerated (𝓟 s) 
goal: (𝓟 s).IsCountablyGenerated

full_name: Filter.isCountablyGenerated_pure
code: @[instance]
theorem isCountablyGenerated_pure (a : α) : IsCountablyGenerated (pure a) 
goal: (pure a).IsCountablyGenerated

full_name: Filter.isCountablyGenerated_bot
code: @[instance]
theorem isCountablyGenerated_bot : IsCountablyGenerated (⊥ : Filter α) 
goal: ⊥.IsCountablyGenerated

full_name: Filter.isCountablyGenerated_top
code: @[instance]
theorem isCountablyGenerated_top : IsCountablyGenerated (⊤ : Filter α) 
goal: ⊤.IsCountablyGenerated

full_name: Filter.iInf.isCountablyGenerated
code: instance iInf.isCountablyGenerated {ι : Sort u} {α : Type v} [Countable ι] (f : ι → Filter α)
    [∀ i, IsCountablyGenerated (f i)] : IsCountablyGenerated (⨅ i, f i) 
goal: (⨅ i, f i).IsCountablyGenerated