File: Mathlib/Order/GaloisConnection.lean

full_name: GaloisConnection
code: /-- A Galois connection is a pair of functions `l` and `u` satisfying
`l a ≤ b ↔ a ≤ u b`. They are special cases of adjoint functors in category theory,
but do not depend on the category theory library in mathlib. -/
def GaloisConnection [Preorder α] [Preorder β] (l : α → β) (u : β → α) 
goal: Prop

full_name: OrderIso.to_galoisConnection
code: /-- Makes a Galois connection from an order-preserving bijection. -/
theorem OrderIso.to_galoisConnection [Preorder α] [Preorder β] (oi : α ≃o β) :
    GaloisConnection oi oi.symm 
goal: GaloisConnection ⇑oi ⇑oi.symm

full_name: GaloisConnection.monotone_intro
code: theorem monotone_intro (hu : Monotone u) (hl : Monotone l) (hul : ∀ a, a ≤ u (l a))
    (hlu : ∀ a, l (u a) ≤ a) : GaloisConnection l u 
goal: GaloisConnection l u

full_name: GaloisConnection.dual
code: protected theorem dual {l : α → β} {u : β → α} (gc : GaloisConnection l u) :
    GaloisConnection (OrderDual.toDual ∘ u ∘ OrderDual.ofDual)
      (OrderDual.toDual ∘ l ∘ OrderDual.ofDual) 
goal: GaloisConnection (⇑OrderDual.toDual ∘ u ∘ ⇑OrderDual.ofDual) (⇑OrderDual.toDual ∘ l ∘ ⇑OrderDual.ofDual)

full_name: GaloisConnection.le_iff_le
code: theorem le_iff_le {a : α} {b : β} : l a ≤ b ↔ a ≤ u b 
goal: l a ≤ b ↔ a ≤ u b

full_name: GaloisConnection.l_le
code: theorem l_le {a : α} {b : β} : a ≤ u b → l a ≤ b 
goal: a ≤ u b → l a ≤ b

full_name: GaloisConnection.le_u
code: theorem le_u {a : α} {b : β} : l a ≤ b → a ≤ u b 
goal: l a ≤ b → a ≤ u b

full_name: GaloisConnection.le_u_l
code: theorem le_u_l (a) : a ≤ u (l a) 
goal: a ≤ u (l a)

full_name: GaloisConnection.l_u_le
code: theorem l_u_le (a) : l (u a) ≤ a 
goal: l (u a) ≤ a

full_name: GaloisConnection.monotone_u
code: theorem monotone_u : Monotone u 
goal: Monotone u

full_name: GaloisConnection.monotone_l
code: theorem monotone_l : Monotone l 
goal: Monotone l

full_name: GaloisConnection.upperBounds_l_image
code: theorem upperBounds_l_image (gc : GaloisConnection l u) (s : Set α) :
    upperBounds (l '' s) = u ⁻¹' upperBounds s 
goal: upperBounds (l '' s) = u ⁻¹' upperBounds s

full_name: GaloisConnection.lowerBounds_u_image
code: theorem lowerBounds_u_image (gc : GaloisConnection l u) (s : Set β) :
    lowerBounds (u '' s) = l ⁻¹' lowerBounds s 
goal: lowerBounds (u '' s) = l ⁻¹' lowerBounds s

full_name: GaloisConnection.bddAbove_l_image
code: theorem bddAbove_l_image {s : Set α} : BddAbove (l '' s) ↔ BddAbove s 
goal: BddAbove (l '' s) ↔ BddAbove s

full_name: GaloisConnection.bddBelow_u_image
code: theorem bddBelow_u_image {s : Set β} : BddBelow (u '' s) ↔ BddBelow s 
goal: BddBelow (u '' s) ↔ BddBelow s

full_name: GaloisConnection.isLUB_l_image
code: theorem isLUB_l_image {s : Set α} {a : α} (h : IsLUB s a) : IsLUB (l '' s) (l a) 
goal: IsLUB (l '' s) (l a)

full_name: GaloisConnection.isGLB_u_image
code: theorem isGLB_u_image {s : Set β} {b : β} (h : IsGLB s b) : IsGLB (u '' s) (u b) 
goal: IsGLB (u '' s) (u b)

full_name: GaloisConnection.isLeast_l
code: theorem isLeast_l {a : α} : IsLeast { b | a ≤ u b } (l a) 
goal: IsLeast {b | a ≤ u b} (l a)

full_name: GaloisConnection.isGreatest_u
code: theorem isGreatest_u {b : β} : IsGreatest { a | l a ≤ b } (u b) 
goal: IsGreatest {a | l a ≤ b} (u b)

full_name: GaloisConnection.isGLB_l
code: theorem isGLB_l {a : α} : IsGLB { b | a ≤ u b } (l a) 
goal: IsGLB {b | a ≤ u b} (l a)

full_name: GaloisConnection.isLUB_u
code: theorem isLUB_u {b : β} : IsLUB { a | l a ≤ b } (u b) 
goal: IsLUB {a | l a ≤ b} (u b)

full_name: GaloisConnection.le_u_l_trans
code: /-- If `(l, u)` is a Galois connection, then the relation `x ≤ u (l y)` is a transitive relation.
If `l` is a closure operator (`Submodule.span`, `Subgroup.closure`, ...) and `u` is the coercion to
`Set`, this reads as "if `U` is in the closure of `V` and `V` is in the closure of `W` then `U` is
in the closure of `W`". -/
theorem le_u_l_trans {x y z : α} (hxy : x ≤ u (l y)) (hyz : y ≤ u (l z)) : x ≤ u (l z) 
goal: x ≤ u (l z)

full_name: GaloisConnection.l_u_le_trans
code: theorem l_u_le_trans {x y z : β} (hxy : l (u x) ≤ y) (hyz : l (u y) ≤ z) : l (u x) ≤ z 
goal: l (u x) ≤ z

full_name: GaloisConnection.u_l_u_eq_u
code: theorem u_l_u_eq_u (b : β) : u (l (u b)) = u b 
goal: u (l (u b)) = u b

full_name: GaloisConnection.u_l_u_eq_u'
code: theorem u_l_u_eq_u' : u ∘ l ∘ u = u 
goal: u ∘ l ∘ u = u

full_name: GaloisConnection.u_unique
code: theorem u_unique {l' : α → β} {u' : β → α} (gc' : GaloisConnection l' u') (hl : ∀ a, l a = l' a)
    {b : β} : u b = u' b 
goal: u b = u' b

full_name: GaloisConnection.exists_eq_u
code: /-- If there exists a `b` such that `a = u a`, then `b = l a` is one such element. -/
theorem exists_eq_u (a : α) : (∃ b : β, a = u b) ↔ a = u (l a) 
goal: (∃ b, a = u b) ↔ a = u (l a)

