File: Mathlib/Order/Closure.lean

full_name: ClosureOperator.idempotent'
code: /-- A closure operator on the preorder `α` is a monotone function which is extensive (every `x`
is less than its closure) and idempotent. -/
structure ClosureOperator [Preorder α] extends α →o α where
  /-- An element is less than or equal its closure -/
  le_closure' : ∀ x, x ≤ toFun x
  /-- Closures are idempotent -/
  idempotent' : ∀ x, toFun (toFun x) = toFun x
  /-- Predicate for an element to be closed.

  By default, this is defined as `c.IsClosed x := (c x = x)` (see `isClosed_iff`).
  We allow an override to fix definitional equalities. -/
  IsClosed (x : α) : Prop := toFun x = x
  isClosed_iff {x : α} : IsClosed x ↔ toFun x = x := by aesop
goal: self.toFun (self.toFun x) = self.toFun x

full_name: ClosureOperator.isClosed_iff
code: /-- A closure operator on the preorder `α` is a monotone function which is extensive (every `x`
is less than its closure) and idempotent. -/
structure ClosureOperator [Preorder α] extends α →o α where
  /-- An element is less than or equal its closure -/
  le_closure' : ∀ x, x ≤ toFun x
  /-- Closures are idempotent -/
  idempotent' : ∀ x, toFun (toFun x) = toFun x
  /-- Predicate for an element to be closed.

  By default, this is defined as `c.IsClosed x := (c x = x)` (see `isClosed_iff`).
  We allow an override to fix definitional equalities. -/
  IsClosed (x : α) : Prop := toFun x = x
  isClosed_iff {x : α} : IsClosed x ↔ toFun x = x := by aesop
goal: self.IsClosed x ↔ self.toFun x = x

full_name: ClosureOperator.le_closure'
code: /-- A closure operator on the preorder `α` is a monotone function which is extensive (every `x`
is less than its closure) and idempotent. -/
structure ClosureOperator [Preorder α] extends α →o α where
  /-- An element is less than or equal its closure -/
  le_closure' : ∀ x, x ≤ toFun x
  /-- Closures are idempotent -/
  idempotent' : ∀ x, toFun (toFun x) = toFun x
  /-- Predicate for an element to be closed.

  By default, this is defined as `c.IsClosed x := (c x = x)` (see `isClosed_iff`).
  We allow an override to fix definitional equalities. -/
  IsClosed (x : α) : Prop := toFun x = x
  isClosed_iff {x : α} : IsClosed x ↔ toFun x = x := by aesop
goal: x ≤ self.toFun x

full_name: ClosureOperator.IsClosed
code: /-- A closure operator on the preorder `α` is a monotone function which is extensive (every `x`
is less than its closure) and idempotent. -/
structure ClosureOperator [Preorder α] extends α →o α where
  /-- An element is less than or equal its closure -/
  le_closure' : ∀ x, x ≤ toFun x
  /-- Closures are idempotent -/
  idempotent' : ∀ x, toFun (toFun x) = toFun x
  /-- Predicate for an element to be closed.

  By default, this is defined as `c.IsClosed x := (c x = x)` (see `isClosed_iff`).
  We allow an override to fix definitional equalities. -/
  IsClosed (x : α) : Prop := toFun x = x
  isClosed_iff {x : α} : IsClosed x ↔ toFun x = x := by aesop
goal: Prop

full_name: ClosureOperator
code: /-- A closure operator on the preorder `α` is a monotone function which is extensive (every `x`
is less than its closure) and idempotent. -/
structure ClosureOperator [Preorder α] extends α →o α where
  /-- An element is less than or equal its closure -/
  le_closure' : ∀ x, x ≤ toFun x
  /-- Closures are idempotent -/
  idempotent' : ∀ x, toFun (toFun x) = toFun x
  /-- Predicate for an element to be closed.

  By default, this is defined as `c.IsClosed x := (c x = x)` (see `isClosed_iff`).
  We allow an override to fix definitional equalities. -/
  IsClosed (x : α) : Prop := toFun x = x
  isClosed_iff {x : α} : IsClosed x ↔ toFun x = x := by aesop
goal: Type u_1

full_name: ClosureOperator.instFunLike
code: instance [Preorder α] : FunLike (ClosureOperator α) α α 
goal: FunLike (ClosureOperator α) α α

