Closure operators between preorders

We define (bundled) closure operators on a preorder as monotone (increasing), extensive (inflationary) and idempotent functions. We define closed elements for the operator as elements which are fixed by it.

Lower adjoints to a function between preorders u : β → α allow to generalise closure operators to situations where the closure operator we are dealing with naturally decomposes as u ∘ l where l is a worthy function to have on its own. Typical examples include l : Set G → Subgroup G := Subgroup.closure, u : Subgroup G → Set G := (↑), where G is a group. This shows there is a close connection between closure operators, lower adjoints and Galois connections/insertions: every Galois connection induces a lower adjoint which itself induces a closure operator by composition (see GaloisConnection.lowerAdjoint and LowerAdjoint.closureOperator), and every closure operator on a partial order induces a Galois insertion from the set of closed elements to the underlying type (see ClosureOperator.gi).

Main definitions

• ClosureOperator: A closure operator is a monotone function f : α → α such that ∀ x, x ≤ f x and ∀ x, f (f x) = f x.
• LowerAdjoint: A lower adjoint to u : β → α is a function l : α → β such that l and u form a Galois connection.

Implementation details

Although LowerAdjoint is technically a generalisation of ClosureOperator (by defining toFun := id), it is desirable to have both as otherwise ids would be carried all over the place when using concrete closure operators such as ConvexHull.

LowerAdjoint really is a semibundled structure version of GaloisConnection.

References

• https://en.wikipedia.org/wiki/Closure_operator#Closure_operators_on_partially_ordered_sets

Closure operator

structure ClosureOperator (α : Type u_1) [Preorder α] extends OrderHom : Type u_1

• toFun : α → α
• monotone' : Monotone s.toFun
• le_closure' : ∀ (x : α), x ≤ OrderHom.toFun s.toOrderHom x

  An element is less than or equal its closure

• idempotent' : ∀ (x : α), OrderHom.toFun s.toOrderHom (OrderHom.toFun s.toOrderHom x) = OrderHom.toFun s.toOrderHom x

  Closures are idempotent

A closure operator on the preorder α is a monotone function which is extensive (every x is less than its closure) and idempotent.

instance ClosureOperator.instOrderHomClassClosureOperatorToLE (α : Type u_1) [Preorder α] : OrderHomClass (ClosureOperator α) α α

Equations

• ClosureOperator.instOrderHomClassClosureOperatorToLE α = RelHomClass.mk (_ : ∀ (f : ClosureOperator α) (x x_1 : α), x ≤ x_1 → ↑f.toOrderHom x ≤ ↑f.toOrderHom x_1)

@[simp]

theorem ClosureOperator.id_apply (α : Type u_1) [PartialOrder α] (a : α) : ↑(ClosureOperator.id α) a = a

def ClosureOperator.id (α : Type u_1) [PartialOrder α] : ClosureOperator α

The identity function as a closure operator.

Equations

• One or more equations did not get rendered due to their size.

instance ClosureOperator.instInhabitedClosureOperatorToPreorder (α : Type u_1) [PartialOrder α] : Inhabited (ClosureOperator α)

Equations

• ClosureOperator.instInhabitedClosureOperatorToPreorder α = { default := ClosureOperator.id α }

theorem ClosureOperator.ext {α : Type u_1} [PartialOrder α] (c₁ : ClosureOperator α) (c₂ : ClosureOperator α) : ↑c₁ = ↑c₂ → c₁ = c₂

@[simp]

theorem ClosureOperator.mk'_apply {α : Type u_1} [PartialOrder α] (f : α → α) (hf₁ : Monotone f) (hf₂ : ∀ (x : α), x ≤ f x) (hf₃ : ∀ (x : α), f (f x) ≤ f x) : ∀ (a : α), ↑(ClosureOperator.mk' f hf₁ hf₂ hf₃) a = f a

def ClosureOperator.mk' {α : Type u_1} [PartialOrder α] (f : α → α) (hf₁ : Monotone f) (hf₂ : ∀ (x : α), x ≤ f x) (hf₃ : ∀ (x : α), f (f x) ≤ f x) : ClosureOperator α

Constructor for a closure operator using the weaker idempotency axiom: f (f x) ≤ f x.

Equations