full_name: GaloisConnection.u_eq
code: theorem u_eq (gc : GaloisConnection l u) {z : α} {y : β} : u y = z ↔ ∀ x, x ≤ z ↔ l x ≤ y 
goal: u y = z ↔ ∀ (x : α), x ≤ z ↔ l x ≤ y

full_name: GaloisConnection.l_u_l_eq_l
code: theorem l_u_l_eq_l (a : α) : l (u (l a)) = l a 
goal: l (u (l a)) = l a

full_name: GaloisConnection.l_u_l_eq_l'
code: theorem l_u_l_eq_l' : l ∘ u ∘ l = l 
goal: l ∘ u ∘ l = l

full_name: GaloisConnection.l_unique
code: theorem l_unique {l' : α → β} {u' : β → α} (gc' : GaloisConnection l' u') (hu : ∀ b, u b = u' b)
    {a : α} : l a = l' a 
goal: l a = l' a

full_name: GaloisConnection.exists_eq_l
code: /-- If there exists an `a` such that `b = l a`, then `a = u b` is one such element. -/
theorem exists_eq_l (b : β) : (∃ a : α, b = l a) ↔ b = l (u b) 
goal: (∃ a, b = l a) ↔ b = l (u b)

full_name: GaloisConnection.l_eq
code: theorem l_eq {x : α} {z : β} : l x = z ↔ ∀ y, z ≤ y ↔ x ≤ u y 
goal: l x = z ↔ ∀ (y : β), z ≤ y ↔ x ≤ u y

full_name: GaloisConnection.u_eq_top
code: theorem u_eq_top {l : α → β} {u : β → α} (gc : GaloisConnection l u) {x} : u x = ⊤ ↔ l ⊤ ≤ x 
goal: u x = ⊤ ↔ l ⊤ ≤ x

full_name: GaloisConnection.u_top
code: theorem u_top [OrderTop β] {l : α → β} {u : β → α} (gc : GaloisConnection l u) : u ⊤ = ⊤ 
goal: u ⊤ = ⊤

full_name: GaloisConnection.l_eq_bot
code: theorem l_eq_bot {l : α → β} {u : β → α} (gc : GaloisConnection l u) {x} : l x = ⊥ ↔ x ≤ u ⊥ 
goal: l x = ⊥ ↔ x ≤ u ⊥

full_name: GaloisConnection.l_bot
code: theorem l_bot [OrderBot α] {l : α → β} {u : β → α} (gc : GaloisConnection l u) : l ⊥ = ⊥ 
goal: l ⊥ = ⊥

full_name: GaloisConnection.l_sup
code: theorem l_sup : l (a₁ ⊔ a₂) = l a₁ ⊔ l a₂ 
goal: l (a₁ ⊔ a₂) = l a₁ ⊔ l a₂

full_name: GaloisConnection.u_inf
code: theorem u_inf : u (b₁ ⊓ b₂) = u b₁ ⊓ u b₂ 
goal: u (b₁ ⊓ b₂) = u b₁ ⊓ u b₂

full_name: GaloisConnection.l_iSup
code: theorem l_iSup (gc : GaloisConnection l u) {f : ι → α} : l (iSup f) = ⨆ i, l (f i) 
goal: l (iSup f) = ⨆ i, l (f i)

full_name: GaloisConnection.l_iSup₂
code: theorem l_iSup₂ (gc : GaloisConnection l u) {f : ∀ i, κ i → α} :
    l (⨆ (i) (j), f i j) = ⨆ (i) (j), l (f i j) 
goal: l (⨆ i, ⨆ j, f i j) = ⨆ i, ⨆ j, l (f i j)

full_name: GaloisConnection.u_iInf
code: theorem u_iInf {f : ι → β} : u (iInf f) = ⨅ i, u (f i) 
goal: u (iInf f) = ⨅ i, u (f i)

full_name: GaloisConnection.u_iInf₂
code: theorem u_iInf₂ {f : ∀ i, κ i → β} : u (⨅ (i) (j), f i j) = ⨅ (i) (j), u (f i j) 
goal: u (⨅ i, ⨅ j, f i j) = ⨅ i, ⨅ j, u (f i j)

full_name: GaloisConnection.l_sSup
code: theorem l_sSup (gc : GaloisConnection l u) {s : Set α} : l (sSup s) = ⨆ a ∈ s, l a 
goal: l (sSup s) = ⨆ a ∈ s, l a

full_name: GaloisConnection.u_sInf
code: theorem u_sInf {s : Set β} : u (sInf s) = ⨅ a ∈ s, u a 
goal: u (sInf s) = ⨅ a ∈ s, u a

full_name: GaloisConnection.lt_iff_lt
code: theorem lt_iff_lt {a : α} {b : β} : b < l a ↔ u b < a 
goal: b < l a ↔ u b < a

full_name: GaloisConnection.id
code: protected theorem id [pα : Preorder α] : @GaloisConnection α α pα pα id id 
goal: GaloisConnection id id

full_name: GaloisConnection.compose
code: protected theorem compose [Preorder α] [Preorder β] [Preorder γ] {l1 : α → β} {u1 : β → α}
    {l2 : β → γ} {u2 : γ → β} (gc1 : GaloisConnection l1 u1) (gc2 : GaloisConnection l2 u2) :
    GaloisConnection (l2 ∘ l1) (u1 ∘ u2) 
goal: GaloisConnection (l2 ∘ l1) (u1 ∘ u2)

full_name: GaloisConnection.dfun
code: protected theorem dfun {ι : Type u} {α : ι → Type v} {β : ι → Type w} [∀ i, Preorder (α i)]
    [∀ i, Preorder (β i)] (l : ∀ i, α i → β i) (u : ∀ i, β i → α i)
    (gc : ∀ i, GaloisConnection (l i) (u i)) :
    GaloisConnection (fun (a : ∀ i, α i) i => l i (a i)) fun b i => u i (b i) 
goal: GaloisConnection (fun a i => l i (a i)) fun b i => u i (b i)

full_name: GaloisConnection.compl
code: protected theorem compl [BooleanAlgebra α] [BooleanAlgebra β] {l : α → β} {u : β → α}
    (gc : GaloisConnection l u) :
    GaloisConnection (compl ∘ u ∘ compl) (compl ∘ l ∘ compl) 
goal: GaloisConnection (compl ∘ u ∘ compl) (compl ∘ l ∘ compl)