full_name: ClosureOperator.instOrderHomClass
code: instance [Preorder α] : OrderHomClass (ClosureOperator α) α α 
goal: OrderHomClass (ClosureOperator α) α α

full_name: ClosureOperator.conjBy
code: /-- If `c` is a closure operator on `α` and `e` an order-isomorphism
between `α` and `β` then `e ∘ c ∘ e⁻¹` is a closure operator on `β`. -/
@[simps apply]
def conjBy {α β} [Preorder α] [Preorder β] (c : ClosureOperator α)
    (e : α ≃o β) : ClosureOperator β 
goal: ClosureOperator β

full_name: ClosureOperator.conjBy_apply
code: /-- If `c` is a closure operator on `α` and `e` an order-isomorphism
between `α` and `β` then `e ∘ c ∘ e⁻¹` is a closure operator on `β`. -/
@[simps apply]
def conjBy {α β} [Preorder α] [Preorder β] (c : ClosureOperator α)
    (e : α ≃o β) : ClosureOperator β 
goal: (c.conjBy e) a = (e.conj ↑c) a

full_name: ClosureOperator.conjBy_refl
code: lemma conjBy_refl {α} [Preorder α] (c : ClosureOperator α) :
    c.conjBy (OrderIso.refl α) = c 
goal: c.conjBy (OrderIso.refl α) = c

full_name: ClosureOperator.conjBy_trans
code: lemma conjBy_trans {α β γ} [Preorder α] [Preorder β] [Preorder γ]
    (e₁ : α ≃o β) (e₂ : β ≃o γ) (c : ClosureOperator α) :
    c.conjBy (e₁.trans e₂) = (c.conjBy e₁).conjBy e₂ 
goal: c.conjBy (e₁.trans e₂) = (c.conjBy e₁).conjBy e₂

full_name: ClosureOperator.id_isClosed
code: /-- The identity function as a closure operator. -/
@[simps!]
def id : ClosureOperator α 
goal: ∀ (x : α), (ClosureOperator.id α).IsClosed x = True

full_name: ClosureOperator.id
code: /-- The identity function as a closure operator. -/
@[simps!]
def id : ClosureOperator α 
goal: ClosureOperator α

full_name: ClosureOperator.id_apply
code: /-- The identity function as a closure operator. -/
@[simps!]
def id : ClosureOperator α 
goal: (ClosureOperator.id α) a = a

full_name: ClosureOperator.instInhabited
code: instance : Inhabited (ClosureOperator α) 
goal: Inhabited (ClosureOperator α)

full_name: ClosureOperator.ext
code: @[ext]
theorem ext : ∀ c₁ c₂ : ClosureOperator α, (∀ x, c₁ x = c₂ x) → c₁ = c₂ 
goal: (∀ (x : α), c₁ x = c₂ x) → c₁ = c₂

full_name: ClosureOperator.mk'
code: /-- Constructor for a closure operator using the weaker idempotency axiom: `f (f x) ≤ f x`. -/
@[simps]
def mk' (f : α → α) (hf₁ : Monotone f) (hf₂ : ∀ x, x ≤ f x) (hf₃ : ∀ x, f (f x) ≤ f x) :
    ClosureOperator α 
goal: ClosureOperator α

full_name: ClosureOperator.mk'_isClosed
code: /-- Constructor for a closure operator using the weaker idempotency axiom: `f (f x) ≤ f x`. -/
@[simps]
def mk' (f : α → α) (hf₁ : Monotone f) (hf₂ : ∀ x, x ≤ f x) (hf₃ : ∀ x, f (f x) ≤ f x) :
    ClosureOperator α 
