File: Mathlib/Order/Filter/SmallSets.lean

full_name: Filter.smallSets
code: /-- The filter `l.smallSets` is the largest filter containing all powersets of members of `l`. -/
def smallSets (l : Filter α) : Filter (Set α) 
goal: Filter (Set α)

full_name: Filter.smallSets_eq_generate
code: theorem smallSets_eq_generate {f : Filter α} : f.smallSets = generate (powerset '' f.sets) 
goal: f.smallSets = Filter.generate (Set.powerset '' f.sets)

full_name: Filter.bind_smallSets_gc
code: theorem bind_smallSets_gc :
    GaloisConnection (fun L : Filter (Set α) ↦ L.bind principal) smallSets 
goal: GaloisConnection (fun L => L.bind 𝓟) Filter.smallSets

full_name: Filter.HasBasis.smallSets
code: protected theorem HasBasis.smallSets {p : ι → Prop} {s : ι → Set α} (h : HasBasis l p s) :
    HasBasis l.smallSets p fun i => 𝒫 s i 
goal: l.smallSets.HasBasis p fun i => 𝒫 s i

full_name: Filter.hasBasis_smallSets
code: theorem hasBasis_smallSets (l : Filter α) :
    HasBasis l.smallSets (fun t : Set α => t ∈ l) powerset 
goal: l.smallSets.HasBasis (fun t => t ∈ l) Set.powerset

full_name: Filter.tendsto_smallSets_iff
code: /-- `g` converges to `f.smallSets` if for all `s ∈ f`, eventually we have `g x ⊆ s`. -/
theorem tendsto_smallSets_iff {f : α → Set β} :
    Tendsto f la lb.smallSets ↔ ∀ t ∈ lb, ∀ᶠ x in la, f x ⊆ t 
goal: Filter.Tendsto f la lb.smallSets ↔ ∀ t ∈ lb, ∀ᶠ (x : α) in la, f x ⊆ t

full_name: Filter.eventually_smallSets
code: theorem eventually_smallSets {p : Set α → Prop} :
    (∀ᶠ s in l.smallSets, p s) ↔ ∃ s ∈ l, ∀ t, t ⊆ s → p t 
goal: (∀ᶠ (s : Set α) in l.smallSets, p s) ↔ ∃ s ∈ l, ∀ t ⊆ s, p t

full_name: Filter.eventually_smallSets'
code: 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 
goal: (∀ᶠ (s : Set α) in l.smallSets, p s) ↔ ∃ s ∈ l, p s

full_name: Filter.frequently_smallSets
code: theorem frequently_smallSets {p : Set α → Prop} :
    (∃ᶠ s in l.smallSets, p s) ↔ ∀ t ∈ l, ∃ s, s ⊆ t ∧ p s 
goal: (∃ᶠ (s : Set α) in l.smallSets, p s) ↔ ∀ t ∈ l, ∃ s ⊆ t, p s

full_name: Filter.frequently_smallSets_mem
code: theorem frequently_smallSets_mem (l : Filter α) : ∃ᶠ s in l.smallSets, s ∈ l 
goal: ∃ᶠ (s : Set α) in l.smallSets, s ∈ l

full_name: Filter.tendsto_image_smallSets
code: @[simp]
lemma tendsto_image_smallSets {f : α → β} :
    Tendsto (f '' ·) la.smallSets lb.smallSets ↔ Tendsto f la lb 
goal: Filter.Tendsto (fun x => f '' x) la.smallSets lb.smallSets ↔ Filter.Tendsto f la lb

full_name: Filter.HasAntitoneBasis.tendsto_smallSets
code: theorem HasAntitoneBasis.tendsto_smallSets {ι} [Preorder ι] {s : ι → Set α}
    (hl : l.HasAntitoneBasis s) : Tendsto s atTop l.smallSets 
goal: Filter.Tendsto s Filter.atTop l.smallSets

full_name: Filter.monotone_smallSets
code: @[mono]
theorem monotone_smallSets : Monotone (@smallSets α) 
goal: Monotone Filter.smallSets

full_name: Filter.smallSets_bot
code: @[simp]
theorem smallSets_bot : (⊥ : Filter α).smallSets = pure ∅ 
goal: ⊥.smallSets = pure ∅