full_name: GaloisConnection.l_comm_of_u_comm
code: theorem l_comm_of_u_comm {X : Type*} [Preorder X] {Y : Type*} [Preorder Y] {Z : Type*}
    [Preorder Z] {W : Type*} [PartialOrder W] {lYX : X → Y} {uXY : Y → X}
    (hXY : GaloisConnection lYX uXY) {lWZ : Z → W} {uZW : W → Z} (hZW : GaloisConnection lWZ uZW)
    {lWY : Y → W} {uYW : W → Y} (hWY : GaloisConnection lWY uYW) {lZX : X → Z} {uXZ : Z → X}
    (hXZ : GaloisConnection lZX uXZ) (h : ∀ w, uXZ (uZW w) = uXY (uYW w)) {x : X} :
    lWZ (lZX x) = lWY (lYX x) 
goal: lWZ (lZX x) = lWY (lYX x)

full_name: GaloisConnection.u_comm_of_l_comm
code: theorem u_comm_of_l_comm {X : Type*} [PartialOrder X] {Y : Type*} [Preorder Y] {Z : Type*}
    [Preorder Z] {W : Type*} [Preorder W] {lYX : X → Y} {uXY : Y → X}
    (hXY : GaloisConnection lYX uXY) {lWZ : Z → W} {uZW : W → Z} (hZW : GaloisConnection lWZ uZW)
    {lWY : Y → W} {uYW : W → Y} (hWY : GaloisConnection lWY uYW) {lZX : X → Z} {uXZ : Z → X}
    (hXZ : GaloisConnection lZX uXZ) (h : ∀ x, lWZ (lZX x) = lWY (lYX x)) {w : W} :
    uXZ (uZW w) = uXY (uYW w) 
goal: uXZ (uZW w) = uXY (uYW w)

full_name: GaloisConnection.l_comm_iff_u_comm
code: theorem l_comm_iff_u_comm {X : Type*} [PartialOrder X] {Y : Type*} [Preorder Y] {Z : Type*}
    [Preorder Z] {W : Type*} [PartialOrder W] {lYX : X → Y} {uXY : Y → X}
    (hXY : GaloisConnection lYX uXY) {lWZ : Z → W} {uZW : W → Z} (hZW : GaloisConnection lWZ uZW)
    {lWY : Y → W} {uYW : W → Y} (hWY : GaloisConnection lWY uYW) {lZX : X → Z} {uXZ : Z → X}
    (hXZ : GaloisConnection lZX uXZ) :
    (∀ w : W, uXZ (uZW w) = uXY (uYW w)) ↔ ∀ x : X, lWZ (lZX x) = lWY (lYX x) 
goal: (∀ (w : W), uXZ (uZW w) = uXY (uYW w)) ↔ ∀ (x : X), lWZ (lZX x) = lWY (lYX x)

full_name: gc_sSup_Iic
code: /-- `sSup` and `Iic` form a Galois connection. -/
theorem gc_sSup_Iic [CompleteSemilatticeSup α] :
    GaloisConnection (sSup : Set α → α) (Iic : α → Set α) 
goal: GaloisConnection sSup Set.Iic

full_name: gc_Ici_sInf
code: /-- `toDual ∘ Ici` and `sInf ∘ ofDual` form a Galois connection. -/
theorem gc_Ici_sInf [CompleteSemilatticeInf α] :
    GaloisConnection (toDual ∘ Ici : α → (Set α)ᵒᵈ) (sInf ∘ ofDual : (Set α)ᵒᵈ → α) 
goal: GaloisConnection (⇑OrderDual.toDual ∘ Set.Ici) (sInf ∘ ⇑OrderDual.ofDual)

full_name: sSup_image2_eq_sSup_sSup
code: theorem sSup_image2_eq_sSup_sSup (h₁ : ∀ b, GaloisConnection (swap l b) (u₁ b))
    (h₂ : ∀ a, GaloisConnection (l a) (u₂ a)) : sSup (image2 l s t) = l (sSup s) (sSup t) 
goal: sSup (Set.image2 l s t) = l (sSup s) (sSup t)

full_name: sSup_image2_eq_sSup_sInf
code: theorem sSup_image2_eq_sSup_sInf (h₁ : ∀ b, GaloisConnection (swap l b) (u₁ b))
    (h₂ : ∀ a, GaloisConnection (l a ∘ ofDual) (toDual ∘ u₂ a)) :
    sSup (image2 l s t) = l (sSup s) (sInf t) 
goal: sSup (Set.image2 l s t) = l (sSup s) (sInf t)

full_name: sSup_image2_eq_sInf_sSup
code: theorem sSup_image2_eq_sInf_sSup (h₁ : ∀ b, GaloisConnection (swap l b ∘ ofDual) (toDual ∘ u₁ b))
    (h₂ : ∀ a, GaloisConnection (l a) (u₂ a)) : sSup (image2 l s t) = l (sInf s) (sSup t) 
goal: sSup (Set.image2 l s t) = l (sInf s) (sSup t)

full_name: sSup_image2_eq_sInf_sInf
code: theorem sSup_image2_eq_sInf_sInf (h₁ : ∀ b, GaloisConnection (swap l b ∘ ofDual) (toDual ∘ u₁ b))
    (h₂ : ∀ a, GaloisConnection (l a ∘ ofDual) (toDual ∘ u₂ a)) :
    sSup (image2 l s t) = l (sInf s) (sInf t) 
goal: sSup (Set.image2 l s t) = l (sInf s) (sInf t)

full_name: sInf_image2_eq_sInf_sInf
code: theorem sInf_image2_eq_sInf_sInf (h₁ : ∀ b, GaloisConnection (l₁ b) (swap u b))
    (h₂ : ∀ a, GaloisConnection (l₂ a) (u a)) : sInf (image2 u s t) = u (sInf s) (sInf t) 
goal: sInf (Set.image2 u s t) = u (sInf s) (sInf t)

full_name: sInf_image2_eq_sInf_sSup
code: theorem sInf_image2_eq_sInf_sSup (h₁ : ∀ b, GaloisConnection (l₁ b) (swap u b))
    (h₂ : ∀ a, GaloisConnection (toDual ∘ l₂ a) (u a ∘ ofDual)) :
    sInf (image2 u s t) = u (sInf s) (sSup t) 
goal: sInf (Set.image2 u s t) = u (sInf s) (sSup t)

full_name: sInf_image2_eq_sSup_sInf
code: theorem sInf_image2_eq_sSup_sInf (h₁ : ∀ b, GaloisConnection (toDual ∘ l₁ b) (swap u b ∘ ofDual))
    (h₂ : ∀ a, GaloisConnection (l₂ a) (u a)) : sInf (image2 u s t) = u (sSup s) (sInf t) 
goal: sInf (Set.image2 u s t) = u (sSup s) (sInf t)