goal: (ClosureOperator.mk' f hf₁ hf₂ hf₃).IsClosed x = (f x = x)

full_name: ClosureOperator.mk'_apply
code: /-- Constructor for a closure operator using the weaker idempotency axiom: `f (f x) ≤ f x`. -/
@[simps]
def mk' (f : α → α) (hf₁ : Monotone f) (hf₂ : ∀ x, x ≤ f x) (hf₃ : ∀ x, f (f x) ≤ f x) :
    ClosureOperator α 
goal: ∀ (a : α), (ClosureOperator.mk' f hf₁ hf₂ hf₃) a = f a

full_name: ClosureOperator.mk₂_apply
code: /-- 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. -/
@[simps]
def mk₂ (f : α → α) (hf : ∀ x, x ≤ f x) (hmin : ∀ ⦃x y⦄, x ≤ f y → f x ≤ f y) :
    ClosureOperator α 
goal: ∀ (a : α), (ClosureOperator.mk₂ f hf hmin) a = f a

full_name: ClosureOperator.mk₂_isClosed
code: /-- 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. -/
@[simps]
def mk₂ (f : α → α) (hf : ∀ x, x ≤ f x) (hmin : ∀ ⦃x y⦄, x ≤ f y → f x ≤ f y) :
    ClosureOperator α 
goal: (ClosureOperator.mk₂ f hf hmin).IsClosed x = (f x = x)

full_name: ClosureOperator.mk₂
code: /-- 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. -/
@[simps]
def mk₂ (f : α → α) (hf : ∀ x, x ≤ f x) (hmin : ∀ ⦃x y⦄, x ≤ f y → f x ≤ f y) :
    ClosureOperator α 
goal: ClosureOperator α

full_name: ClosureOperator.ofPred_isClosed
code: /-- Construct a closure operator from an inflationary function `f` and a "closedness" predicate `p`
witnessing minimality of `f x` among closed elements greater than `x`. -/
@[simps!]
def ofPred (f : α → α) (p : α → Prop) (hf : ∀ x, x ≤ f x) (hfp : ∀ x, p (f x))
    (hmin : ∀ ⦃x y⦄, x ≤ y → p y → f x ≤ y) : ClosureOperator α 
goal: ∀ (a : α), (ClosureOperator.ofPred f p hf hfp hmin).IsClosed a = p a

full_name: ClosureOperator.ofPred_apply
code: /-- Construct a closure operator from an inflationary function `f` and a "closedness" predicate `p`
witnessing minimality of `f x` among closed elements greater than `x`. -/
@[simps!]
def ofPred (f : α → α) (p : α → Prop) (hf : ∀ x, x ≤ f x) (hfp : ∀ x, p (f x))
    (hmin : ∀ ⦃x y⦄, x ≤ y → p y → f x ≤ y) : ClosureOperator α 
goal: ∀ (a : α), (ClosureOperator.ofPred f p hf hfp hmin) a = f a

full_name: ClosureOperator.ofPred
code: /-- Construct a closure operator from an inflationary function `f` and a "closedness" predicate `p`
witnessing minimality of `f x` among closed elements greater than `x`. -/
@[simps!]
def ofPred (f : α → α) (p : α → Prop) (hf : ∀ x, x ≤ f x) (hfp : ∀ x, p (f x))
    (hmin : ∀ ⦃x y⦄, x ≤ y → p y → f x ≤ y) : ClosureOperator α 
goal: ClosureOperator α

full_name: ClosureOperator.monotone
code: @[mono]
theorem monotone : Monotone c 
goal: Monotone ⇑c

full_name: ClosureOperator.le_closure
code: /-- Every element is less than its closure. This property is sometimes referred to as extensivity or
inflationarity. -/
theorem le_closure (x : α) : x ≤ c x 
goal: x ≤ c x

full_name: ClosureOperator.idempotent
code: @[simp]
theorem idempotent (x : α) : c (c x) = c x 
goal: c (c x) = c x

full_name: ClosureOperator.isClosed_closure
code: @[simp] lemma isClosed_closure (x : α) : c.IsClosed (c x) 
goal: c.IsClosed (c x)

full_name: ClosureOperator.Closeds
code: /-- The type of elements closed under a closure operator. -/
abbrev Closeds 
goal: Type u_1

full_name: ClosureOperator.toCloseds
code: /-- Send an element to a closed element (by taking the closure). -/
def toCloseds (x : α) : c.Closeds 
goal: c.Closeds

full_name: ClosureOperator.IsClosed.closure_eq
code: theorem IsClosed.closure_eq : c.IsClosed x → c x = x 
goal: c.IsClosed x → c x = x

full_name: ClosureOperator.isClosed_iff_closure_le
code: theorem isClosed_iff_closure_le : c.IsClosed x ↔ c x ≤ x 
goal: c.IsClosed x ↔ c x ≤ x

full_name: ClosureOperator.setOf_isClosed_eq_range_closure
code: /-- The set of closed elements for `c` is exactly its range. -/
theorem setOf_isClosed_eq_range_closure : {x | c.IsClosed x} = Set.range c 
goal: {x | c.IsClosed x} = Set.range ⇑c

full_name: ClosureOperator.le_closure_iff
code: theorem le_closure_iff : x ≤ c y ↔ c x ≤ c y 
goal: x ≤ c y ↔ c x ≤ c y

full_name: ClosureOperator.IsClosed.closure_le_iff
code: @[simp]
theorem IsClosed.closure_le_iff (hy : c.IsClosed y) : c x ≤ y ↔ x ≤ y 
goal: c x ≤ y ↔ x ≤ y

full_name: ClosureOperator.closure_min
code: lemma closure_min (hxy : x ≤ y) (hy : c.IsClosed y) : c x ≤ y 
goal: c x ≤ y

full_name: ClosureOperator.closure_isGLB
code: lemma closure_isGLB (x : α) : IsGLB { y | x ≤ y ∧ c.IsClosed y } (c x) 
goal: IsGLB {y | x ≤ y ∧ c.IsClosed y} (c x)

full_name: ClosureOperator.ext_isClosed
code: theorem ext_isClosed (c₁ c₂ : ClosureOperator α)
    (h : ∀ x, c₁.IsClosed x ↔ c₂.IsClosed x) : c₁ = c₂ 
goal: c₁ = c₂

full_name: ClosureOperator.eq_ofPred_closed
code: /-- A closure operator is equal to the closure operator obtained by feeding `c.closed` into the
`ofPred` constructor. -/
theorem eq_ofPred_closed (c : ClosureOperator α) :
    c = ofPred c c.IsClosed c.le_closure c.isClosed_closure fun x y ↦ closure_min 
goal: c = ClosureOperator.ofPred (⇑c) c.IsClosed ⋯ ⋯ ⋯

full_name: ClosureOperator.closure_top
code: @[simp]
theorem closure_top : c ⊤ = ⊤ 
goal: c ⊤ = ⊤

full_name: ClosureOperator.isClosed_top
code: @[simp] lemma isClosed_top : c.IsClosed ⊤ 
goal: c.IsClosed ⊤

full_name: ClosureOperator.closure_inf_le
code: theorem closure_inf_le [SemilatticeInf α] (c : ClosureOperator α) (x y : α) :
    c (x ⊓ y) ≤ c x ⊓ c y 
goal: c (x ⊓ y) ≤ c x ⊓ c y

full_name: ClosureOperator.closure_sup_closure_le
code: theorem closure_sup_closure_le (x y : α) : c x ⊔ c y ≤ c (x ⊔ y) 
goal: c x ⊔ c y ≤ c (x ⊔ y)

full_name: ClosureOperator.closure_sup_closure_left
code: theorem closure_sup_closure_left (x y : α) : c (c x ⊔ y) = c (x ⊔ y) 
goal: c (c x ⊔ y) = c (x ⊔ y)

full_name: ClosureOperator.closure_sup_closure_right
code: theorem closure_sup_closure_right (x y : α) : c (x ⊔ c y) = c (x ⊔ y) 
goal: c (x ⊔ c y) = c (x ⊔ y)

full_name: ClosureOperator.closure_sup_closure
code: theorem closure_sup_closure (x y : α) : c (c x ⊔ c y) = c (x ⊔ y) 
goal: c (c x ⊔ c y) = c (x ⊔ y)

full_name: ClosureOperator.ofCompletePred_isClosed
code: /-- Define a closure operator from a predicate that's preserved under infima. -/
@[simps!]
def ofCompletePred (p : α → Prop) (hsinf : ∀ s, (∀ a ∈ s, p a) → p (sInf s)) : ClosureOperator α 
goal: ∀ (a : α), (ClosureOperator.ofCompletePred p hsinf).IsClosed a = p a

full_name: ClosureOperator.ofCompletePred_apply
code: /-- Define a closure operator from a predicate that's preserved under infima. -/
@[simps!]
def ofCompletePred (p : α → Prop) (hsinf : ∀ s, (∀ a ∈ s, p a) → p (sInf s)) : ClosureOperator α 
goal: (ClosureOperator.ofCompletePred p hsinf) a = ⨅ b, ↑b

full_name: ClosureOperator.ofCompletePred
code: /-- Define a closure operator from a predicate that's preserved under infima. -/
@[simps!]
def ofCompletePred (p : α → Prop) (hsinf : ∀ s, (∀ a ∈ s, p a) → p (sInf s)) : ClosureOperator α 
goal: ClosureOperator α

full_name: ClosureOperator.sInf_isClosed
code: theorem sInf_isClosed {c : ClosureOperator α} {S : Set α}
    (H : ∀ x ∈ S, c.IsClosed x) : c.IsClosed (sInf S) 
goal: c.IsClosed (sInf S)

full_name: ClosureOperator.closure_iSup_closure
code: @[simp]
theorem closure_iSup_closure (f : ι → α) : c (⨆ i, c (f i)) = c (⨆ i, f i) 
goal: c (⨆ i, c (f i)) = c (⨆ i, f i)

full_name: ClosureOperator.closure_iSup₂_closure
code: @[simp]
theorem closure_iSup₂_closure (f : ∀ i, κ i → α) :
    c (⨆ (i) (j), c (f i j)) = c (⨆ (i) (j), f i j) 
goal: c (⨆ i, ⨆ j, c (f i j)) = c (⨆ i, ⨆ j, f i j)

full_name: OrderIso.equivClosureOperator
code: /-- Conjugating `ClosureOperators` on `α` and on `β` by a fixed isomorphism
`e : α ≃o β` gives an equivalence `ClosureOperator α ≃ ClosureOperator β`. -/
@[simps apply symm_apply]
def OrderIso.equivClosureOperator {α β} [Preorder α] [Preorder β] (e : α ≃o β) :
    ClosureOperator α ≃ ClosureOperator β 
goal: ClosureOperator α ≃ ClosureOperator β

full_name: OrderIso.equivClosureOperator_apply
code: /-- Conjugating `ClosureOperators` on `α` and on `β` by a fixed isomorphism
`e : α ≃o β` gives an equivalence `ClosureOperator α ≃ ClosureOperator β`. -/
@[simps apply symm_apply]
def OrderIso.equivClosureOperator {α β} [Preorder α] [Preorder β] (e : α ≃o β) :
    ClosureOperator α ≃ ClosureOperator β 
goal: e.equivClosureOperator c = c.conjBy e

full_name: OrderIso.equivClosureOperator_symm_apply
code: /-- Conjugating `ClosureOperators` on `α` and on `β` by a fixed isomorphism
`e : α ≃o β` gives an equivalence `ClosureOperator α ≃ ClosureOperator β`. -/
@[simps apply symm_apply]
def OrderIso.equivClosureOperator {α β} [Preorder α] [Preorder β] (e : α ≃o β) :
    ClosureOperator α ≃ ClosureOperator β 
goal: e.equivClosureOperator.symm c = c.conjBy e.symm

full_name: LowerAdjoint.toFun
code: /-- 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 `(↑) : β → α`. -/
structure LowerAdjoint [Preorder α] [Preorder β] (u : β → α) where
  /-- The underlying function -/
  toFun : α → β
  /-- The underlying function is a lower adjoint. -/
  gc' : GaloisConnection toFun u
goal: α → β

full_name: LowerAdjoint.gc'
code: /-- 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 `(↑) : β → α`. -/
structure LowerAdjoint [Preorder α] [Preorder β] (u : β → α) where
  /-- The underlying function -/
  toFun : α → β
  /-- The underlying function is a lower adjoint. -/
  gc' : GaloisConnection toFun u
goal: GaloisConnection self.toFun u

full_name: LowerAdjoint
code: /-- 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 `(↑) : β → α`. -/
structure LowerAdjoint [Preorder α] [Preorder β] (u : β → α) where
  /-- The underlying function -/
  toFun : α → β
  /-- The underlying function is a lower adjoint. -/
  gc' : GaloisConnection toFun u
goal: Type (max u_1 u_4)

full_name: LowerAdjoint.id_toFun
code: /-- The identity function as a lower adjoint to itself. -/
@[simps]
protected def id [Preorder α] : LowerAdjoint (id : α → α) 
goal: (LowerAdjoint.id α).toFun x = x

full_name: LowerAdjoint.id
code: /-- The identity function as a lower adjoint to itself. -/
@[simps]
protected def id [Preorder α] : LowerAdjoint (id : α → α) 
goal: LowerAdjoint id

full_name: LowerAdjoint.instInhabitedId
code: instance [Preorder α] : Inhabited (LowerAdjoint (id : α → α)) 
goal: Inhabited (LowerAdjoint id)

full_name: LowerAdjoint.instCoeFunForall
code: instance : CoeFun (LowerAdjoint u) fun _ => α → β 
goal: CoeFun (LowerAdjoint u) fun x => α → β

full_name: LowerAdjoint.gc
code: theorem gc : GaloisConnection l u 
goal: GaloisConnection l.toFun u

full_name: LowerAdjoint.ext
code: @[ext]
theorem ext : ∀ l₁ l₂ : LowerAdjoint u, (l₁ : α → β) = (l₂ : α → β) → l₁ = l₂
  
goal: l₁.toFun = l₂.toFun → l₁ = l₂

full_name: LowerAdjoint.monotone
code: @[mono]
theorem monotone : Monotone (u ∘ l) 
goal: Monotone (u ∘ l.toFun)

full_name: LowerAdjoint.le_closure
code: /-- Every element is less than its closure. This property is sometimes referred to as extensivity or
inflationarity. -/
theorem le_closure (x : α) : x ≤ u (l x) 
goal: x ≤ u (l.toFun x)

full_name: LowerAdjoint.closureOperator_isClosed
code: /-- 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. -/
@[simps]
def closureOperator : ClosureOperator α 
goal: l.closureOperator.IsClosed x = (u (l.toFun x) = x)

full_name: LowerAdjoint.closureOperator
code: /-- 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. -/
@[simps]
def closureOperator : ClosureOperator α 
goal: ClosureOperator α

full_name: LowerAdjoint.closureOperator_apply
code: /-- 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. -/
@[simps]
def closureOperator : ClosureOperator α 
goal: l.closureOperator x = u (l.toFun x)

full_name: LowerAdjoint.idempotent
code: theorem idempotent (x : α) : u (l (u (l x))) = u (l x) 
goal: u (l.toFun (u (l.toFun x))) = u (l.toFun x)

full_name: LowerAdjoint.le_closure_iff
code: theorem le_closure_iff (x y : α) : x ≤ u (l y) ↔ u (l x) ≤ u (l y) 
goal: x ≤ u (l.toFun y) ↔ u (l.toFun x) ≤ u (l.toFun y)

full_name: LowerAdjoint.closed
code: /-- An element `x` is closed for `l : LowerAdjoint u` if it is a fixed point: `u (l x) = x` -/
def closed : Set α 
goal: Set α

full_name: LowerAdjoint.mem_closed_iff
code: theorem mem_closed_iff (x : α) : x ∈ l.closed ↔ u (l x) = x 
goal: x ∈ l.closed ↔ u (l.toFun x) = x

full_name: LowerAdjoint.closure_eq_self_of_mem_closed
code: theorem closure_eq_self_of_mem_closed {x : α} (h : x ∈ l.closed) : u (l x) = x 
goal: u (l.toFun x) = x

full_name: LowerAdjoint.mem_closed_iff_closure_le
code: theorem mem_closed_iff_closure_le (x : α) : x ∈ l.closed ↔ u (l x) ≤ x 
goal: x ∈ l.closed ↔ u (l.toFun x) ≤ x

full_name: LowerAdjoint.closure_is_closed
code: @[simp, nolint simpNF] -- Porting note: lemma does prove itself, seems to be a linter error
theorem closure_is_closed (x : α) : u (l x) ∈ l.closed 
goal: u (l.toFun x) ∈ l.closed

full_name: LowerAdjoint.closed_eq_range_close
code: /-- The set of closed elements for `l` is the range of `u ∘ l`. -/
theorem closed_eq_range_close : l.closed = Set.range (u ∘ l) 
goal: l.closed = Set.range (u ∘ l.toFun)

full_name: LowerAdjoint.toClosed
code: /-- Send an `x` to an element of the set of closed elements (by taking the closure). -/
def toClosed (x : α) : l.closed 
goal: ↑l.closed

full_name: LowerAdjoint.closure_le_closed_iff_le
code: @[simp]
theorem closure_le_closed_iff_le (x : α) {y : α} (hy : l.closed y) : u (l x) ≤ y ↔ x ≤ y 
goal: u (l.toFun x) ≤ y ↔ x ≤ y

full_name: LowerAdjoint.closure_top
code: theorem closure_top [PartialOrder α] [OrderTop α] [Preorder β] {u : β → α} (l : LowerAdjoint u) :
    u (l ⊤) = ⊤ 
goal: u (l.toFun ⊤) = ⊤

full_name: LowerAdjoint.closure_inf_le
code: theorem closure_inf_le [SemilatticeInf α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (x y : α) :
    u (l (x ⊓ y)) ≤ u (l x) ⊓ u (l y) 
goal: u (l.toFun (x ⊓ y)) ≤ u (l.toFun x) ⊓ u (l.toFun y)

full_name: LowerAdjoint.closure_sup_closure_le
code: theorem closure_sup_closure_le (x y : α) : u (l x) ⊔ u (l y) ≤ u (l (x ⊔ y)) 
goal: u (l.toFun x) ⊔ u (l.toFun y) ≤ u (l.toFun (x ⊔ y))

full_name: LowerAdjoint.closure_sup_closure_left
code: theorem closure_sup_closure_left (x y : α) : u (l (u (l x) ⊔ y)) = u (l (x ⊔ y)) 
goal: u (l.toFun (u (l.toFun x) ⊔ y)) = u (l.toFun (x ⊔ y))

full_name: LowerAdjoint.closure_sup_closure_right
code: theorem closure_sup_closure_right (x y : α) : u (l (x ⊔ u (l y))) = u (l (x ⊔ y)) 
goal: u (l.toFun (x ⊔ u (l.toFun y))) = u (l.toFun (x ⊔ y))

full_name: LowerAdjoint.closure_sup_closure
code: theorem closure_sup_closure (x y : α) : u (l (u (l x) ⊔ u (l y))) = u (l (x ⊔ y)) 
goal: u (l.toFun (u (l.toFun x) ⊔ u (l.toFun y))) = u (l.toFun (x ⊔ y))

full_name: LowerAdjoint.closure_iSup_closure
code: theorem closure_iSup_closure (f : ι → α) : u (l (⨆ i, u (l (f i)))) = u (l (⨆ i, f i)) 
goal: u (l.toFun (⨆ i, u (l.toFun (f i)))) = u (l.toFun (⨆ i, f i))

full_name: LowerAdjoint.closure_iSup₂_closure
code: theorem closure_iSup₂_closure (f : ∀ i, κ i → α) :
    u (l <| ⨆ (i) (j), u (l <| f i j)) = u (l <| ⨆ (i) (j), f i j) 
goal: u (l.toFun (⨆ i, ⨆ j, u (l.toFun (f i j)))) = u (l.toFun (⨆ i, ⨆ j, f i j))

full_name: LowerAdjoint.subset_closure
code: theorem subset_closure (s : Set β) : s ⊆ l s 
goal: s ⊆ ↑(l.toFun s)

full_name: LowerAdjoint.not_mem_of_not_mem_closure
code: theorem not_mem_of_not_mem_closure {s : Set β} {P : β} (hP : P ∉ l s) : P ∉ s 
goal: P ∉ s

full_name: LowerAdjoint.le_iff_subset
code: theorem le_iff_subset (s : Set β) (S : α) : l s ≤ S ↔ s ⊆ S 
goal: l.toFun s ≤ S ↔ s ⊆ ↑S

full_name: LowerAdjoint.mem_iff
code: theorem mem_iff (s : Set β) (x : β) : x ∈ l s ↔ ∀ S : α, s ⊆ S → x ∈ S 
goal: x ∈ l.toFun s ↔ ∀ (S : α), s ⊆ ↑S → x ∈ S

full_name: LowerAdjoint.eq_of_le
code: theorem eq_of_le {s : Set β} {S : α} (h₁ : s ⊆ S) (h₂ : S ≤ l s) : l s = S 
goal: l.toFun s = S

full_name: LowerAdjoint.closure_union_closure_subset
code: theorem closure_union_closure_subset (x y : α) : (l x : Set β) ∪ l y ⊆ l (x ∪ y) 
goal: ↑(l.toFun ↑x) ∪ ↑(l.toFun ↑y) ⊆ ↑(l.toFun (↑x ∪ ↑y))

full_name: LowerAdjoint.closure_union_closure_left
code: @[simp]
theorem closure_union_closure_left (x y : α) : l (l x ∪ y) = l (x ∪ y) 
goal: l.toFun (↑(l.toFun ↑x) ∪ ↑y) = l.toFun (↑x ∪ ↑y)

full_name: LowerAdjoint.closure_union_closure_right
code: @[simp]
theorem closure_union_closure_right (x y : α) : l (x ∪ l y) = l (x ∪ y) 
goal: l.toFun (↑x ∪ ↑(l.toFun ↑y)) = l.toFun (↑x ∪ ↑y)

full_name: LowerAdjoint.closure_union_closure
code: theorem closure_union_closure (x y : α) : l (l x ∪ l y) = l (x ∪ y) 
goal: l.toFun (↑(l.toFun ↑x) ∪ ↑(l.toFun ↑y)) = l.toFun (↑x ∪ ↑y)

full_name: LowerAdjoint.closure_iUnion_closure
code: @[simp]
theorem closure_iUnion_closure (f : ι → α) : l (⋃ i, l (f i)) = l (⋃ i, f i) 
goal: l.toFun (⋃ i, ↑(l.toFun ↑(f i))) = l.toFun (⋃ i, ↑(f i))

full_name: LowerAdjoint.closure_iUnion₂_closure
code: @[simp]
theorem closure_iUnion₂_closure (f : ∀ i, κ i → α) :
    l (⋃ (i) (j), l (f i j)) = l (⋃ (i) (j), f i j) 
goal: l.toFun (⋃ i, ⋃ j, ↑(l.toFun ↑(f i j))) = l.toFun (⋃ i, ⋃ j, ↑(f i j))

full_name: GaloisConnection.lowerAdjoint_toFun
code: /-- Every Galois connection induces a lower adjoint. -/
@[simps]
def GaloisConnection.lowerAdjoint [Preorder α] [Preorder β] {l : α → β} {u : β → α}
    (gc : GaloisConnection l u) : LowerAdjoint u 
goal: ∀ (a : α), gc.lowerAdjoint.toFun a = l a

full_name: GaloisConnection.lowerAdjoint
code: /-- Every Galois connection induces a lower adjoint. -/
@[simps]
def GaloisConnection.lowerAdjoint [Preorder α] [Preorder β] {l : α → β} {u : β → α}
    (gc : GaloisConnection l u) : LowerAdjoint u 
goal: LowerAdjoint u

full_name: GaloisConnection.closureOperator_isClosed
code: /-- 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. -/
@[simps!]
def GaloisConnection.closureOperator [PartialOrder α] [Preorder β] {l : α → β} {u : β → α}
    (gc : GaloisConnection l u) : ClosureOperator α 
goal: gc.closureOperator.IsClosed x = (u (l x) = x)

full_name: GaloisConnection.closureOperator_apply
code: /-- 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. -/
@[simps!]
def GaloisConnection.closureOperator [PartialOrder α] [Preorder β] {l : α → β} {u : β → α}
    (gc : GaloisConnection l u) : ClosureOperator α 
goal: gc.closureOperator x = u (l x)

full_name: GaloisConnection.closureOperator
code: /-- 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. -/
@[simps!]
def GaloisConnection.closureOperator [PartialOrder α] [Preorder β] {l : α → β} {u : β → α}
    (gc : GaloisConnection l u) : ClosureOperator α 
goal: ClosureOperator α

full_name: ClosureOperator.gi
code: /-- The set of closed elements has a Galois insertion to the underlying type. -/
def ClosureOperator.gi [PartialOrder α] (c : ClosureOperator α) :
    GaloisInsertion c.toCloseds (↑) 
goal: GaloisInsertion c.toCloseds Subtype.val

full_name: closureOperator_gi_self
code: /-- 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. -/
@[simp]
theorem closureOperator_gi_self [PartialOrder α] (c : ClosureOperator α) :
    c.gi.gc.closureOperator = c 
goal: ⋯.closureOperator = c