full_name: Filter.smallSets_top
code: @[simp]
theorem smallSets_top : (⊤ : Filter α).smallSets = ⊤ 
goal: ⊤.smallSets = ⊤

full_name: Filter.smallSets_principal
code: @[simp]
theorem smallSets_principal (s : Set α) : (𝓟 s).smallSets = 𝓟 (𝒫 s) 
goal: (𝓟 s).smallSets = 𝓟 (𝒫 s)

full_name: Filter.smallSets_comap_eq_comap_image
code: theorem smallSets_comap_eq_comap_image (l : Filter β) (f : α → β) :
    (comap f l).smallSets = comap (image f) l.smallSets 
goal: (Filter.comap f l).smallSets = Filter.comap (Set.image f) l.smallSets

full_name: Filter.smallSets_comap
code: theorem smallSets_comap (l : Filter β) (f : α → β) :
    (comap f l).smallSets = l.lift' (powerset ∘ preimage f) 
goal: (Filter.comap f l).smallSets = l.lift' (Set.powerset ∘ Set.preimage f)

full_name: Filter.comap_smallSets
code: theorem comap_smallSets (l : Filter β) (f : α → Set β) :
    comap f l.smallSets = l.lift' (preimage f ∘ powerset) 
goal: Filter.comap f l.smallSets = l.lift' (Set.preimage f ∘ Set.powerset)

full_name: Filter.smallSets_iInf
code: theorem smallSets_iInf {f : ι → Filter α} : (iInf f).smallSets = ⨅ i, (f i).smallSets 
goal: (iInf f).smallSets = ⨅ i, (f i).smallSets

full_name: Filter.smallSets_inf
code: theorem smallSets_inf (l₁ l₂ : Filter α) : (l₁ ⊓ l₂).smallSets = l₁.smallSets ⊓ l₂.smallSets 
goal: (l₁ ⊓ l₂).smallSets = l₁.smallSets ⊓ l₂.smallSets

full_name: Filter.smallSets_neBot
code: instance smallSets_neBot (l : Filter α) : NeBot l.smallSets 
goal: l.smallSets.NeBot

full_name: Filter.Tendsto.smallSets_mono
code: 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 
goal: Filter.Tendsto s la lb.smallSets

full_name: Filter.Tendsto.of_smallSets
code: /-- Generalized **squeeze theorem** (also known as **sandwich theorem**). If `s : α → Set β` is a
family of sets that tends to `Filter.smallSets lb` along `la` and `f : α → β` is a function such
that `f x ∈ s x` eventually along `la`, then `f` tends to `lb` along `la`.

If `s x` is the closed interval `[g x, h x]` for some functions `g`, `h` that tend to the same limit
`𝓝 y`, then we obtain the standard squeeze theorem, see
`tendsto_of_tendsto_of_tendsto_of_le_of_le'`. -/
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 
goal: Filter.Tendsto f la lb

full_name: Filter.eventually_smallSets_eventually
code: @[simp]
theorem eventually_smallSets_eventually {p : α → Prop} :
    (∀ᶠ s in l.smallSets, ∀ᶠ x in l', x ∈ s → p x) ↔ ∀ᶠ x in l ⊓ l', p x 
goal: (∀ᶠ (s : Set α) in l.smallSets, ∀ᶠ (x : α) in l', x ∈ s → p x) ↔ ∀ᶠ (x : α) in l ⊓ l', p x

full_name: Filter.eventually_smallSets_forall
code: @[simp]
theorem eventually_smallSets_forall {p : α → Prop} :
    (∀ᶠ s in l.smallSets, ∀ x ∈ s, p x) ↔ ∀ᶠ x in l, p x 
goal: (∀ᶠ (s : Set α) in l.smallSets, ∀ x ∈ s, p x) ↔ ∀ᶠ (x : α) in l, p x

full_name: Filter.eventually_smallSets_subset
code: @[simp]
theorem eventually_smallSets_subset {s : Set α} : (∀ᶠ t in l.smallSets, t ⊆ s) ↔ s ∈ l 
goal: (∀ᶠ (t : Set α) in l.smallSets, t ⊆ s) ↔ s ∈ l