File: Mathlib/Data/Analysis/Filter.lean

full_name: CFilter.f
code: /-- A `CFilter α σ` is a realization of a filter (base) on `α`,
  represented by a type `σ` together with operations for the top element and
  the binary `inf` operation. -/
structure CFilter (α σ : Type*) [PartialOrder α] where
  f : σ → α
  pt : σ
  inf : σ → σ → σ
  inf_le_left : ∀ a b : σ, f (inf a b) ≤ f a
  inf_le_right : ∀ a b : σ, f (inf a b) ≤ f b
goal: σ → α

full_name: CFilter.inf_le_left
code: /-- A `CFilter α σ` is a realization of a filter (base) on `α`,
  represented by a type `σ` together with operations for the top element and
  the binary `inf` operation. -/
structure CFilter (α σ : Type*) [PartialOrder α] where
  f : σ → α
  pt : σ
  inf : σ → σ → σ
  inf_le_left : ∀ a b : σ, f (inf a b) ≤ f a
  inf_le_right : ∀ a b : σ, f (inf a b) ≤ f b
goal: self.f (self.inf a b) ≤ self.f a

full_name: CFilter.inf
code: /-- A `CFilter α σ` is a realization of a filter (base) on `α`,
  represented by a type `σ` together with operations for the top element and
  the binary `inf` operation. -/
structure CFilter (α σ : Type*) [PartialOrder α] where
  f : σ → α
  pt : σ
  inf : σ → σ → σ
  inf_le_left : ∀ a b : σ, f (inf a b) ≤ f a
  inf_le_right : ∀ a b : σ, f (inf a b) ≤ f b
goal: σ → σ → σ

full_name: CFilter.inf_le_right
code: /-- A `CFilter α σ` is a realization of a filter (base) on `α`,
  represented by a type `σ` together with operations for the top element and
  the binary `inf` operation. -/
structure CFilter (α σ : Type*) [PartialOrder α] where
  f : σ → α
  pt : σ
  inf : σ → σ → σ
  inf_le_left : ∀ a b : σ, f (inf a b) ≤ f a
  inf_le_right : ∀ a b : σ, f (inf a b) ≤ f b
goal: self.f (self.inf a b) ≤ self.f b

full_name: CFilter.pt
code: /-- A `CFilter α σ` is a realization of a filter (base) on `α`,
  represented by a type `σ` together with operations for the top element and
  the binary `inf` operation. -/
structure CFilter (α σ : Type*) [PartialOrder α] where
  f : σ → α
  pt : σ
  inf : σ → σ → σ
  inf_le_left : ∀ a b : σ, f (inf a b) ≤ f a
  inf_le_right : ∀ a b : σ, f (inf a b) ≤ f b
goal: σ

full_name: CFilter
code: /-- A `CFilter α σ` is a realization of a filter (base) on `α`,
  represented by a type `σ` together with operations for the top element and
  the binary `inf` operation. -/
structure CFilter (α σ : Type*) [PartialOrder α] where
  f : σ → α
  pt : σ
  inf : σ → σ → σ
  inf_le_left : ∀ a b : σ, f (inf a b) ≤ f a
  inf_le_right : ∀ a b : σ, f (inf a b) ≤ f b
goal: Type (max u_1 u_2)

full_name: instInhabitedCFilter
code: instance [Inhabited α] [SemilatticeInf α] : Inhabited (CFilter α α) 
goal: Inhabited (CFilter α α)

full_name: CFilter.instCoeFunForall
code: instance : CoeFun (CFilter α σ) fun _ ↦ σ → α 
goal: CoeFun (CFilter α σ) fun x => σ → α

full_name: CFilter.coe_mk
code: theorem coe_mk (f pt inf h₁ h₂ a) : (@CFilter.mk α σ _ f pt inf h₁ h₂) a = f a 
goal: { f := f, pt := pt, inf := inf, inf_le_left := h₁, inf_le_right := h₂ }.f a = f a

full_name: CFilter.ofEquiv
code: /-- Map a `CFilter` to an equivalent representation type. -/
def ofEquiv (E : σ ≃ τ) : CFilter α σ → CFilter α τ
  
goal: CFilter α σ → CFilter α τ

full_name: CFilter.ofEquiv_val
code: @[simp]
theorem ofEquiv_val (E : σ ≃ τ) (F : CFilter α σ) (a : τ) : F.ofEquiv E a = F (E.symm a) 
goal: (CFilter.ofEquiv E F).f a = F.f (E.symm a)

full_name: CFilter.toFilter
code: /-- The filter represented by a `CFilter` is the collection of supersets of
  elements of the filter base. -/
def toFilter (F : CFilter (Set α) σ) : Filter α 
goal: Filter α

