File: Mathlib/Order/Filter/CardinalInter.lean

full_name: CardinalInterFilter.cardinal_sInter_mem
code: /-- A filter `l` has the cardinal `c` intersection property if for any collection
of less than `c` sets `s ∈ l`, their intersection belongs to `l` as well. -/
class CardinalInterFilter (l : Filter α) (c : Cardinal.{u}) : Prop where
  /-- For a collection of sets `s ∈ l` with cardinality below c,
  their intersection belongs to `l` as well. -/
  cardinal_sInter_mem : ∀ S : Set (Set α), (#S < c) → (∀ s ∈ S, s ∈ l) → ⋂₀ S ∈ l
goal: #↑S < c → (∀ s ∈ S, s ∈ l) → ⋂₀ S ∈ l

full_name: CardinalInterFilter
code: /-- A filter `l` has the cardinal `c` intersection property if for any collection
of less than `c` sets `s ∈ l`, their intersection belongs to `l` as well. -/
class CardinalInterFilter (l : Filter α) (c : Cardinal.{u}) : Prop where
  /-- For a collection of sets `s ∈ l` with cardinality below c,
  their intersection belongs to `l` as well. -/
  cardinal_sInter_mem : ∀ S : Set (Set α), (#S < c) → (∀ s ∈ S, s ∈ l) → ⋂₀ S ∈ l
goal: Prop

full_name: cardinal_sInter_mem
code: theorem cardinal_sInter_mem {S : Set (Set α)} [CardinalInterFilter l c] (hSc : #S < c) :
    ⋂₀ S ∈ l ↔ ∀ s ∈ S, s ∈ l 
goal: ⋂₀ S ∈ l ↔ ∀ s ∈ S, s ∈ l

full_name: Filter.cardinalInterFilter_aleph0
code: /-- Every filter is a CardinalInterFilter with c = aleph0 -/
theorem _root_.Filter.cardinalInterFilter_aleph0 (l : Filter α) : CardinalInterFilter l aleph0 
goal: CardinalInterFilter l ℵ₀

full_name: CardinalInterFilter.toCountableInterFilter
code: /-- Every CardinalInterFilter with c > aleph0 is a CountableInterFilter -/
theorem CardinalInterFilter.toCountableInterFilter (l : Filter α) [CardinalInterFilter l c]
    (hc : aleph0 < c) : CountableInterFilter l 
goal: CountableInterFilter l

full_name: CountableInterFilter.toCardinalInterFilter
code: /-- Every CountableInterFilter is a CardinalInterFilter with c = aleph 1-/
instance CountableInterFilter.toCardinalInterFilter (l : Filter α) [CountableInterFilter l] :
    CardinalInterFilter l (aleph 1) 
goal: CardinalInterFilter l (Cardinal.aleph 1)

full_name: cardinalInterFilter_aleph_one_iff
code: theorem cardinalInterFilter_aleph_one_iff :
    CardinalInterFilter l (aleph 1) ↔ CountableInterFilter l 
goal: CardinalInterFilter l (Cardinal.aleph 1) ↔ CountableInterFilter l

full_name: CardinalInterFilter.of_cardinalInterFilter_of_le
code: /-- Every CardinalInterFilter for some c also is a CardinalInterFilter for some a ≤ c -/
theorem CardinalInterFilter.of_cardinalInterFilter_of_le (l : Filter α) [CardinalInterFilter l c]
    {a : Cardinal.{u}} (hac : a ≤ c) :
    CardinalInterFilter l a 
goal: CardinalInterFilter l a

full_name: CardinalInterFilter.of_cardinalInterFilter_of_lt
code: theorem CardinalInterFilter.of_cardinalInterFilter_of_lt (l : Filter α) [CardinalInterFilter l c]
    {a : Cardinal.{u}} (hac : a < c) : CardinalInterFilter l a 
goal: CardinalInterFilter l a

full_name: Filter.cardinal_iInter_mem
code: theorem cardinal_iInter_mem {s : ι → Set α} (hic : #ι < c) :
    (⋂ i, s i) ∈ l ↔ ∀ i, s i ∈ l 
goal: ⋂ i, s i ∈ l ↔ ∀ (i : ι), s i ∈ l

full_name: Filter.cardinal_bInter_mem
code: 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 
goal: ⋂ i, ⋂ (hi : i ∈ S), s i hi ∈ l ↔ ∀ (i : ι) (hi : i ∈ S), s i hi ∈ l

full_name: Filter.eventually_cardinal_forall
code: theorem eventually_cardinal_forall {p : α → ι → Prop} (hic : #ι < c) :
    (∀ᶠ x in l, ∀ i, p x i) ↔ ∀ i, ∀ᶠ x in l, p x i 
goal: (∀ᶠ (x : α) in l, ∀ (i : ι), p x i) ↔ ∀ (i : ι), ∀ᶠ (x : α) in l, p x i

full_name: Filter.eventually_cardinal_ball
code: 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 
goal: (∀ᶠ (x : α) in l, ∀ (i : ι) (hi : i ∈ S), p x i hi) ↔ ∀ (i : ι) (hi : i ∈ S), ∀ᶠ (x : α) in l, p x i hi

full_name: Filter.EventuallyLE.cardinal_iUnion
code: theorem EventuallyLE.cardinal_iUnion {s t : ι → Set α} (hic : #ι < c)
    (h : ∀ i, s i ≤ᶠ[l] t i) : ⋃ i, s i ≤ᶠ[l] ⋃ i, t i 
goal: ⋃ i, s i ≤ᶠ[l] ⋃ i, t i

full_name: Filter.EventuallyEq.cardinal_iUnion
code: theorem EventuallyEq.cardinal_iUnion {s t : ι → Set α} (hic : #ι < c)
    (h : ∀ i, s i =ᶠ[l] t i) : ⋃ i, s i =ᶠ[l] ⋃ i, t i 
goal: ⋃ i, s i =ᶠ[l] ⋃ i, t i

full_name: Filter.EventuallyLE.cardinal_bUnion
code: 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 ‹_› 
goal: ⋃ i, ⋃ (h : i ∈ S), s i h ≤ᶠ[l] ⋃ i, ⋃ (h : i ∈ S), t i h

full_name: Filter.EventuallyEq.cardinal_bUnion
code: 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 ‹_› 
goal: ⋃ i, ⋃ (h : i ∈ S), s i h =ᶠ[l] ⋃ i, ⋃ (h : i ∈ S), t i h

full_name: Filter.EventuallyLE.cardinal_iInter
code: theorem EventuallyLE.cardinal_iInter {s t : ι → Set α} (hic : #ι < c)
    (h : ∀ i, s i ≤ᶠ[l] t i) : ⋂ i, s i ≤ᶠ[l] ⋂ i, t i 
goal: ⋂ i, s i ≤ᶠ[l] ⋂ i, t i

full_name: Filter.EventuallyEq.cardinal_iInter
code: theorem EventuallyEq.cardinal_iInter {s t : ι → Set α} (hic : #ι < c)
    (h : ∀ i, s i =ᶠ[l] t i) : ⋂ i, s i =ᶠ[l] ⋂ i, t i 
goal: ⋂ i, s i =ᶠ[l] ⋂ i, t i

full_name: Filter.EventuallyLE.cardinal_bInter
code: 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 ‹_› 
goal: ⋂ i, ⋂ (h : i ∈ S), s i h ≤ᶠ[l] ⋂ i, ⋂ (h : i ∈ S), t i h

full_name: Filter.EventuallyEq.cardinal_bInter
code: 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 ‹_› 
goal: ⋂ i, ⋂ (h : i ∈ S), s i h =ᶠ[l] ⋂ i, ⋂ (h : i ∈ S), t i h

full_name: Filter.ofCardinalInter
code: /-- Construct a filter with cardinal `c` intersection property. This constructor deduces
`Filter.univ_sets` and `Filter.inter_sets` from the cardinal `c` intersection property. -/
def 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) : Filter α 
goal: Filter α

full_name: Filter.cardinalInter_ofCardinalInter
code: instance cardinalInter_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) :
    CardinalInterFilter (Filter.ofCardinalInter l hc hl h_mono) c 
goal: CardinalInterFilter (Filter.ofCardinalInter l hc hl h_mono) c

full_name: Filter.mem_ofCardinalInter
code: @[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 
goal: s ∈ Filter.ofCardinalInter l hc hl h_mono ↔ s ∈ l

full_name: Filter.ofCardinalUnion
code: /-- Construct a filter with cardinal `c` intersection property.
Similarly to `Filter.comk`, a set belongs to this filter if its complement satisfies the property.
Similarly to `Filter.ofCardinalInter`,
this constructor deduces some properties from the cardinal `c` intersection property
which becomes the cardinal `c` union property because we take complements of all sets. -/
def ofCardinalUnion (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) : Filter α 
goal: Filter α

full_name: Filter.cardinalInter_ofCardinalUnion
code: instance cardinalInter_ofCardinalUnion (l : Set (Set α)) (hc : 2 < c) (h₁ h₂) :
    CardinalInterFilter (Filter.ofCardinalUnion l hc h₁ h₂) c 
goal: CardinalInterFilter (Filter.ofCardinalUnion l hc h₁ h₂) c

full_name: Filter.mem_ofCardinalUnion
code: @[simp]
theorem mem_ofCardinalUnion {l : Set (Set α)} (hc : 2 < c) {hunion hmono s} :
    s ∈ ofCardinalUnion l hc hunion hmono ↔ l sᶜ 
goal: s ∈ Filter.ofCardinalUnion l hc hunion hmono ↔ l sᶜ

full_name: Filter.cardinalInterFilter_principal
code: instance cardinalInterFilter_principal (s : Set α) : CardinalInterFilter (𝓟 s) c 
goal: CardinalInterFilter (𝓟 s) c

full_name: Filter.cardinalInterFilter_bot
code: instance cardinalInterFilter_bot : CardinalInterFilter (⊥ : Filter α) c 
goal: CardinalInterFilter ⊥ c

full_name: Filter.cardinalInterFilter_top
code: instance cardinalInterFilter_top : CardinalInterFilter (⊤ : Filter α) c 
goal: CardinalInterFilter ⊤ c

full_name: Filter.instCardinalInterFilterComap
code: instance (l : Filter β) [CardinalInterFilter l c] (f : α → β) :
    CardinalInterFilter (comap f l) c 
goal: CardinalInterFilter (Filter.comap f l) c

full_name: Filter.instCardinalInterFilterMap
code: instance (l : Filter α) [CardinalInterFilter l c] (f : α → β) :
    CardinalInterFilter (map f l) c 
goal: CardinalInterFilter (Filter.map f l) c

full_name: Filter.cardinalInterFilter_inf_eq
code: /-- Infimum of two `CardinalInterFilter`s is a `CardinalInterFilter`. This is useful, e.g.,
to automatically get an instance for `residual α ⊓ 𝓟 s`. -/
instance cardinalInterFilter_inf_eq (l₁ l₂ : Filter α) [CardinalInterFilter l₁ c]
    [CardinalInterFilter l₂ c] : CardinalInterFilter (l₁ ⊓ l₂) c 
goal: CardinalInterFilter (l₁ ⊓ l₂) c

full_name: Filter.cardinalInterFilter_inf
code: instance cardinalInterFilter_inf (l₁ l₂ : Filter α) {c₁ c₂ : Cardinal.{u}}
    [CardinalInterFilter l₁ c₁] [CardinalInterFilter l₂ c₂] : CardinalInterFilter (l₁ ⊓ l₂)
    (c₁ ⊓ c₂) 
goal: CardinalInterFilter (l₁ ⊓ l₂) (c₁ ⊓ c₂)

full_name: Filter.cardinalInterFilter_sup_eq
code: /-- Supremum of two `CardinalInterFilter`s is a `CardinalInterFilter`. -/
instance cardinalInterFilter_sup_eq (l₁ l₂ : Filter α) [CardinalInterFilter l₁ c]
    [CardinalInterFilter l₂ c] : CardinalInterFilter (l₁ ⊔ l₂) c 
goal: CardinalInterFilter (l₁ ⊔ l₂) c

full_name: Filter.cardinalInterFilter_sup
code: instance cardinalInterFilter_sup (l₁ l₂ : Filter α) {c₁ c₂ : Cardinal.{u}}
    [CardinalInterFilter l₁ c₁] [CardinalInterFilter l₂ c₂] :
    CardinalInterFilter (l₁ ⊔ l₂) (c₁ ⊓ c₂) 
goal: CardinalInterFilter (l₁ ⊔ l₂) (c₁ ⊓ c₂)

full_name: Filter.CardinalGenerateSets.univ
code: /-- `Filter.CardinalGenerateSets c g` is the (sets of the)
greatest `cardinalInterFilter c` containing `g`. -/
inductive CardinalGenerateSets : Set α → Prop
  | basic {s : Set α} : s ∈ g → CardinalGenerateSets s
  | univ : CardinalGenerateSets univ
  | superset {s t : Set α} : CardinalGenerateSets s → s ⊆ t → CardinalGenerateSets t
  | sInter {S : Set (Set α)} :
    (#S < c) → (∀ s ∈ S, CardinalGenerateSets s) → CardinalGenerateSets (⋂₀ S)
goal: Filter.CardinalGenerateSets g Set.univ

full_name: Filter.CardinalGenerateSets.sInter
code: /-- `Filter.CardinalGenerateSets c g` is the (sets of the)
greatest `cardinalInterFilter c` containing `g`. -/
inductive CardinalGenerateSets : Set α → Prop
  | basic {s : Set α} : s ∈ g → CardinalGenerateSets s
  | univ : CardinalGenerateSets univ
  | superset {s t : Set α} : CardinalGenerateSets s → s ⊆ t → CardinalGenerateSets t
  | sInter {S : Set (Set α)} :
    (#S < c) → (∀ s ∈ S, CardinalGenerateSets s) → CardinalGenerateSets (⋂₀ S)
goal: #↑S < c → (∀ s ∈ S, Filter.CardinalGenerateSets g s) → Filter.CardinalGenerateSets g (⋂₀ S)

full_name: Filter.CardinalGenerateSets.basic
code: /-- `Filter.CardinalGenerateSets c g` is the (sets of the)
greatest `cardinalInterFilter c` containing `g`. -/
inductive CardinalGenerateSets : Set α → Prop
  | basic {s : Set α} : s ∈ g → CardinalGenerateSets s
  | univ : CardinalGenerateSets univ
  | superset {s t : Set α} : CardinalGenerateSets s → s ⊆ t → CardinalGenerateSets t
  | sInter {S : Set (Set α)} :
    (#S < c) → (∀ s ∈ S, CardinalGenerateSets s) → CardinalGenerateSets (⋂₀ S)
goal: s ∈ g → Filter.CardinalGenerateSets g s

full_name: Filter.CardinalGenerateSets.superset
code: /-- `Filter.CardinalGenerateSets c g` is the (sets of the)
greatest `cardinalInterFilter c` containing `g`. -/
inductive CardinalGenerateSets : Set α → Prop
  | basic {s : Set α} : s ∈ g → CardinalGenerateSets s
  | univ : CardinalGenerateSets univ
  | superset {s t : Set α} : CardinalGenerateSets s → s ⊆ t → CardinalGenerateSets t
  | sInter {S : Set (Set α)} :
    (#S < c) → (∀ s ∈ S, CardinalGenerateSets s) → CardinalGenerateSets (⋂₀ S)
goal: Filter.CardinalGenerateSets g s → s ⊆ t → Filter.CardinalGenerateSets g t

full_name: Filter.CardinalGenerateSets
code: /-- `Filter.CardinalGenerateSets c g` is the (sets of the)
greatest `cardinalInterFilter c` containing `g`. -/
inductive CardinalGenerateSets : Set α → Prop
  | basic {s : Set α} : s ∈ g → CardinalGenerateSets s
  | univ : CardinalGenerateSets univ
  | superset {s t : Set α} : CardinalGenerateSets s → s ⊆ t → CardinalGenerateSets t
  | sInter {S : Set (Set α)} :
    (#S < c) → (∀ s ∈ S, CardinalGenerateSets s) → CardinalGenerateSets (⋂₀ S)
goal: Set α → Prop

full_name: Filter.cardinalGenerate
code: /-- `Filter.cardinalGenerate c g` is the greatest `cardinalInterFilter c` containing `g`. -/
def cardinalGenerate (hc : 2 < c) : Filter α 
goal: Filter α

full_name: Filter.cardinalInter_ofCardinalGenerate
code: lemma cardinalInter_ofCardinalGenerate (hc : 2 < c) :
    CardinalInterFilter (cardinalGenerate g hc) c 
goal: CardinalInterFilter (Filter.cardinalGenerate g hc) c

full_name: Filter.mem_cardinaleGenerate_iff
code: /-- A set is in the `cardinalInterFilter` generated by `g` if and only if
it contains an intersection of `c` elements of `g`. -/
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 
goal: s ∈ Filter.cardinalGenerate g ⋯ ↔ ∃ S ⊆ g, #↑S < c ∧ ⋂₀ S ⊆ s

full_name: Filter.le_cardinalGenerate_iff_of_cardinalInterFilter
code: theorem le_cardinalGenerate_iff_of_cardinalInterFilter {f : Filter α} [CardinalInterFilter f c]
    (hc : 2 < c) : f ≤ cardinalGenerate g hc ↔ g ⊆ f.sets 
goal: f ≤ Filter.cardinalGenerate g hc ↔ g ⊆ f.sets

full_name: Filter.cardinalGenerate_isGreatest
code: /-- `cardinalGenerate g hc` is the greatest `cardinalInterFilter c` containing `g`. -/
theorem cardinalGenerate_isGreatest (hc : 2 < c) :
    IsGreatest { f : Filter α | CardinalInterFilter f c ∧ g ⊆ f.sets } (cardinalGenerate g hc) 
goal: IsGreatest {f | CardinalInterFilter f c ∧ g ⊆ f.sets} (Filter.cardinalGenerate g hc)