full_name: sInf_image2_eq_sSup_sSup
code: theorem sInf_image2_eq_sSup_sSup (h₁ : ∀ b, GaloisConnection (toDual ∘ l₁ b) (swap u b ∘ ofDual))
    (h₂ : ∀ a, GaloisConnection (toDual ∘ l₂ a) (u a ∘ ofDual)) :
    sInf (image2 u s t) = u (sSup s) (sSup t) 
goal: sInf (Set.image2 u s t) = u (sSup s) (sSup t)

full_name: OrderIso.bddAbove_image
code: @[simp]
theorem bddAbove_image (e : α ≃o β) {s : Set α} : BddAbove (e '' s) ↔ BddAbove s 
goal: BddAbove (⇑e '' s) ↔ BddAbove s

full_name: OrderIso.bddBelow_image
code: @[simp]
theorem bddBelow_image (e : α ≃o β) {s : Set α} : BddBelow (e '' s) ↔ BddBelow s 
goal: BddBelow (⇑e '' s) ↔ BddBelow s

full_name: OrderIso.bddAbove_preimage
code: @[simp]
theorem bddAbove_preimage (e : α ≃o β) {s : Set β} : BddAbove (e ⁻¹' s) ↔ BddAbove s 
goal: BddAbove (⇑e ⁻¹' s) ↔ BddAbove s

full_name: OrderIso.bddBelow_preimage
code: @[simp]
theorem bddBelow_preimage (e : α ≃o β) {s : Set β} : BddBelow (e ⁻¹' s) ↔ BddBelow s 
goal: BddBelow (⇑e ⁻¹' s) ↔ BddBelow s

full_name: Nat.galoisConnection_mul_div
code: theorem galoisConnection_mul_div {k : ℕ} (h : 0 < k) :
    GaloisConnection (fun n => n * k) fun n => n / k 
goal: GaloisConnection (fun n => n * k) fun n => n / k

full_name: GaloisInsertion
code: /-- A Galois insertion is a Galois connection where `l ∘ u = id`. It also contains a constructive
choice function, to give better definitional equalities when lifting order structures. Dual
to `GaloisCoinsertion` -/
structure GaloisInsertion {α β : Type*} [Preorder α] [Preorder β] (l : α → β) (u : β → α) where
  /-- A contructive choice function for images of `l`. -/
  choice : ∀ x : α, u (l x) ≤ x → β
  /-- The Galois connection associated to a Galois insertion. -/
  gc : GaloisConnection l u
  /-- Main property of a Galois insertion. -/
  le_l_u : ∀ x, x ≤ l (u x)
  /-- Property of the choice function. -/
  choice_eq : ∀ a h, choice a h = l a
goal: Type (max u_2 u_3)

full_name: GaloisInsertion.choice_eq
code: /-- A Galois insertion is a Galois connection where `l ∘ u = id`. It also contains a constructive
choice function, to give better definitional equalities when lifting order structures. Dual
to `GaloisCoinsertion` -/
structure GaloisInsertion {α β : Type*} [Preorder α] [Preorder β] (l : α → β) (u : β → α) where
  /-- A contructive choice function for images of `l`. -/
  choice : ∀ x : α, u (l x) ≤ x → β
  /-- The Galois connection associated to a Galois insertion. -/
  gc : GaloisConnection l u
  /-- Main property of a Galois insertion. -/
  le_l_u : ∀ x, x ≤ l (u x)
  /-- Property of the choice function. -/
  choice_eq : ∀ a h, choice a h = l a
goal: self.choice a h = l a

full_name: GaloisInsertion.gc
code: /-- A Galois insertion is a Galois connection where `l ∘ u = id`. It also contains a constructive
choice function, to give better definitional equalities when lifting order structures. Dual
to `GaloisCoinsertion` -/
structure GaloisInsertion {α β : Type*} [Preorder α] [Preorder β] (l : α → β) (u : β → α) where
  /-- A contructive choice function for images of `l`. -/
  choice : ∀ x : α, u (l x) ≤ x → β
  /-- The Galois connection associated to a Galois insertion. -/
  gc : GaloisConnection l u
  /-- Main property of a Galois insertion. -/
  le_l_u : ∀ x, x ≤ l (u x)
  /-- Property of the choice function. -/
  choice_eq : ∀ a h, choice a h = l a
goal: GaloisConnection l u

full_name: GaloisInsertion.choice
code: /-- A Galois insertion is a Galois connection where `l ∘ u = id`. It also contains a constructive
choice function, to give better definitional equalities when lifting order structures. Dual
to `GaloisCoinsertion` -/
structure GaloisInsertion {α β : Type*} [Preorder α] [Preorder β] (l : α → β) (u : β → α) where
  /-- A contructive choice function for images of `l`. -/
  choice : ∀ x : α, u (l x) ≤ x → β
  /-- The Galois connection associated to a Galois insertion. -/
  gc : GaloisConnection l u
  /-- Main property of a Galois insertion. -/
  le_l_u : ∀ x, x ≤ l (u x)
  /-- Property of the choice function. -/
  choice_eq : ∀ a h, choice a h = l a
goal: u (l x) ≤ x → β

full_name: GaloisInsertion.le_l_u
code: /-- A Galois insertion is a Galois connection where `l ∘ u = id`. It also contains a constructive
choice function, to give better definitional equalities when lifting order structures. Dual
to `GaloisCoinsertion` -/
structure GaloisInsertion {α β : Type*} [Preorder α] [Preorder β] (l : α → β) (u : β → α) where
  /-- A contructive choice function for images of `l`. -/
  choice : ∀ x : α, u (l x) ≤ x → β
  /-- The Galois connection associated to a Galois insertion. -/
  gc : GaloisConnection l u
  /-- Main property of a Galois insertion. -/
  le_l_u : ∀ x, x ≤ l (u x)
  /-- Property of the choice function. -/
  choice_eq : ∀ a h, choice a h = l a
goal: x ≤ l (u x)

full_name: GaloisInsertion.monotoneIntro
code: /-- A constructor for a Galois insertion with the trivial `choice` function. -/
def GaloisInsertion.monotoneIntro {α β : Type*} [Preorder α] [Preorder β] {l : α → β} {u : β → α}
    (hu : Monotone u) (hl : Monotone l) (hul : ∀ a, a ≤ u (l a)) (hlu : ∀ b, l (u b) = b) :
    GaloisInsertion l u 
goal: GaloisInsertion l u

full_name: OrderIso.toGaloisInsertion
code: /-- Makes a Galois insertion from an order-preserving bijection. -/
protected def OrderIso.toGaloisInsertion [Preorder α] [Preorder β] (oi : α ≃o β) :
    GaloisInsertion oi oi.symm 
goal: GaloisInsertion ⇑oi ⇑oi.symm

full_name: GaloisConnection.toGaloisInsertion
code: /-- Make a `GaloisInsertion l u` from a `GaloisConnection l u` such that `∀ b, b ≤ l (u b)` -/
def GaloisConnection.toGaloisInsertion {α β : Type*} [Preorder α] [Preorder β] {l : α → β}
    {u : β → α} (gc : GaloisConnection l u) (h : ∀ b, b ≤ l (u b)) : GaloisInsertion l u 
goal: GaloisInsertion l u

full_name: GaloisConnection.liftOrderBot
code: /-- Lift the bottom along a Galois connection -/
def GaloisConnection.liftOrderBot {α β : Type*} [Preorder α] [OrderBot α] [PartialOrder β]
    {l : α → β} {u : β → α} (gc : GaloisConnection l u) :
    OrderBot β 
goal: OrderBot β

full_name: GaloisInsertion.l_u_eq
code: theorem l_u_eq [Preorder α] [PartialOrder β] (gi : GaloisInsertion l u) (b : β) : l (u b) = b 
goal: l (u b) = b

full_name: GaloisInsertion.leftInverse_l_u
code: theorem leftInverse_l_u [Preorder α] [PartialOrder β] (gi : GaloisInsertion l u) :
    LeftInverse l u 
goal: Function.LeftInverse l u

full_name: GaloisInsertion.l_top
code: theorem l_top [Preorder α] [PartialOrder β] [OrderTop α] [OrderTop β]
    (gi : GaloisInsertion l u) : l ⊤ = ⊤ 
goal: l ⊤ = ⊤

full_name: GaloisInsertion.l_surjective
code: theorem l_surjective [Preorder α] [PartialOrder β] (gi : GaloisInsertion l u) : Surjective l 
goal: Function.Surjective l

full_name: GaloisInsertion.u_injective
code: theorem u_injective [Preorder α] [PartialOrder β] (gi : GaloisInsertion l u) : Injective u 
goal: Function.Injective u

full_name: GaloisInsertion.l_sup_u
code: theorem l_sup_u [SemilatticeSup α] [SemilatticeSup β] (gi : GaloisInsertion l u) (a b : β) :
    l (u a ⊔ u b) = a ⊔ b 
goal: l (u a ⊔ u b) = a ⊔ b

full_name: GaloisInsertion.l_iSup_u
code: theorem l_iSup_u [CompleteLattice α] [CompleteLattice β] (gi : GaloisInsertion l u) {ι : Sort x}
    (f : ι → β) : l (⨆ i, u (f i)) = ⨆ i, f i 
goal: l (⨆ i, u (f i)) = ⨆ i, f i

full_name: GaloisInsertion.l_biSup_u
code: theorem l_biSup_u [CompleteLattice α] [CompleteLattice β] (gi : GaloisInsertion l u) {ι : Sort x}
    {p : ι → Prop} (f : ∀ i, p i → β) : l (⨆ (i) (hi), u (f i hi)) = ⨆ (i) (hi), f i hi 
goal: l (⨆ i, ⨆ (hi : p i), u (f i hi)) = ⨆ i, ⨆ (hi : p i), f i hi

full_name: GaloisInsertion.l_sSup_u_image
code: theorem l_sSup_u_image [CompleteLattice α] [CompleteLattice β] (gi : GaloisInsertion l u)
    (s : Set β) : l (sSup (u '' s)) = sSup s 
goal: l (sSup (u '' s)) = sSup s

full_name: GaloisInsertion.l_inf_u
code: theorem l_inf_u [SemilatticeInf α] [SemilatticeInf β] (gi : GaloisInsertion l u) (a b : β) :
    l (u a ⊓ u b) = a ⊓ b 
goal: l (u a ⊓ u b) = a ⊓ b

full_name: GaloisInsertion.l_iInf_u
code: theorem l_iInf_u [CompleteLattice α] [CompleteLattice β] (gi : GaloisInsertion l u) {ι : Sort x}
    (f : ι → β) : l (⨅ i, u (f i)) = ⨅ i, f i 
goal: l (⨅ i, u (f i)) = ⨅ i, f i

full_name: GaloisInsertion.l_biInf_u
code: theorem l_biInf_u [CompleteLattice α] [CompleteLattice β] (gi : GaloisInsertion l u) {ι : Sort x}
    {p : ι → Prop} (f : ∀ (i) (_ : p i), β) : l (⨅ (i) (hi), u (f i hi)) = ⨅ (i) (hi), f i hi 
goal: l (⨅ i, ⨅ (hi : p i), u (f i hi)) = ⨅ i, ⨅ (hi : p i), f i hi

full_name: GaloisInsertion.l_sInf_u_image
code: theorem l_sInf_u_image [CompleteLattice α] [CompleteLattice β] (gi : GaloisInsertion l u)
    (s : Set β) : l (sInf (u '' s)) = sInf s 
goal: l (sInf (u '' s)) = sInf s

full_name: GaloisInsertion.l_iInf_of_ul_eq_self
code: theorem l_iInf_of_ul_eq_self [CompleteLattice α] [CompleteLattice β] (gi : GaloisInsertion l u)
    {ι : Sort x} (f : ι → α) (hf : ∀ i, u (l (f i)) = f i) : l (⨅ i, f i) = ⨅ i, l (f i) 
goal: l (⨅ i, f i) = ⨅ i, l (f i)

full_name: GaloisInsertion.l_biInf_of_ul_eq_self
code: theorem l_biInf_of_ul_eq_self [CompleteLattice α] [CompleteLattice β] (gi : GaloisInsertion l u)
    {ι : Sort x} {p : ι → Prop} (f : ∀ (i) (_ : p i), α) (hf : ∀ i hi, u (l (f i hi)) = f i hi) :
    l (⨅ (i) (hi), f i hi) = ⨅ (i) (hi), l (f i hi) 
goal: l (⨅ i, ⨅ (hi : p i), f i hi) = ⨅ i, ⨅ (hi : p i), l (f i hi)

full_name: GaloisInsertion.u_le_u_iff
code: theorem u_le_u_iff [Preorder α] [Preorder β] (gi : GaloisInsertion l u) {a b} : u a ≤ u b ↔ a ≤ b 
goal: u a ≤ u b ↔ a ≤ b

full_name: GaloisInsertion.strictMono_u
code: theorem strictMono_u [Preorder α] [Preorder β] (gi : GaloisInsertion l u) : StrictMono u 
goal: StrictMono u

full_name: GaloisInsertion.isLUB_of_u_image
code: theorem isLUB_of_u_image [Preorder α] [Preorder β] (gi : GaloisInsertion l u) {s : Set β} {a : α}
    (hs : IsLUB (u '' s) a) : IsLUB s (l a) 
goal: IsLUB s (l a)

full_name: GaloisInsertion.isGLB_of_u_image
code: theorem isGLB_of_u_image [Preorder α] [Preorder β] (gi : GaloisInsertion l u) {s : Set β} {a : α}
    (hs : IsGLB (u '' s) a) : IsGLB s (l a) 
goal: IsGLB s (l a)

full_name: GaloisInsertion.liftSemilatticeSup
code: /-- Lift the suprema along a Galois insertion -/
abbrev liftSemilatticeSup [SemilatticeSup α] (gi : GaloisInsertion l u) : SemilatticeSup β 
goal: SemilatticeSup β

full_name: GaloisInsertion.liftSemilatticeInf
code: /-- Lift the infima along a Galois insertion -/
abbrev liftSemilatticeInf [SemilatticeInf α] (gi : GaloisInsertion l u) : SemilatticeInf β 
goal: SemilatticeInf β

full_name: GaloisInsertion.liftLattice
code: /-- Lift the suprema and infima along a Galois insertion -/
abbrev liftLattice [Lattice α] (gi : GaloisInsertion l u) : Lattice β 
goal: Lattice β

full_name: GaloisInsertion.liftOrderTop
code: /-- Lift the top along a Galois insertion -/
abbrev liftOrderTop [Preorder α] [OrderTop α] (gi : GaloisInsertion l u) :
    OrderTop β 
goal: OrderTop β

full_name: GaloisInsertion.liftBoundedOrder
code: /-- Lift the top, bottom, suprema, and infima along a Galois insertion -/
abbrev liftBoundedOrder [Preorder α] [BoundedOrder α] (gi : GaloisInsertion l u) : BoundedOrder β 
goal: BoundedOrder β

full_name: GaloisInsertion.liftCompleteLattice
code: /-- Lift all suprema and infima along a Galois insertion -/
abbrev liftCompleteLattice [CompleteLattice α] (gi : GaloisInsertion l u) : CompleteLattice β 
goal: CompleteLattice β

full_name: GaloisCoinsertion.choice_eq
code: /-- A Galois coinsertion is a Galois connection where `u ∘ l = id`. It also contains a constructive
choice function, to give better definitional equalities when lifting order structures. Dual to
`GaloisInsertion` -/
structure GaloisCoinsertion [Preorder α] [Preorder β] (l : α → β) (u : β → α) where
  /-- A contructive choice function for images of `u`. -/
  choice : ∀ x : β, x ≤ l (u x) → α
  /-- The Galois connection associated to a Galois coinsertion. -/
  gc : GaloisConnection l u
  /-- Main property of a Galois coinsertion. -/
  u_l_le : ∀ x, u (l x) ≤ x
  /-- Property of the choice function. -/
  choice_eq : ∀ a h, choice a h = u a
goal: self.choice a h = u a

full_name: GaloisCoinsertion
code: /-- A Galois coinsertion is a Galois connection where `u ∘ l = id`. It also contains a constructive
choice function, to give better definitional equalities when lifting order structures. Dual to
`GaloisInsertion` -/
structure GaloisCoinsertion [Preorder α] [Preorder β] (l : α → β) (u : β → α) where
  /-- A contructive choice function for images of `u`. -/
  choice : ∀ x : β, x ≤ l (u x) → α
  /-- The Galois connection associated to a Galois coinsertion. -/
  gc : GaloisConnection l u
  /-- Main property of a Galois coinsertion. -/
  u_l_le : ∀ x, u (l x) ≤ x
  /-- Property of the choice function. -/
  choice_eq : ∀ a h, choice a h = u a
goal: Type (max u v)

full_name: GaloisCoinsertion.choice
code: /-- A Galois coinsertion is a Galois connection where `u ∘ l = id`. It also contains a constructive
choice function, to give better definitional equalities when lifting order structures. Dual to
`GaloisInsertion` -/
structure GaloisCoinsertion [Preorder α] [Preorder β] (l : α → β) (u : β → α) where
  /-- A contructive choice function for images of `u`. -/
  choice : ∀ x : β, x ≤ l (u x) → α
  /-- The Galois connection associated to a Galois coinsertion. -/
  gc : GaloisConnection l u
  /-- Main property of a Galois coinsertion. -/
  u_l_le : ∀ x, u (l x) ≤ x
  /-- Property of the choice function. -/
  choice_eq : ∀ a h, choice a h = u a
goal: x ≤ l (u x) → α

full_name: GaloisCoinsertion.gc
code: /-- A Galois coinsertion is a Galois connection where `u ∘ l = id`. It also contains a constructive
choice function, to give better definitional equalities when lifting order structures. Dual to
`GaloisInsertion` -/
structure GaloisCoinsertion [Preorder α] [Preorder β] (l : α → β) (u : β → α) where
  /-- A contructive choice function for images of `u`. -/
  choice : ∀ x : β, x ≤ l (u x) → α
  /-- The Galois connection associated to a Galois coinsertion. -/
  gc : GaloisConnection l u
  /-- Main property of a Galois coinsertion. -/
  u_l_le : ∀ x, u (l x) ≤ x
  /-- Property of the choice function. -/
  choice_eq : ∀ a h, choice a h = u a
goal: GaloisConnection l u

full_name: GaloisCoinsertion.u_l_le
code: /-- A Galois coinsertion is a Galois connection where `u ∘ l = id`. It also contains a constructive
choice function, to give better definitional equalities when lifting order structures. Dual to
`GaloisInsertion` -/
structure GaloisCoinsertion [Preorder α] [Preorder β] (l : α → β) (u : β → α) where
  /-- A contructive choice function for images of `u`. -/
  choice : ∀ x : β, x ≤ l (u x) → α
  /-- The Galois connection associated to a Galois coinsertion. -/
  gc : GaloisConnection l u
  /-- Main property of a Galois coinsertion. -/
  u_l_le : ∀ x, u (l x) ≤ x
  /-- Property of the choice function. -/
  choice_eq : ∀ a h, choice a h = u a
goal: u (l x) ≤ x

full_name: GaloisCoinsertion.dual
code: /-- Make a `GaloisInsertion` between `αᵒᵈ` and `βᵒᵈ` from a `GaloisCoinsertion` between `α` and
`β`. -/
def GaloisCoinsertion.dual [Preorder α] [Preorder β] {l : α → β} {u : β → α} :
    GaloisCoinsertion l u → GaloisInsertion (toDual ∘ u ∘ ofDual) (toDual ∘ l ∘ ofDual) 
goal: GaloisCoinsertion l u →
  GaloisInsertion (⇑OrderDual.toDual ∘ u ∘ ⇑OrderDual.ofDual) (⇑OrderDual.toDual ∘ l ∘ ⇑OrderDual.ofDual)

full_name: GaloisInsertion.dual
code: /-- Make a `GaloisCoinsertion` between `αᵒᵈ` and `βᵒᵈ` from a `GaloisInsertion` between `α` and
`β`. -/
def GaloisInsertion.dual [Preorder α] [Preorder β] {l : α → β} {u : β → α} :
    GaloisInsertion l u → GaloisCoinsertion (toDual ∘ u ∘ ofDual) (toDual ∘ l ∘ ofDual) 
goal: GaloisInsertion l u →
  GaloisCoinsertion (⇑OrderDual.toDual ∘ u ∘ ⇑OrderDual.ofDual) (⇑OrderDual.toDual ∘ l ∘ ⇑OrderDual.ofDual)

full_name: GaloisCoinsertion.ofDual
code: /-- Make a `GaloisInsertion` between `α` and `β` from a `GaloisCoinsertion` between `αᵒᵈ` and
`βᵒᵈ`. -/
def GaloisCoinsertion.ofDual [Preorder α] [Preorder β] {l : αᵒᵈ → βᵒᵈ} {u : βᵒᵈ → αᵒᵈ} :
    GaloisCoinsertion l u → GaloisInsertion (ofDual ∘ u ∘ toDual) (ofDual ∘ l ∘ toDual) 
goal: GaloisCoinsertion l u →
  GaloisInsertion (⇑OrderDual.ofDual ∘ u ∘ ⇑OrderDual.toDual) (⇑OrderDual.ofDual ∘ l ∘ ⇑OrderDual.toDual)

full_name: GaloisInsertion.ofDual
code: /-- Make a `GaloisCoinsertion` between `α` and `β` from a `GaloisInsertion` between `αᵒᵈ` and
`βᵒᵈ`. -/
def GaloisInsertion.ofDual [Preorder α] [Preorder β] {l : αᵒᵈ → βᵒᵈ} {u : βᵒᵈ → αᵒᵈ} :
    GaloisInsertion l u → GaloisCoinsertion (ofDual ∘ u ∘ toDual) (ofDual ∘ l ∘ toDual) 
goal: GaloisInsertion l u →
  GaloisCoinsertion (⇑OrderDual.ofDual ∘ u ∘ ⇑OrderDual.toDual) (⇑OrderDual.ofDual ∘ l ∘ ⇑OrderDual.toDual)

full_name: OrderIso.toGaloisCoinsertion
code: /-- Makes a Galois coinsertion from an order-preserving bijection. -/
protected def OrderIso.toGaloisCoinsertion [Preorder α] [Preorder β] (oi : α ≃o β) :
    GaloisCoinsertion oi oi.symm 
goal: GaloisCoinsertion ⇑oi ⇑oi.symm

full_name: GaloisCoinsertion.monotoneIntro
code: /-- A constructor for a Galois coinsertion with the trivial `choice` function. -/
def GaloisCoinsertion.monotoneIntro [Preorder α] [Preorder β] {l : α → β} {u : β → α}
    (hu : Monotone u) (hl : Monotone l) (hlu : ∀ b, l (u b) ≤ b) (hul : ∀ a, u (l a) = a) :
    GaloisCoinsertion l u 
goal: GaloisCoinsertion l u

full_name: GaloisConnection.toGaloisCoinsertion
code: /-- Make a `GaloisCoinsertion l u` from a `GaloisConnection l u` such that `∀ a, u (l a) ≤ a` -/
def GaloisConnection.toGaloisCoinsertion {α β : Type*} [Preorder α] [Preorder β] {l : α → β}
    {u : β → α} (gc : GaloisConnection l u) (h : ∀ a, u (l a) ≤ a) : GaloisCoinsertion l u 
goal: GaloisCoinsertion l u

full_name: GaloisConnection.liftOrderTop
code: /-- Lift the top along a Galois connection -/
def GaloisConnection.liftOrderTop {α β : Type*} [PartialOrder α] [Preorder β] [OrderTop β]
    {l : α → β} {u : β → α} (gc : GaloisConnection l u) :
    OrderTop α 
goal: OrderTop α

full_name: GaloisCoinsertion.u_l_eq
code: theorem u_l_eq [PartialOrder α] [Preorder β] (gi : GaloisCoinsertion l u) (a : α) : u (l a) = a 
goal: u (l a) = a

full_name: GaloisCoinsertion.u_l_leftInverse
code: theorem u_l_leftInverse [PartialOrder α] [Preorder β] (gi : GaloisCoinsertion l u) :
    LeftInverse u l 
goal: Function.LeftInverse u l

full_name: GaloisCoinsertion.u_bot
code: theorem u_bot [PartialOrder α] [Preorder β] [OrderBot α] [OrderBot β] (gi : GaloisCoinsertion l u) :
    u ⊥ = ⊥ 
goal: u ⊥ = ⊥

full_name: GaloisCoinsertion.u_surjective
code: theorem u_surjective [PartialOrder α] [Preorder β] (gi : GaloisCoinsertion l u) : Surjective u 
goal: Function.Surjective u

full_name: GaloisCoinsertion.l_injective
code: theorem l_injective [PartialOrder α] [Preorder β] (gi : GaloisCoinsertion l u) : Injective l 
goal: Function.Injective l

full_name: GaloisCoinsertion.u_inf_l
code: theorem u_inf_l [SemilatticeInf α] [SemilatticeInf β] (gi : GaloisCoinsertion l u) (a b : α) :
    u (l a ⊓ l b) = a ⊓ b 
goal: u (l a ⊓ l b) = a ⊓ b

full_name: GaloisCoinsertion.u_iInf_l
code: theorem u_iInf_l [CompleteLattice α] [CompleteLattice β] (gi : GaloisCoinsertion l u) {ι : Sort x}
    (f : ι → α) : u (⨅ i, l (f i)) = ⨅ i, f i 
goal: u (⨅ i, l (f i)) = ⨅ i, f i

full_name: GaloisCoinsertion.u_sInf_l_image
code: theorem u_sInf_l_image [CompleteLattice α] [CompleteLattice β] (gi : GaloisCoinsertion l u)
    (s : Set α) : u (sInf (l '' s)) = sInf s 
goal: u (sInf (l '' s)) = sInf s

full_name: GaloisCoinsertion.u_sup_l
code: theorem u_sup_l [SemilatticeSup α] [SemilatticeSup β] (gi : GaloisCoinsertion l u) (a b : α) :
    u (l a ⊔ l b) = a ⊔ b 
goal: u (l a ⊔ l b) = a ⊔ b

full_name: GaloisCoinsertion.u_iSup_l
code: theorem u_iSup_l [CompleteLattice α] [CompleteLattice β] (gi : GaloisCoinsertion l u) {ι : Sort x}
    (f : ι → α) : u (⨆ i, l (f i)) = ⨆ i, f i 
goal: u (⨆ i, l (f i)) = ⨆ i, f i

full_name: GaloisCoinsertion.u_biSup_l
code: theorem u_biSup_l [CompleteLattice α] [CompleteLattice β] (gi : GaloisCoinsertion l u) {ι : Sort x}
    {p : ι → Prop} (f : ∀ (i) (_ : p i), α) : u (⨆ (i) (hi), l (f i hi)) = ⨆ (i) (hi), f i hi 
goal: u (⨆ i, ⨆ (hi : p i), l (f i hi)) = ⨆ i, ⨆ (hi : p i), f i hi

full_name: GaloisCoinsertion.u_sSup_l_image
code: theorem u_sSup_l_image [CompleteLattice α] [CompleteLattice β] (gi : GaloisCoinsertion l u)
    (s : Set α) : u (sSup (l '' s)) = sSup s 
goal: u (sSup (l '' s)) = sSup s

full_name: GaloisCoinsertion.u_iSup_of_lu_eq_self
code: theorem u_iSup_of_lu_eq_self [CompleteLattice α] [CompleteLattice β] (gi : GaloisCoinsertion l u)
    {ι : Sort x} (f : ι → β) (hf : ∀ i, l (u (f i)) = f i) : u (⨆ i, f i) = ⨆ i, u (f i) 
goal: u (⨆ i, f i) = ⨆ i, u (f i)

full_name: GaloisCoinsertion.u_biSup_of_lu_eq_self
code: theorem u_biSup_of_lu_eq_self [CompleteLattice α] [CompleteLattice β] (gi : GaloisCoinsertion l u)
    {ι : Sort x} {p : ι → Prop} (f : ∀ (i) (_ : p i), β) (hf : ∀ i hi, l (u (f i hi)) = f i hi) :
    u (⨆ (i) (hi), f i hi) = ⨆ (i) (hi), u (f i hi) 
goal: u (⨆ i, ⨆ (hi : p i), f i hi) = ⨆ i, ⨆ (hi : p i), u (f i hi)

full_name: GaloisCoinsertion.l_le_l_iff
code: theorem l_le_l_iff [Preorder α] [Preorder β] (gi : GaloisCoinsertion l u) {a b} :
    l a ≤ l b ↔ a ≤ b 
goal: l a ≤ l b ↔ a ≤ b

full_name: GaloisCoinsertion.strictMono_l
code: theorem strictMono_l [Preorder α] [Preorder β] (gi : GaloisCoinsertion l u) : StrictMono l 
goal: StrictMono l

full_name: GaloisCoinsertion.isGLB_of_l_image
code: theorem isGLB_of_l_image [Preorder α] [Preorder β] (gi : GaloisCoinsertion l u) {s : Set α} {a : β}
    (hs : IsGLB (l '' s) a) : IsGLB s (u a) 
goal: IsGLB s (u a)

full_name: GaloisCoinsertion.isLUB_of_l_image
code: theorem isLUB_of_l_image [Preorder α] [Preorder β] (gi : GaloisCoinsertion l u) {s : Set α} {a : β}
    (hs : IsLUB (l '' s) a) : IsLUB s (u a) 
goal: IsLUB s (u a)

full_name: GaloisCoinsertion.liftSemilatticeInf
code: /-- Lift the infima along a Galois coinsertion -/
abbrev liftSemilatticeInf [SemilatticeInf β] (gi : GaloisCoinsertion l u) : SemilatticeInf α 
goal: SemilatticeInf α

full_name: GaloisCoinsertion.liftSemilatticeSup
code: /-- Lift the suprema along a Galois coinsertion -/
abbrev liftSemilatticeSup [SemilatticeSup β] (gi : GaloisCoinsertion l u) : SemilatticeSup α 
goal: SemilatticeSup α

full_name: GaloisCoinsertion.liftLattice
code: /-- Lift the suprema and infima along a Galois coinsertion -/
abbrev liftLattice [Lattice β] (gi : GaloisCoinsertion l u) : Lattice α 
goal: Lattice α

full_name: GaloisCoinsertion.liftOrderBot
code: /-- Lift the bot along a Galois coinsertion -/
abbrev liftOrderBot [Preorder β] [OrderBot β] (gi : GaloisCoinsertion l u) : OrderBot α 
goal: OrderBot α

full_name: GaloisCoinsertion.liftBoundedOrder
code: /-- Lift the top, bottom, suprema, and infima along a Galois coinsertion -/
abbrev liftBoundedOrder
    [Preorder β] [BoundedOrder β] (gi : GaloisCoinsertion l u) : BoundedOrder α 
goal: BoundedOrder α

full_name: GaloisCoinsertion.liftCompleteLattice
code: /-- Lift all suprema and infima along a Galois coinsertion -/
abbrev liftCompleteLattice [CompleteLattice β] (gi : GaloisCoinsertion l u) : CompleteLattice α 
goal: CompleteLattice α

full_name: gi_sSup_Iic
code: /-- `sSup` and `Iic` form a Galois insertion. -/
def gi_sSup_Iic [CompleteSemilatticeSup α] :
    GaloisInsertion (sSup : Set α → α) (Iic : α → Set α) 
goal: GaloisInsertion sSup Set.Iic

full_name: gci_Ici_sInf
code: /-- `toDual ∘ Ici` and `sInf ∘ ofDual` form a Galois coinsertion. -/
def gci_Ici_sInf [CompleteSemilatticeInf α] :
    GaloisCoinsertion (toDual ∘ Ici : α → (Set α)ᵒᵈ) (sInf ∘ ofDual : (Set α)ᵒᵈ → α) 
goal: GaloisCoinsertion (⇑OrderDual.toDual ∘ Set.Ici) (sInf ∘ ⇑OrderDual.ofDual)

full_name: WithBot.giUnbot'Bot
code: /-- If `α` is a partial order with bottom element (e.g., `ℕ`, `ℝ≥0`), then `WithBot.unbot' ⊥` and
coercion form a Galois insertion. -/
def WithBot.giUnbot'Bot [Preorder α] [OrderBot α] :
    GaloisInsertion (WithBot.unbot' ⊥) (some : α → WithBot α) 
goal: GaloisInsertion (WithBot.unbot' ⊥) WithBot.some