full_name: CFilter.mem_toFilter_sets
code: @[simp]
theorem mem_toFilter_sets (F : CFilter (Set α) σ) {a : Set α} : a ∈ F.toFilter ↔ ∃ b, F b ⊆ a 
goal: a ∈ F.toFilter ↔ ∃ b, F.f b ⊆ a

full_name: Filter.Realizer
code: /-- A realizer for filter `f` is a cfilter which generates `f`. -/
structure Filter.Realizer (f : Filter α) where
  σ : Type*
  F : CFilter (Set α) σ
  eq : F.toFilter = f
goal: Type (max u_1 (u_5 + 1))

full_name: Filter.Realizer.F
code: /-- A realizer for filter `f` is a cfilter which generates `f`. -/
structure Filter.Realizer (f : Filter α) where
  σ : Type*
  F : CFilter (Set α) σ
  eq : F.toFilter = f
goal: CFilter (Set α) self.σ

full_name: Filter.Realizer.eq
code: /-- A realizer for filter `f` is a cfilter which generates `f`. -/
structure Filter.Realizer (f : Filter α) where
  σ : Type*
  F : CFilter (Set α) σ
  eq : F.toFilter = f
goal: self.F.toFilter = f

full_name: Filter.Realizer.σ
code: /-- A realizer for filter `f` is a cfilter which generates `f`. -/
structure Filter.Realizer (f : Filter α) where
  σ : Type*
  F : CFilter (Set α) σ
  eq : F.toFilter = f
goal: Type u_5

full_name: CFilter.toRealizer
code: /-- A `CFilter` realizes the filter it generates. -/
protected def CFilter.toRealizer (F : CFilter (Set α) σ) : F.toFilter.Realizer 
goal: F.toFilter.Realizer

full_name: Filter.Realizer.mem_sets
code: theorem mem_sets {f : Filter α} (F : f.Realizer) {a : Set α} : a ∈ f ↔ ∃ b, F.F b ⊆ a 
goal: a ∈ f ↔ ∃ b, F.F.f b ⊆ a

full_name: Filter.Realizer.ofEq
code: /-- Transfer a realizer along an equality of filter. This has better definitional equalities than
the `Eq.rec` proof. -/
def ofEq {f g : Filter α} (e : f = g) (F : f.Realizer) : g.Realizer 
goal: g.Realizer

full_name: Filter.Realizer.ofFilter
code: /-- A filter realizes itself. -/
def ofFilter (f : Filter α) : f.Realizer 
goal: f.Realizer

full_name: Filter.Realizer.ofEquiv
code: /-- Transfer a filter realizer to another realizer on a different base type. -/
def ofEquiv {f : Filter α} (F : f.Realizer) (E : F.σ ≃ τ) : f.Realizer 
goal: f.Realizer

full_name: Filter.Realizer.ofEquiv_σ
code: @[simp]
theorem ofEquiv_σ {f : Filter α} (F : f.Realizer) (E : F.σ ≃ τ) : (F.ofEquiv E).σ = τ 
goal: (F.ofEquiv E).σ = τ

full_name: Filter.Realizer.ofEquiv_F
code: @[simp]
theorem ofEquiv_F {f : Filter α} (F : f.Realizer) (E : F.σ ≃ τ) (s : τ) :
    (F.ofEquiv E).F s = F.F (E.symm s) 
goal: (F.ofEquiv E).F.f s = F.F.f (E.symm s)

full_name: Filter.Realizer.principal
code: /-- `Unit` is a realizer for the principal filter -/
protected def principal (s : Set α) : (principal s).Realizer 
goal: (𝓟 s).Realizer

full_name: Filter.Realizer.principal_σ
code: @[simp]
theorem principal_σ (s : Set α) : (Realizer.principal s).σ = Unit 
goal: (Filter.Realizer.principal s).σ = Unit

full_name: Filter.Realizer.principal_F
code: @[simp]
theorem principal_F (s : Set α) (u : Unit) : (Realizer.principal s).F u = s 
goal: (Filter.Realizer.principal s).F.f u = s

full_name: Filter.Realizer.instInhabitedPrincipal
code: instance (s : Set α) : Inhabited (principal s).Realizer 
goal: Inhabited (𝓟 s).Realizer

full_name: Filter.Realizer.top
code: /-- `Unit` is a realizer for the top filter -/
protected def top : (⊤ : Filter α).Realizer 
goal: ⊤.Realizer

full_name: Filter.Realizer.top_σ
code: @[simp]
theorem top_σ : (@Realizer.top α).σ = Unit 
goal: Filter.Realizer.top.σ = Unit

