File: Mathlib/Order/PFilter.lean

full_name: Order.PFilter
code: /-- A filter on a preorder `P` is a subset of `P` that is
  - nonempty
  - downward directed
  - upward closed. -/
structure PFilter (P : Type*) [Preorder P] where
  dual : Ideal Pᵒᵈ
goal: Type u_1

full_name: Order.PFilter.dual
code: /-- A filter on a preorder `P` is a subset of `P` that is
  - nonempty
  - downward directed
  - upward closed. -/
structure PFilter (P : Type*) [Preorder P] where
  dual : Ideal Pᵒᵈ
goal: Order.Ideal Pᵒᵈ

full_name: Order.IsPFilter
code: /-- A predicate for when a subset of `P` is a filter. -/
def IsPFilter [Preorder P] (F : Set P) : Prop 
goal: Prop

full_name: Order.IsPFilter.of_def
code: theorem IsPFilter.of_def [Preorder P] {F : Set P} (nonempty : F.Nonempty)
    (directed : DirectedOn (· ≥ ·) F) (mem_of_le : ∀ {x y : P}, x ≤ y → x ∈ F → y ∈ F) :
    IsPFilter F 
goal: Order.IsPFilter F

full_name: Order.IsPFilter.toPFilter
code: /-- Create an element of type `Order.PFilter` from a set satisfying the predicate
`Order.IsPFilter`. -/
def IsPFilter.toPFilter [Preorder P] {F : Set P} (h : IsPFilter F) : PFilter P 
goal: Order.PFilter P

full_name: Order.PFilter.instInhabited
code: instance [Inhabited P] : Inhabited (PFilter P) 
goal: Inhabited (Order.PFilter P)

full_name: Order.PFilter.instSetLike
code: /-- A filter on `P` is a subset of `P`. -/
instance : SetLike (PFilter P) P 
goal: SetLike (Order.PFilter P) P

full_name: Order.PFilter.isPFilter
code: theorem isPFilter : IsPFilter (F : Set P) 
goal: Order.IsPFilter ↑F

full_name: Order.PFilter.nonempty
code: protected theorem nonempty : (F : Set P).Nonempty 
goal: (↑F).Nonempty

full_name: Order.PFilter.directed
code: theorem directed : DirectedOn (· ≥ ·) (F : Set P) 
goal: DirectedOn (fun x x_1 => x ≥ x_1) ↑F

full_name: Order.PFilter.mem_of_le
code: theorem mem_of_le {F : PFilter P} : x ≤ y → x ∈ F → y ∈ F 
goal: x ≤ y → x ∈ F → y ∈ F

full_name: Order.PFilter.ext
code: /-- Two filters are equal when their underlying sets are equal. -/
@[ext]
theorem ext (h : (s : Set P) = t) : s = t 
goal: s = t

full_name: Order.PFilter.mem_of_mem_of_le
code: @[trans]
theorem mem_of_mem_of_le {F G : PFilter P} (hx : x ∈ F) (hle : F ≤ G) : x ∈ G 
goal: x ∈ G

full_name: Order.PFilter.principal
code: /-- The smallest filter containing a given element. -/
def principal (p : P) : PFilter P 
goal: Order.PFilter P

full_name: Order.PFilter.mem_mk
code: @[simp]
theorem mem_mk (x : P) (I : Ideal Pᵒᵈ) : x ∈ (⟨I⟩ : PFilter P) ↔ toDual x ∈ I 
goal: x ∈ { dual := I } ↔ OrderDual.toDual x ∈ I

full_name: Order.PFilter.principal_le_iff
code: @[simp]
theorem principal_le_iff {F : PFilter P} : principal x ≤ F ↔ x ∈ F 
goal: Order.PFilter.principal x ≤ F ↔ x ∈ F

full_name: Order.PFilter.mem_principal
code: @[simp] theorem mem_principal : x ∈ principal y ↔ y ≤ x 
goal: x ∈ Order.PFilter.principal y ↔ y ≤ x

full_name: Order.PFilter.principal_le_principal_iff
code: theorem principal_le_principal_iff {p q : P} : principal q ≤ principal p ↔ p ≤ q 
goal: Order.PFilter.principal q ≤ Order.PFilter.principal p ↔ p ≤ q

full_name: Order.PFilter.antitone_principal
code: theorem antitone_principal : Antitone (principal : P → PFilter P) 
goal: Antitone Order.PFilter.principal

full_name: Order.PFilter.top_mem
code: /-- A specific witness of `pfilter.nonempty` when `P` has a top element. -/
@[simp] theorem top_mem : ⊤ ∈ F 
goal: ⊤ ∈ F

full_name: Order.PFilter.instOrderBot
code: /-- There is a bottom filter when `P` has a top element. -/
instance : OrderBot (PFilter P) 
goal: OrderBot (Order.PFilter P)

full_name: Order.PFilter.instOrderTopOfOrderBot
code: /-- There is a top filter when `P` has a bottom element. -/
instance {P} [Preorder P] [OrderBot P] : OrderTop (PFilter P) 
goal: OrderTop (Order.PFilter P)

full_name: Order.PFilter.inf_mem
code: /-- A specific witness of `pfilter.directed` when `P` has meets. -/
theorem inf_mem (hx : x ∈ F) (hy : y ∈ F) : x ⊓ y ∈ F 
goal: x ⊓ y ∈ F

full_name: Order.PFilter.inf_mem_iff
code: @[simp]
theorem inf_mem_iff : x ⊓ y ∈ F ↔ x ∈ F ∧ y ∈ F 
goal: x ⊓ y ∈ F ↔ x ∈ F ∧ y ∈ F

full_name: Order.PFilter.sInf_gc
code: theorem sInf_gc :
    GaloisConnection (fun x => toDual (principal x)) fun F => sInf (ofDual F : PFilter P) 
goal: GaloisConnection (fun x => OrderDual.toDual (Order.PFilter.principal x)) fun F => sInf ↑(OrderDual.ofDual F)

full_name: Order.PFilter.infGi
code: /-- If a poset `P` admits arbitrary `Inf`s, then `principal` and `Inf` form a Galois coinsertion. -/
def infGi :
    GaloisCoinsertion (fun x => toDual (principal x)) fun F => sInf (ofDual F : PFilter P) 
goal: GaloisCoinsertion (fun x => OrderDual.toDual (Order.PFilter.principal x)) fun F => sInf ↑(OrderDual.ofDual F)