• ClosureOperator.mk' f hf₁ hf₂ hf₃ = { toOrderHom := { toFun := f, monotone' := hf₁ }, le_closure' := hf₂, idempotent' := (_ : ∀ (x : α), f (f x) = f x) }

@[simp]

theorem ClosureOperator.mk₂_apply {α : Type u_1} [PartialOrder α] (f : α → α) (hf : ∀ (x : α), x ≤ f x) (hmin : ∀ ⦃x y : α⦄, x ≤ f y → f x ≤ f y) : ∀ (a : α), ↑(ClosureOperator.mk₂ f hf hmin) a = f a

def ClosureOperator.mk₂ {α : Type u_1} [PartialOrder α] (f : α → α) (hf : ∀ (x : α), x ≤ f x) (hmin : ∀ ⦃x y : α⦄, x ≤ f y → f x ≤ f y) : ClosureOperator α

Convenience constructor for a closure operator using the weaker minimality axiom: x ≤ f y → f x ≤ f y, which is sometimes easier to prove in practice.

Equations

• ClosureOperator.mk₂ f hf hmin = { toOrderHom := { toFun := f, monotone' := (_ : ∀ (x y : α), x ≤ y → f x ≤ f y) }, le_closure' := hf, idempotent' := (_ : ∀ (x : α), f (f x) = f x) }

@[simp]

theorem ClosureOperator.mk₃_apply {α : Type u_1} [PartialOrder α] (f : α → α) (p : α → Prop) (hf : ∀ (x : α), x ≤ f x) (hfp : (x : α) → p (f x)) (hmin : ∀ ⦃x y : α⦄, x ≤ y → p y → f x ≤ y) : ∀ (a : α), ↑(ClosureOperator.mk₃ f p hf hfp hmin) a = f a

def ClosureOperator.mk₃ {α : Type u_1} [PartialOrder α] (f : α → α) (p : α → Prop) (hf : ∀ (x : α), x ≤ f x) (hfp : (x : α) → p (f x)) (hmin : ∀ ⦃x y : α⦄, x ≤ y → p y → f x ≤ y) : ClosureOperator α

Expanded out version of mk₂. p implies being closed. This constructor should be used when you already know a sufficient condition for being closed and using mem_mk₃_closed will avoid you the (slight) hassle of having to prove it both inside and outside the constructor.

Equations

• ClosureOperator.mk₃ f p hf hfp hmin = ClosureOperator.mk₂ f hf (_ : ∀ (x y : α), x ≤ f y → f x ≤ f y)

theorem ClosureOperator.closure_mem_mk₃ {α : Type u_1} [PartialOrder α] {f : α → α} {p : α → Prop} {hf : ∀ (x : α), x ≤ f x} {hfp : (x : α) → p (f x)} {hmin : ∀ ⦃x y : α⦄, x ≤ y → p y → f x ≤ y} (x : α) : p (↑(ClosureOperator.mk₃ f p hf hfp hmin) x)

This lemma shows that the image of x of a closure operator built from the mk₃ constructor respects p, the property that was fed into it.

theorem ClosureOperator.closure_le_mk₃_iff {α : Type u_1} [PartialOrder α] {f : α → α} {p : α → Prop} {hf : ∀ (x : α), x ≤ f x} {hfp : (x : α) → p (f x)} {hmin : ∀ ⦃x y : α⦄, x ≤ y → p y → f x ≤ y} {x : α} {y : α} (hxy : x ≤ y) (hy : p y) : ↑(ClosureOperator.mk₃ f p hf hfp hmin) x ≤ y

Analogue of closure_le_closed_iff_le but with the p that was fed into the mk₃ constructor.

theorem ClosureOperator.monotone {α : Type u_1} [PartialOrder α] (c : ClosureOperator α) : Monotone ↑c

theorem ClosureOperator.le_closure {α : Type u_1} [PartialOrder α] (c : ClosureOperator α) (x : α) : x ≤ ↑c x

Every element is less than its closure. This property is sometimes referred to as extensivity or inflationarity.

@[simp]

theorem ClosureOperator.idempotent {α : Type u_1} [PartialOrder α] (c : ClosureOperator α) (x : α) : ↑c (↑c x) = ↑c x

theorem ClosureOperator.le_closure_iff {α : Type u_1} [PartialOrder α] (c : ClosureOperator α) (x : α) (y : α) : x ≤ ↑c y ↔ ↑c x ≤ ↑c y

def ClosureOperator.closed {α : Type u_1} [PartialOrder α] (c : ClosureOperator α) : Set α

An element x is closed for the closure operator c if it is a fixed point for it.

Equations

• ClosureOperator.closed c = {x | ↑c x = x}

theorem ClosureOperator.mem_closed_iff {α : Type u_1} [PartialOrder α] (c : ClosureOperator α) (x : α) : x ∈ ClosureOperator.closed c ↔ ↑c x = x

theorem ClosureOperator.mem_closed_iff_closure_le {α : Type u_1} [PartialOrder α] (c : ClosureOperator α) (x : α) : x ∈ ClosureOperator.closed c ↔ ↑c x ≤ x

theorem ClosureOperator.closure_eq_self_of_mem_closed {α : Type u_1} [PartialOrder α] (c : ClosureOperator α) {x : α} (h : x ∈ ClosureOperator.closed c) : ↑c x = x

@[simp]

theorem ClosureOperator.closure_is_closed {α : Type u_1} [PartialOrder α] (c : ClosureOperator α) (x : α) : ↑c x ∈ ClosureOperator.closed c

theorem ClosureOperator.closed_eq_range_close {α : Type u_1} [PartialOrder α] (c : ClosureOperator α) : ClosureOperator.closed c = Set.range ↑c

The set of closed elements for c is exactly its range.

def ClosureOperator.toClosed {α : Type u_1} [PartialOrder α] (c : ClosureOperator α) (x : α) : ↑(ClosureOperator.closed c)

Send an x to an element of the set of closed elements (by taking the closure).

Equations

• ClosureOperator.toClosed c x = { val := ↑c x, property := (_ : ↑c x ∈ ClosureOperator.closed c) }

@[simp]

theorem ClosureOperator.closure_le_closed_iff_le {α : Type u_1} [PartialOrder α] (c : ClosureOperator α) (x : α) {y : α} (hy : ClosureOperator.closed c y) : ↑c x ≤ y ↔ x ≤ y

theorem ClosureOperator.eq_mk₃_closed {α : Type u_1} [PartialOrder α] (c : ClosureOperator α) : c = ClosureOperator.mk₃ (↑c) (ClosureOperator.closed c) (_ : ∀ (x : α), x ≤ ↑c x) (_ : ∀ (x : α), ↑c x ∈ ClosureOperator.closed c) (_ : ∀ (x y : α), x ≤ y → ClosureOperator.closed c y → ↑c x ≤ y)

A closure operator is equal to the closure operator obtained by feeding c.closed into the mk₃ constructor.

@[simp]

theorem ClosureOperator.mem_mk₃_closed {α : Type u_1} [PartialOrder α] {f : α → α} {p : α → Prop} {hf : ∀ (x : α), x ≤ f x} {hfp : (x : α) → p (f x)} {hmin : ∀ ⦃x y : α⦄, x ≤ y → p y → f x ≤ y} {x : α} : x ∈ ClosureOperator.closed (ClosureOperator.mk₃ f p hf hfp hmin) ↔ p x

The property p fed into the mk₃ constructor exactly corresponds to being closed.

@[simp]

theorem ClosureOperator.closure_top {α : Type u_1} [PartialOrder α] [OrderTop α] (c : ClosureOperator α) : ↑c ⊤ = ⊤

theorem ClosureOperator.top_mem_closed {α : Type u_1} [PartialOrder α] [OrderTop α] (c : ClosureOperator α) : ⊤ ∈ ClosureOperator.closed c

theorem ClosureOperator.closure_inf_le {α : Type u_1} [SemilatticeInf α] (c : ClosureOperator α) (x : α) (y : α) : ↑c (x ⊓ y) ≤ ↑c x ⊓ ↑c y

theorem ClosureOperator.closure_sup_closure_le {α : Type u_1} [SemilatticeSup α] (c : ClosureOperator α) (x : α) (y : α) : ↑c x ⊔ ↑c y ≤ ↑c (x ⊔ y)

theorem ClosureOperator.closure_sup_closure_left {α : Type u_1} [SemilatticeSup α] (c : ClosureOperator α) (x : α) (y : α) : ↑c (↑c x ⊔ y) = ↑c (x ⊔ y)

theorem ClosureOperator.closure_sup_closure_right {α : Type u_1} [SemilatticeSup α] (c : ClosureOperator α) (x : α) (y : α) : ↑c (x ⊔ ↑c y) = ↑c (x ⊔ y)

theorem ClosureOperator.closure_sup_closure {α : Type u_1} [SemilatticeSup α] (c : ClosureOperator α) (x : α) (y : α) : ↑c (↑c x ⊔ ↑c y) = ↑c (x ⊔ y)

@[simp]

theorem ClosureOperator.closure_iSup_closure {α : Type u_1} {ι : Sort u_2} [CompleteLattice α] (c : ClosureOperator α) (f : ι → α) : ↑c (⨆ (i : ι), ↑c (f i)) = ↑c (⨆ (i : ι), f i)

@[simp]

theorem ClosureOperator.closure_iSup₂_closure {α : Type u_1} {ι : Sort u_2} {κ : ι → Sort u_3} [CompleteLattice α] (c : ClosureOperator α) (f : (i : ι) → κ i → α) : ↑c (⨆ (i : ι) (j : κ i), ↑c (f i j)) = ↑c (⨆ (i : ι) (j : κ i), f i j)

Lower adjoint

structure LowerAdjoint {α : Type u_1} {β : Type u_4} [Preorder α] [Preorder β] (u : β → α) : Type (max u_1 u_4)

• toFun : α → β

  The underlying function

• gc' : GaloisConnection s.toFun u

  The underlying function is a lower adjoint.

A lower adjoint of u on the preorder α is a function l such that l and u form a Galois connection. It allows us to define closure operators whose output does not match the input. In practice, u is often (↑) : β → α.

@[simp]

theorem LowerAdjoint.id_toFun (α : Type u_1) [Preorder α] (x : α) : LowerAdjoint.toFun (LowerAdjoint.id α) x = x

def LowerAdjoint.id (α : Type u_1) [Preorder α] : LowerAdjoint id

The identity function as a lower adjoint to itself.

Equations

• LowerAdjoint.id α = { toFun := fun x => x, gc' := (_ : GaloisConnection id id) }

instance LowerAdjoint.instInhabitedLowerAdjointId {α : Type u_1} [Preorder α] : Inhabited (LowerAdjoint id)

Equations

• LowerAdjoint.instInhabitedLowerAdjointId = { default := LowerAdjoint.id α }

instance LowerAdjoint.instCoeFunLowerAdjointForAll {α : Type u_1} {β : Type u_4} [Preorder α] [Preorder β] {u : β → α} : CoeFun (LowerAdjoint u) fun x => α → β

Equations

• LowerAdjoint.instCoeFunLowerAdjointForAll = { coe := LowerAdjoint.toFun }

theorem LowerAdjoint.gc {α : Type u_1} {β : Type u_4} [Preorder α] [Preorder β] {u : β → α} (l : LowerAdjoint u) : GaloisConnection l.toFun u

theorem LowerAdjoint.ext {α : Type u_1} {β : Type u_4} [Preorder α] [Preorder β] {u : β → α} (l₁ : LowerAdjoint u) (l₂ : LowerAdjoint u) : l₁.toFun = l₂.toFun → l₁ = l₂

theorem LowerAdjoint.monotone {α : Type u_1} {β : Type u_4} [Preorder α] [Preorder β] {u : β → α} (l : LowerAdjoint u) : Monotone (u ∘ l.toFun)

theorem LowerAdjoint.le_closure {α : Type u_1} {β : Type u_4} [Preorder α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (x : α) : x ≤ u (LowerAdjoint.toFun l x)

Every element is less than its closure. This property is sometimes referred to as extensivity or inflationarity.

@[simp]

theorem LowerAdjoint.closureOperator_apply {α : Type u_1} {β : Type u_4} [PartialOrder α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (x : α) : ↑(LowerAdjoint.closureOperator l) x = u (LowerAdjoint.toFun l x)

def LowerAdjoint.closureOperator {α : Type u_1} {β : Type u_4} [PartialOrder α] [Preorder β] {u : β → α} (l : LowerAdjoint u) : ClosureOperator α

Every lower adjoint induces a closure operator given by the composition. This is the partial order version of the statement that every adjunction induces a monad.

Equations

• One or more equations did not get rendered due to their size.

theorem LowerAdjoint.idempotent {α : Type u_1} {β : Type u_4} [PartialOrder α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (x : α) : u (LowerAdjoint.toFun l (u (LowerAdjoint.toFun l x))) = u (LowerAdjoint.toFun l x)

theorem LowerAdjoint.le_closure_iff {α : Type u_1} {β : Type u_4} [PartialOrder α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (x : α) (y : α) : x ≤ u (LowerAdjoint.toFun l y) ↔ u (LowerAdjoint.toFun l x) ≤ u (LowerAdjoint.toFun l y)

def LowerAdjoint.closed {α : Type u_1} {β : Type u_4} [Preorder α] [Preorder β] {u : β → α} (l : LowerAdjoint u) : Set α

An element x is closed for l : LowerAdjoint u if it is a fixed point: u (l x) = x

Equations

• LowerAdjoint.closed l = {x | u (LowerAdjoint.toFun l x) = x}

theorem LowerAdjoint.mem_closed_iff {α : Type u_1} {β : Type u_4} [Preorder α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (x : α) : x ∈ LowerAdjoint.closed l ↔ u (LowerAdjoint.toFun l x) = x

theorem LowerAdjoint.closure_eq_self_of_mem_closed {α : Type u_1} {β : Type u_4} [Preorder α] [Preorder β] {u : β → α} (l : LowerAdjoint u) {x : α} (h : x ∈ LowerAdjoint.closed l) : u (LowerAdjoint.toFun l x) = x

theorem LowerAdjoint.mem_closed_iff_closure_le {α : Type u_1} {β : Type u_4} [PartialOrder α] [PartialOrder β] {u : β → α} (l : LowerAdjoint u) (x : α) : x ∈ LowerAdjoint.closed l ↔ u (LowerAdjoint.toFun l x) ≤ x

@[simp]

theorem LowerAdjoint.closure_is_closed {α : Type u_1} {β : Type u_4} [PartialOrder α] [PartialOrder β] {u : β → α} (l : LowerAdjoint u) (x : α) : u (LowerAdjoint.toFun l x) ∈ LowerAdjoint.closed l

theorem LowerAdjoint.closed_eq_range_close {α : Type u_1} {β : Type u_4} [PartialOrder α] [PartialOrder β] {u : β → α} (l : LowerAdjoint u) : LowerAdjoint.closed l = Set.range (u ∘ l.toFun)

The set of closed elements for l is the range of u ∘ l.

def LowerAdjoint.toClosed {α : Type u_1} {β : Type u_4} [PartialOrder α] [PartialOrder β] {u : β → α} (l : LowerAdjoint u) (x : α) : ↑(LowerAdjoint.closed l)

Send an x to an element of the set of closed elements (by taking the closure).

Equations

• LowerAdjoint.toClosed l x = { val := u (LowerAdjoint.toFun l x), property := (_ : u (LowerAdjoint.toFun l x) ∈ LowerAdjoint.closed l) }

@[simp]

theorem LowerAdjoint.closure_le_closed_iff_le {α : Type u_1} {β : Type u_4} [PartialOrder α] [PartialOrder β] {u : β → α} (l : LowerAdjoint u) (x : α) {y : α} (hy : LowerAdjoint.closed l y) : u (LowerAdjoint.toFun l x) ≤ y ↔ x ≤ y

theorem LowerAdjoint.closure_top {α : Type u_1} {β : Type u_4} [PartialOrder α] [OrderTop α] [Preorder β] {u : β → α} (l : LowerAdjoint u) : u (LowerAdjoint.toFun l ⊤) = ⊤

theorem LowerAdjoint.closure_inf_le {α : Type u_1} {β : Type u_4} [SemilatticeInf α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (x : α) (y : α) : u (LowerAdjoint.toFun l (x ⊓ y)) ≤ u (LowerAdjoint.toFun l x) ⊓ u (LowerAdjoint.toFun l y)

theorem LowerAdjoint.closure_sup_closure_le {α : Type u_1} {β : Type u_4} [SemilatticeSup α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (x : α) (y : α) : u (LowerAdjoint.toFun l x) ⊔ u (LowerAdjoint.toFun l y) ≤ u (LowerAdjoint.toFun l (x ⊔ y))

theorem LowerAdjoint.closure_sup_closure_left {α : Type u_1} {β : Type u_4} [SemilatticeSup α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (x : α) (y : α) : u (LowerAdjoint.toFun l (u (LowerAdjoint.toFun l x) ⊔ y)) = u (LowerAdjoint.toFun l (x ⊔ y))

theorem LowerAdjoint.closure_sup_closure_right {α : Type u_1} {β : Type u_4} [SemilatticeSup α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (x : α) (y : α) : u (LowerAdjoint.toFun l (x ⊔ u (LowerAdjoint.toFun l y))) = u (LowerAdjoint.toFun l (x ⊔ y))

theorem LowerAdjoint.closure_sup_closure {α : Type u_1} {β : Type u_4} [SemilatticeSup α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (x : α) (y : α) : u (LowerAdjoint.toFun l (u (LowerAdjoint.toFun l x) ⊔ u (LowerAdjoint.toFun l y))) = u (LowerAdjoint.toFun l (x ⊔ y))

theorem LowerAdjoint.closure_iSup_closure {α : Type u_1} {ι : Sort u_2} {β : Type u_4} [CompleteLattice α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (f : ι → α) : u (LowerAdjoint.toFun l (⨆ (i : ι), u (LowerAdjoint.toFun l (f i)))) = u (LowerAdjoint.toFun l (⨆ (i : ι), f i))

theorem LowerAdjoint.closure_iSup₂_closure {α : Type u_1} {ι : Sort u_2} {κ : ι → Sort u_3} {β : Type u_4} [CompleteLattice α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (f : (i : ι) → κ i → α) : u (LowerAdjoint.toFun l (⨆ (i : ι) (j : κ i), u (LowerAdjoint.toFun l (f i j)))) = u (LowerAdjoint.toFun l (⨆ (i : ι) (j : κ i), f i j))

theorem LowerAdjoint.subset_closure {α : Type u_1} {β : Type u_4} [SetLike α β] (l : LowerAdjoint SetLike.coe) (s : Set β) : s ⊆ ↑(LowerAdjoint.toFun l s)

theorem LowerAdjoint.not_mem_of_not_mem_closure {α : Type u_1} {β : Type u_4} [SetLike α β] (l : LowerAdjoint SetLike.coe) {s : Set β} {P : β} (hP : ¬P ∈ LowerAdjoint.toFun l s) : ¬P ∈ s

theorem LowerAdjoint.le_iff_subset {α : Type u_1} {β : Type u_4} [SetLike α β] (l : LowerAdjoint SetLike.coe) (s : Set β) (S : α) : LowerAdjoint.toFun l s ≤ S ↔ s ⊆ ↑S

theorem LowerAdjoint.mem_iff {α : Type u_1} {β : Type u_4} [SetLike α β] (l : LowerAdjoint SetLike.coe) (s : Set β) (x : β) : x ∈ LowerAdjoint.toFun l s ↔ ∀ (S : α), s ⊆ ↑S → x ∈ S

theorem LowerAdjoint.eq_of_le {α : Type u_1} {β : Type u_4} [SetLike α β] (l : LowerAdjoint SetLike.coe) {s : Set β} {S : α} (h₁ : s ⊆ ↑S) (h₂ : S ≤ LowerAdjoint.toFun l s) : LowerAdjoint.toFun l s = S

theorem LowerAdjoint.closure_union_closure_subset {α : Type u_1} {β : Type u_4} [SetLike α β] (l : LowerAdjoint SetLike.coe) (x : α) (y : α) : ↑(LowerAdjoint.toFun l ↑x) ∪ ↑(LowerAdjoint.toFun l ↑y) ⊆ ↑(LowerAdjoint.toFun l (↑x ∪ ↑y))

@[simp]

theorem LowerAdjoint.closure_union_closure_left {α : Type u_1} {β : Type u_4} [SetLike α β] (l : LowerAdjoint SetLike.coe) (x : α) (y : α) : LowerAdjoint.toFun l (↑(LowerAdjoint.toFun l ↑x) ∪ ↑y) = LowerAdjoint.toFun l (↑x ∪ ↑y)

@[simp]

theorem LowerAdjoint.closure_union_closure_right {α : Type u_1} {β : Type u_4} [SetLike α β] (l : LowerAdjoint SetLike.coe) (x : α) (y : α) : LowerAdjoint.toFun l (↑x ∪ ↑(LowerAdjoint.toFun l ↑y)) = LowerAdjoint.toFun l (↑x ∪ ↑y)

theorem LowerAdjoint.closure_union_closure {α : Type u_1} {β : Type u_4} [SetLike α β] (l : LowerAdjoint SetLike.coe) (x : α) (y : α) : LowerAdjoint.toFun l (↑(LowerAdjoint.toFun l ↑x) ∪ ↑(LowerAdjoint.toFun l ↑y)) = LowerAdjoint.toFun l (↑x ∪ ↑y)

@[simp]

theorem LowerAdjoint.closure_iUnion_closure {α : Type u_1} {ι : Sort u_2} {β : Type u_4} [SetLike α β] (l : LowerAdjoint SetLike.coe) (f : ι → α) : LowerAdjoint.toFun l (⋃ (i : ι), ↑(LowerAdjoint.toFun l ↑(f i))) = LowerAdjoint.toFun l (⋃ (i : ι), ↑(f i))

@[simp]

theorem LowerAdjoint.closure_iUnion₂_closure {α : Type u_1} {ι : Sort u_2} {κ : ι → Sort u_3} {β : Type u_4} [SetLike α β] (l : LowerAdjoint SetLike.coe) (f : (i : ι) → κ i → α) : LowerAdjoint.toFun l (⋃ (i : ι) (j : κ i), ↑(LowerAdjoint.toFun l ↑(f i j))) = LowerAdjoint.toFun l (⋃ (i : ι) (j : κ i), ↑(f i j))

Translations between GaloisConnection, LowerAdjoint, ClosureOperator

@[simp]

theorem GaloisConnection.lowerAdjoint_toFun {α : Type u_1} {β : Type u_4} [Preorder α] [Preorder β] {l : α → β} {u : β → α} (gc : GaloisConnection l u) : ∀ (a : α), LowerAdjoint.toFun (GaloisConnection.lowerAdjoint gc) a = l a

def GaloisConnection.lowerAdjoint {α : Type u_1} {β : Type u_4} [Preorder α] [Preorder β] {l : α → β} {u : β → α} (gc : GaloisConnection l u) : LowerAdjoint u

Every Galois connection induces a lower adjoint.

Equations

• GaloisConnection.lowerAdjoint gc = { toFun := l, gc' := gc }

@[simp]

theorem GaloisConnection.closureOperator_apply {α : Type u_1} {β : Type u_4} [PartialOrder α] [Preorder β] {l : α → β} {u : β → α} (gc : GaloisConnection l u) (x : α) : ↑(GaloisConnection.closureOperator gc) x = u (l x)

def GaloisConnection.closureOperator {α : Type u_1} {β : Type u_4} [PartialOrder α] [Preorder β] {l : α → β} {u : β → α} (gc : GaloisConnection l u) : ClosureOperator α

Every Galois connection induces a closure operator given by the composition. This is the partial order version of the statement that every adjunction induces a monad.

Equations

• GaloisConnection.closureOperator gc = LowerAdjoint.closureOperator (GaloisConnection.lowerAdjoint gc)

def ClosureOperator.gi {α : Type u_1} [PartialOrder α] (c : ClosureOperator α) : GaloisInsertion (ClosureOperator.toClosed c) Subtype.val

The set of closed elements has a Galois insertion to the underlying type.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem closureOperator_gi_self {α : Type u_1} [PartialOrder α] (c : ClosureOperator α) : GaloisConnection.closureOperator (_ : GaloisConnection (ClosureOperator.toClosed c) Subtype.val) = c

The Galois insertion associated to a closure operator can be used to reconstruct the closure operator. Note that the inverse in the opposite direction does not hold in general.