full_name: Filter.Realizer.top_F
code: @[simp]
theorem top_F (u : Unit) : (@Realizer.top α).F u = univ 
goal: Filter.Realizer.top.F.f u = Set.univ

full_name: Filter.Realizer.bot
code: /-- `Unit` is a realizer for the bottom filter -/
protected def bot : (⊥ : Filter α).Realizer 
goal: ⊥.Realizer

full_name: Filter.Realizer.bot_σ
code: @[simp]
theorem bot_σ : (@Realizer.bot α).σ = Unit 
goal: Filter.Realizer.bot.σ = Unit

full_name: Filter.Realizer.bot_F
code: @[simp]
theorem bot_F (u : Unit) : (@Realizer.bot α).F u = ∅ 
goal: Filter.Realizer.bot.F.f u = ∅

full_name: Filter.Realizer.map
code: /-- Construct a realizer for `map m f` given a realizer for `f` -/
protected def map (m : α → β) {f : Filter α} (F : f.Realizer) : (map m f).Realizer 
goal: (Filter.map m f).Realizer

full_name: Filter.Realizer.map_σ
code: @[simp]
theorem map_σ (m : α → β) {f : Filter α} (F : f.Realizer) : (F.map m).σ = F.σ 
goal: (Filter.Realizer.map m F).σ = F.σ

full_name: Filter.Realizer.map_F
code: @[simp]
theorem map_F (m : α → β) {f : Filter α} (F : f.Realizer) (s) : (F.map m).F s = image m (F.F s) 
goal: (Filter.Realizer.map m F).F.f s = m '' F.F.f s

full_name: Filter.Realizer.comap
code: /-- Construct a realizer for `comap m f` given a realizer for `f` -/
protected def comap (m : α → β) {f : Filter β} (F : f.Realizer) : (comap m f).Realizer 
goal: (Filter.comap m f).Realizer

full_name: Filter.Realizer.sup
code: /-- Construct a realizer for the sup of two filters -/
protected def sup {f g : Filter α} (F : f.Realizer) (G : g.Realizer) : (f ⊔ g).Realizer 
goal: (f ⊔ g).Realizer

full_name: Filter.Realizer.inf
code: /-- Construct a realizer for the inf of two filters -/
protected def inf {f g : Filter α} (F : f.Realizer) (G : g.Realizer) : (f ⊓ g).Realizer 
goal: (f ⊓ g).Realizer

full_name: Filter.Realizer.cofinite
code: /-- Construct a realizer for the cofinite filter -/
protected def cofinite [DecidableEq α] : (@cofinite α).Realizer 
goal: Filter.cofinite.Realizer

full_name: Filter.Realizer.bind
code: /-- Construct a realizer for filter bind -/
protected def bind {f : Filter α} {m : α → Filter β} (F : f.Realizer) (G : ∀ i, (m i).Realizer) :
    (f.bind m).Realizer 
goal: (f.bind m).Realizer

full_name: Filter.Realizer.iSup
code: /-- Construct a realizer for indexed supremum -/
protected def iSup {f : α → Filter β} (F : ∀ i, (f i).Realizer) : (⨆ i, f i).Realizer 
goal: (⨆ i, f i).Realizer

full_name: Filter.Realizer.prod
code: /-- Construct a realizer for the product of filters -/
protected def prod {f g : Filter α} (F : f.Realizer) (G : g.Realizer) : (f.prod g).Realizer 
goal: (f.prod g).Realizer

full_name: Filter.Realizer.le_iff
code: theorem le_iff {f g : Filter α} (F : f.Realizer) (G : g.Realizer) :
    f ≤ g ↔ ∀ b : G.σ, ∃ a : F.σ, F.F a ≤ G.F b 
goal: f ≤ g ↔ ∀ (b : G.σ), ∃ a, F.F.f a ≤ G.F.f b

full_name: Filter.Realizer.tendsto_iff
code: theorem tendsto_iff (f : α → β) {l₁ : Filter α} {l₂ : Filter β} (L₁ : l₁.Realizer)
    (L₂ : l₂.Realizer) : Tendsto f l₁ l₂ ↔ ∀ b, ∃ a, ∀ x ∈ L₁.F a, f x ∈ L₂.F b 
goal: Filter.Tendsto f l₁ l₂ ↔ ∀ (b : L₂.σ), ∃ a, ∀ x ∈ L₁.F.f a, f x ∈ L₂.F.f b

full_name: Filter.Realizer.ne_bot_iff
code: theorem ne_bot_iff {f : Filter α} (F : f.Realizer) : f ≠ ⊥ ↔ ∀ a : F.σ, (F.F a).Nonempty 
goal: f ≠ ⊥ ↔ ∀ (a : F.σ), (F.F.f a).Nonempty