File: Mathlib/Order/Hom/Bounded.lean

full_name: TopHom.toFun
code: /-- The type of `⊤`-preserving functions from `α` to `β`. -/
structure TopHom (α β : Type*) [Top α] [Top β] where
  /-- The underlying function. The preferred spelling is `DFunLike.coe`. -/
  toFun : α → β
  /-- The function preserves the top element. The preferred spelling is `map_top`. -/
  map_top' : toFun ⊤ = ⊤
goal: α → β

full_name: TopHom
code: /-- The type of `⊤`-preserving functions from `α` to `β`. -/
structure TopHom (α β : Type*) [Top α] [Top β] where
  /-- The underlying function. The preferred spelling is `DFunLike.coe`. -/
  toFun : α → β
  /-- The function preserves the top element. The preferred spelling is `map_top`. -/
  map_top' : toFun ⊤ = ⊤
goal: Type (max u_6 u_7)

full_name: TopHom.map_top'
code: /-- The type of `⊤`-preserving functions from `α` to `β`. -/
structure TopHom (α β : Type*) [Top α] [Top β] where
  /-- The underlying function. The preferred spelling is `DFunLike.coe`. -/
  toFun : α → β
  /-- The function preserves the top element. The preferred spelling is `map_top`. -/
  map_top' : toFun ⊤ = ⊤
goal: self.toFun ⊤ = ⊤

full_name: BotHom.toFun
code: /-- The type of `⊥`-preserving functions from `α` to `β`. -/
structure BotHom (α β : Type*) [Bot α] [Bot β] where
  /-- The underlying function. The preferred spelling is `DFunLike.coe`. -/
  toFun : α → β
  /-- The function preserves the bottom element. The preferred spelling is `map_bot`. -/
  map_bot' : toFun ⊥ = ⊥
goal: α → β

full_name: BotHom.map_bot'
code: /-- The type of `⊥`-preserving functions from `α` to `β`. -/
structure BotHom (α β : Type*) [Bot α] [Bot β] where
  /-- The underlying function. The preferred spelling is `DFunLike.coe`. -/
  toFun : α → β
  /-- The function preserves the bottom element. The preferred spelling is `map_bot`. -/
  map_bot' : toFun ⊥ = ⊥
goal: self.toFun ⊥ = ⊥

full_name: BotHom
code: /-- The type of `⊥`-preserving functions from `α` to `β`. -/
structure BotHom (α β : Type*) [Bot α] [Bot β] where
  /-- The underlying function. The preferred spelling is `DFunLike.coe`. -/
  toFun : α → β
  /-- The function preserves the bottom element. The preferred spelling is `map_bot`. -/
  map_bot' : toFun ⊥ = ⊥
goal: Type (max u_6 u_7)

full_name: BoundedOrderHom
code: /-- The type of bounded order homomorphisms from `α` to `β`. -/
structure BoundedOrderHom (α β : Type*) [Preorder α] [Preorder β] [BoundedOrder α]
  [BoundedOrder β] extends OrderHom α β where
  /-- The function preserves the top element. The preferred spelling is `map_top`. -/
  map_top' : toFun ⊤ = ⊤
  /-- The function preserves the bottom element. The preferred spelling is `map_bot`. -/
  map_bot' : toFun ⊥ = ⊥
goal: Type (max u_6 u_7)

full_name: BoundedOrderHom.map_bot'
code: /-- The type of bounded order homomorphisms from `α` to `β`. -/
structure BoundedOrderHom (α β : Type*) [Preorder α] [Preorder β] [BoundedOrder α]
  [BoundedOrder β] extends OrderHom α β where
  /-- The function preserves the top element. The preferred spelling is `map_top`. -/
  map_top' : toFun ⊤ = ⊤
  /-- The function preserves the bottom element. The preferred spelling is `map_bot`. -/
  map_bot' : toFun ⊥ = ⊥
goal: self.toFun ⊥ = ⊥

full_name: BoundedOrderHom.map_top'
code: /-- The type of bounded order homomorphisms from `α` to `β`. -/
structure BoundedOrderHom (α β : Type*) [Preorder α] [Preorder β] [BoundedOrder α]
  [BoundedOrder β] extends OrderHom α β where
  /-- The function preserves the top element. The preferred spelling is `map_top`. -/
  map_top' : toFun ⊤ = ⊤
  /-- The function preserves the bottom element. The preferred spelling is `map_bot`. -/
  map_bot' : toFun ⊥ = ⊥
goal: self.toFun ⊤ = ⊤

full_name: TopHomClass
code: /-- `TopHomClass F α β` states that `F` is a type of `⊤`-preserving morphisms.

You should extend this class when you extend `TopHom`. -/
class TopHomClass (F α β : Type*) [Top α] [Top β] [FunLike F α β] : Prop where
  /-- A `TopHomClass` morphism preserves the top element. -/
  map_top (f : F) : f ⊤ = ⊤
goal: Prop

full_name: TopHomClass.map_top
code: /-- `TopHomClass F α β` states that `F` is a type of `⊤`-preserving morphisms.

You should extend this class when you extend `TopHom`. -/
class TopHomClass (F α β : Type*) [Top α] [Top β] [FunLike F α β] : Prop where
  /-- A `TopHomClass` morphism preserves the top element. -/
  map_top (f : F) : f ⊤ = ⊤
goal: f ⊤ = ⊤

full_name: BotHomClass.map_bot
code: /-- `BotHomClass F α β` states that `F` is a type of `⊥`-preserving morphisms.

You should extend this class when you extend `BotHom`. -/
class BotHomClass (F α β : Type*) [Bot α] [Bot β] [FunLike F α β] : Prop where
  /-- A `BotHomClass` morphism preserves the bottom element. -/
  map_bot (f : F) : f ⊥ = ⊥
goal: f ⊥ = ⊥

full_name: BotHomClass
code: /-- `BotHomClass F α β` states that `F` is a type of `⊥`-preserving morphisms.

You should extend this class when you extend `BotHom`. -/
class BotHomClass (F α β : Type*) [Bot α] [Bot β] [FunLike F α β] : Prop where
  /-- A `BotHomClass` morphism preserves the bottom element. -/
  map_bot (f : F) : f ⊥ = ⊥
goal: Prop

full_name: BoundedOrderHomClass.map_top
code: /-- `BoundedOrderHomClass F α β` states that `F` is a type of bounded order morphisms.

You should extend this class when you extend `BoundedOrderHom`. -/
class BoundedOrderHomClass (F α β : Type*) [LE α] [LE β]
  [BoundedOrder α] [BoundedOrder β] [FunLike F α β]
  extends RelHomClass F ((· ≤ ·) : α → α → Prop) ((· ≤ ·) : β → β → Prop) : Prop where
  /-- Morphisms preserve the top element. The preferred spelling is `_root_.map_top`. -/
  map_top (f : F) : f ⊤ = ⊤
  /-- Morphisms preserve the bottom element. The preferred spelling is `_root_.map_bot`. -/
  map_bot (f : F) : f ⊥ = ⊥
goal: f ⊤ = ⊤

full_name: BoundedOrderHomClass
code: /-- `BoundedOrderHomClass F α β` states that `F` is a type of bounded order morphisms.

You should extend this class when you extend `BoundedOrderHom`. -/
class BoundedOrderHomClass (F α β : Type*) [LE α] [LE β]
  [BoundedOrder α] [BoundedOrder β] [FunLike F α β]
  extends RelHomClass F ((· ≤ ·) : α → α → Prop) ((· ≤ ·) : β → β → Prop) : Prop where
  /-- Morphisms preserve the top element. The preferred spelling is `_root_.map_top`. -/
  map_top (f : F) : f ⊤ = ⊤
  /-- Morphisms preserve the bottom element. The preferred spelling is `_root_.map_bot`. -/
  map_bot (f : F) : f ⊥ = ⊥
goal: Prop

full_name: BoundedOrderHomClass.map_bot
code: /-- `BoundedOrderHomClass F α β` states that `F` is a type of bounded order morphisms.

You should extend this class when you extend `BoundedOrderHom`. -/
class BoundedOrderHomClass (F α β : Type*) [LE α] [LE β]
  [BoundedOrder α] [BoundedOrder β] [FunLike F α β]
  extends RelHomClass F ((· ≤ ·) : α → α → Prop) ((· ≤ ·) : β → β → Prop) : Prop where
  /-- Morphisms preserve the top element. The preferred spelling is `_root_.map_top`. -/
  map_top (f : F) : f ⊤ = ⊤
  /-- Morphisms preserve the bottom element. The preferred spelling is `_root_.map_bot`. -/
  map_bot (f : F) : f ⊥ = ⊥
goal: f ⊥ = ⊥

full_name: BoundedOrderHomClass.toTopHomClass
code: instance (priority := 100) BoundedOrderHomClass.toTopHomClass [LE α] [LE β]
    [BoundedOrder α] [BoundedOrder β] [BoundedOrderHomClass F α β] : TopHomClass F α β 
goal: TopHomClass F α β

full_name: BoundedOrderHomClass.toBotHomClass
code: instance (priority := 100) BoundedOrderHomClass.toBotHomClass [LE α] [LE β]
    [BoundedOrder α] [BoundedOrder β] [BoundedOrderHomClass F α β] : BotHomClass F α β 
goal: BotHomClass F α β

full_name: OrderIsoClass.toTopHomClass
code: instance (priority := 100) OrderIsoClass.toTopHomClass [LE α] [OrderTop α]
    [PartialOrder β] [OrderTop β] [OrderIsoClass F α β] : TopHomClass F α β 
goal: TopHomClass F α β

full_name: OrderIsoClass.toBotHomClass
code: instance (priority := 100) OrderIsoClass.toBotHomClass [LE α] [OrderBot α]
    [PartialOrder β] [OrderBot β] [OrderIsoClass F α β] : BotHomClass F α β 
goal: BotHomClass F α β

full_name: OrderIsoClass.toBoundedOrderHomClass
code: instance (priority := 100) OrderIsoClass.toBoundedOrderHomClass [LE α] [BoundedOrder α]
    [PartialOrder β] [BoundedOrder β] [OrderIsoClass F α β] : BoundedOrderHomClass F α β 
goal: BoundedOrderHomClass F α β

full_name: map_eq_top_iff
code: @[simp]
theorem map_eq_top_iff [LE α] [OrderTop α] [PartialOrder β] [OrderTop β] [OrderIsoClass F α β]
    (f : F) {a : α} : f a = ⊤ ↔ a = ⊤ 
goal: f a = ⊤ ↔ a = ⊤

full_name: map_eq_bot_iff
code: @[simp]
theorem map_eq_bot_iff [LE α] [OrderBot α] [PartialOrder β] [OrderBot β] [OrderIsoClass F α β]
    (f : F) {a : α} : f a = ⊥ ↔ a = ⊥ 
goal: f a = ⊥ ↔ a = ⊥

full_name: TopHomClass.toTopHom
code: /-- Turn an element of a type `F` satisfying `TopHomClass F α β` into an actual
`TopHom`. This is declared as the default coercion from `F` to `TopHom α β`. -/
@[coe]
def TopHomClass.toTopHom [Top α] [Top β] [TopHomClass F α β] (f : F) : TopHom α β 
goal: TopHom α β

full_name: instCoeTCTopHomOfTopHomClass
code: instance [Top α] [Top β] [TopHomClass F α β] : CoeTC F (TopHom α β) 
goal: CoeTC F (TopHom α β)

full_name: BotHomClass.toBotHom
code: /-- Turn an element of a type `F` satisfying `BotHomClass F α β` into an actual
`BotHom`. This is declared as the default coercion from `F` to `BotHom α β`. -/
@[coe]
def BotHomClass.toBotHom [Bot α] [Bot β] [BotHomClass F α β] (f : F) : BotHom α β 
goal: BotHom α β

full_name: instCoeTCBotHomOfBotHomClass
code: instance [Bot α] [Bot β] [BotHomClass F α β] : CoeTC F (BotHom α β) 
goal: CoeTC F (BotHom α β)

full_name: BoundedOrderHomClass.toBoundedOrderHom
code: /-- Turn an element of a type `F` satisfying `BoundedOrderHomClass F α β` into an actual
`BoundedOrderHom`. This is declared as the default coercion from `F` to `BoundedOrderHom α β`. -/
@[coe]
def BoundedOrderHomClass.toBoundedOrderHom [Preorder α] [Preorder β] [BoundedOrder α]
    [BoundedOrder β] [BoundedOrderHomClass F α β] (f : F) : BoundedOrderHom α β 
goal: BoundedOrderHom α β

full_name: instCoeTCBoundedOrderHomOfBoundedOrderHomClass
code: instance [Preorder α] [Preorder β] [BoundedOrder α] [BoundedOrder β] [BoundedOrderHomClass F α β] :
    CoeTC F (BoundedOrderHom α β) 
goal: CoeTC F (BoundedOrderHom α β)

full_name: TopHom.instFunLike
code: instance : FunLike (TopHom α β) α β 
goal: FunLike (TopHom α β) α β

full_name: TopHom.instTopHomClass
code: instance : TopHomClass (TopHom α β) α β 
goal: TopHomClass (TopHom α β) α β

full_name: TopHom.ext
code: @[ext]
theorem ext {f g : TopHom α β} (h : ∀ a, f a = g a) : f = g 
goal: f = g

full_name: TopHom.copy
code: /-- Copy of a `TopHom` with a new `toFun` equal to the old one. Useful to fix definitional
equalities. -/
protected def copy (f : TopHom α β) (f' : α → β) (h : f' = f) :
    TopHom α β 
goal: TopHom α β

full_name: TopHom.coe_copy
code: @[simp]
theorem coe_copy (f : TopHom α β) (f' : α → β) (h : f' = f) : ⇑(f.copy f' h) = f' 
goal: ⇑(f.copy f' h) = f'

full_name: TopHom.copy_eq
code: theorem copy_eq (f : TopHom α β) (f' : α → β) (h : f' = f) : f.copy f' h = f 
goal: f.copy f' h = f

full_name: TopHom.instInhabited
code: instance : Inhabited (TopHom α β) 
goal: Inhabited (TopHom α β)

full_name: TopHom.id
code: /-- `id` as a `TopHom`. -/
protected def id : TopHom α α 
goal: TopHom α α

full_name: TopHom.coe_id
code: @[simp]
theorem coe_id : ⇑(TopHom.id α) = id 
goal: ⇑(TopHom.id α) = id

full_name: TopHom.id_apply
code: @[simp]
theorem id_apply (a : α) : TopHom.id α a = a 
goal: (TopHom.id α) a = a

full_name: TopHom.comp
code: /-- Composition of `TopHom`s as a `TopHom`. -/
def comp (f : TopHom β γ) (g : TopHom α β) :
    TopHom α γ 
goal: TopHom α γ

full_name: TopHom.coe_comp
code: @[simp]
theorem coe_comp (f : TopHom β γ) (g : TopHom α β) : (f.comp g : α → γ) = f ∘ g 
goal: ⇑(f.comp g) = ⇑f ∘ ⇑g

full_name: TopHom.comp_apply
code: @[simp]
theorem comp_apply (f : TopHom β γ) (g : TopHom α β) (a : α) : (f.comp g) a = f (g a) 
goal: (f.comp g) a = f (g a)

full_name: TopHom.comp_assoc
code: @[simp]
theorem comp_assoc (f : TopHom γ δ) (g : TopHom β γ) (h : TopHom α β) :
    (f.comp g).comp h = f.comp (g.comp h) 
goal: (f.comp g).comp h = f.comp (g.comp h)

full_name: TopHom.comp_id
code: @[simp]
theorem comp_id (f : TopHom α β) : f.comp (TopHom.id α) = f 
goal: f.comp (TopHom.id α) = f

full_name: TopHom.id_comp
code: @[simp]
theorem id_comp (f : TopHom α β) : (TopHom.id β).comp f = f 
goal: (TopHom.id β).comp f = f

full_name: TopHom.cancel_right
code: @[simp]
theorem cancel_right {g₁ g₂ : TopHom β γ} {f : TopHom α β} (hf : Surjective f) :
    g₁.comp f = g₂.comp f ↔ g₁ = g₂ 
goal: g₁.comp f = g₂.comp f ↔ g₁ = g₂

full_name: TopHom.cancel_left
code: @[simp]
theorem cancel_left {g : TopHom β γ} {f₁ f₂ : TopHom α β} (hg : Injective g) :
    g.comp f₁ = g.comp f₂ ↔ f₁ = f₂ 
goal: g.comp f₁ = g.comp f₂ ↔ f₁ = f₂

full_name: TopHom.instLE
code: instance instLE [LE β] [Top β] : LE (TopHom α β) 
goal: LE (TopHom α β)

full_name: TopHom.instPreorder
code: instance [Preorder β] [Top β] : Preorder (TopHom α β) 
goal: Preorder (TopHom α β)

full_name: TopHom.instPartialOrder
code: instance [PartialOrder β] [Top β] : PartialOrder (TopHom α β) 
goal: PartialOrder (TopHom α β)

full_name: TopHom.instOrderTop
code: instance : OrderTop (TopHom α β) 
goal: OrderTop (TopHom α β)

full_name: TopHom.coe_top
code: @[simp]
theorem coe_top : ⇑(⊤ : TopHom α β) = ⊤ 
goal: ⇑⊤ = ⊤

full_name: TopHom.top_apply
code: @[simp]
theorem top_apply (a : α) : (⊤ : TopHom α β) a = ⊤ 
goal: ⊤ a = ⊤

full_name: TopHom.instInf
code: instance : Inf (TopHom α β) 
goal: Inf (TopHom α β)

full_name: TopHom.instSemilatticeInf
code: instance : SemilatticeInf (TopHom α β) 
goal: SemilatticeInf (TopHom α β)

full_name: TopHom.coe_inf
code: @[simp]
theorem coe_inf : ⇑(f ⊓ g) = ⇑f ⊓ ⇑g 
goal: ⇑(f ⊓ g) = ⇑f ⊓ ⇑g

full_name: TopHom.inf_apply
code: @[simp]
theorem inf_apply (a : α) : (f ⊓ g) a = f a ⊓ g a 
goal: (f ⊓ g) a = f a ⊓ g a

full_name: TopHom.instSup
code: instance : Sup (TopHom α β) 
goal: Sup (TopHom α β)

full_name: TopHom.instSemilatticeSup
code: instance : SemilatticeSup (TopHom α β) 
goal: SemilatticeSup (TopHom α β)

full_name: TopHom.coe_sup
code: @[simp]
theorem coe_sup : ⇑(f ⊔ g) = ⇑f ⊔ ⇑g 
goal: ⇑(f ⊔ g) = ⇑f ⊔ ⇑g

full_name: TopHom.sup_apply
code: @[simp]
theorem sup_apply (a : α) : (f ⊔ g) a = f a ⊔ g a 
goal: (f ⊔ g) a = f a ⊔ g a

full_name: TopHom.instLattice
code: instance [Lattice β] [OrderTop β] : Lattice (TopHom α β) 
goal: Lattice (TopHom α β)

full_name: TopHom.instDistribLattice
code: instance [DistribLattice β] [OrderTop β] : DistribLattice (TopHom α β) 
goal: DistribLattice (TopHom α β)

full_name: BotHom.instFunLike
code: instance : FunLike (BotHom α β) α β 
goal: FunLike (BotHom α β) α β

full_name: BotHom.instBotHomClass
code: instance : BotHomClass (BotHom α β) α β 
goal: BotHomClass (BotHom α β) α β

full_name: BotHom.ext
code: @[ext]
theorem ext {f g : BotHom α β} (h : ∀ a, f a = g a) : f = g 
goal: f = g

full_name: BotHom.copy
code: /-- Copy of a `BotHom` with a new `toFun` equal to the old one. Useful to fix definitional
equalities. -/
protected def copy (f : BotHom α β) (f' : α → β) (h : f' = f) :
    BotHom α β 
goal: BotHom α β

full_name: BotHom.coe_copy
code: @[simp]
theorem coe_copy (f : BotHom α β) (f' : α → β) (h : f' = f) : ⇑(f.copy f' h) = f' 
goal: ⇑(f.copy f' h) = f'

full_name: BotHom.copy_eq
code: theorem copy_eq (f : BotHom α β) (f' : α → β) (h : f' = f) : f.copy f' h = f 
goal: f.copy f' h = f

full_name: BotHom.instInhabited
code: instance : Inhabited (BotHom α β) 
goal: Inhabited (BotHom α β)

full_name: BotHom.id
code: /-- `id` as a `BotHom`. -/
protected def id : BotHom α α 
goal: BotHom α α

full_name: BotHom.coe_id
code: @[simp]
theorem coe_id : ⇑(BotHom.id α) = id 
goal: ⇑(BotHom.id α) = id

full_name: BotHom.id_apply
code: @[simp]
theorem id_apply (a : α) : BotHom.id α a = a 
goal: (BotHom.id α) a = a

full_name: BotHom.comp
code: /-- Composition of `BotHom`s as a `BotHom`. -/
def comp (f : BotHom β γ) (g : BotHom α β) :
    BotHom α γ 
goal: BotHom α γ

full_name: BotHom.coe_comp
code: @[simp]
theorem coe_comp (f : BotHom β γ) (g : BotHom α β) : (f.comp g : α → γ) = f ∘ g 
goal: ⇑(f.comp g) = ⇑f ∘ ⇑g

full_name: BotHom.comp_apply
code: @[simp]
theorem comp_apply (f : BotHom β γ) (g : BotHom α β) (a : α) : (f.comp g) a = f (g a) 
goal: (f.comp g) a = f (g a)

full_name: BotHom.comp_assoc
code: @[simp]
theorem comp_assoc (f : BotHom γ δ) (g : BotHom β γ) (h : BotHom α β) :
    (f.comp g).comp h = f.comp (g.comp h) 
goal: (f.comp g).comp h = f.comp (g.comp h)

full_name: BotHom.comp_id
code: @[simp]
theorem comp_id (f : BotHom α β) : f.comp (BotHom.id α) = f 
goal: f.comp (BotHom.id α) = f

full_name: BotHom.id_comp
code: @[simp]
theorem id_comp (f : BotHom α β) : (BotHom.id β).comp f = f 
goal: (BotHom.id β).comp f = f

full_name: BotHom.cancel_right
code: @[simp]
theorem cancel_right {g₁ g₂ : BotHom β γ} {f : BotHom α β} (hf : Surjective f) :
    g₁.comp f = g₂.comp f ↔ g₁ = g₂ 
goal: g₁.comp f = g₂.comp f ↔ g₁ = g₂

full_name: BotHom.cancel_left
code: @[simp]
theorem cancel_left {g : BotHom β γ} {f₁ f₂ : BotHom α β} (hg : Injective g) :
    g.comp f₁ = g.comp f₂ ↔ f₁ = f₂ 
goal: g.comp f₁ = g.comp f₂ ↔ f₁ = f₂

full_name: BotHom.instLE
code: instance instLE [LE β] [Bot β] : LE (BotHom α β) 
goal: LE (BotHom α β)

full_name: BotHom.instPreorder
code: instance [Preorder β] [Bot β] : Preorder (BotHom α β) 
goal: Preorder (BotHom α β)

full_name: BotHom.instPartialOrder
code: instance [PartialOrder β] [Bot β] : PartialOrder (BotHom α β) 
goal: PartialOrder (BotHom α β)

full_name: BotHom.instOrderBot
code: instance : OrderBot (BotHom α β) 
goal: OrderBot (BotHom α β)

full_name: BotHom.coe_bot
code: @[simp]
theorem coe_bot : ⇑(⊥ : BotHom α β) = ⊥ 
goal: ⇑⊥ = ⊥

full_name: BotHom.bot_apply
code: @[simp]
theorem bot_apply (a : α) : (⊥ : BotHom α β) a = ⊥ 
goal: ⊥ a = ⊥

full_name: BotHom.instInf
code: instance : Inf (BotHom α β) 
goal: Inf (BotHom α β)

full_name: BotHom.instSemilatticeInf
code: instance : SemilatticeInf (BotHom α β) 
goal: SemilatticeInf (BotHom α β)

full_name: BotHom.coe_inf
code: @[simp]
theorem coe_inf : ⇑(f ⊓ g) = ⇑f ⊓ ⇑g 
goal: ⇑(f ⊓ g) = ⇑f ⊓ ⇑g

full_name: BotHom.inf_apply
code: @[simp]
theorem inf_apply (a : α) : (f ⊓ g) a = f a ⊓ g a 
goal: (f ⊓ g) a = f a ⊓ g a

full_name: BotHom.instSup
code: instance : Sup (BotHom α β) 
goal: Sup (BotHom α β)

full_name: BotHom.instSemilatticeSup
code: instance : SemilatticeSup (BotHom α β) 
goal: SemilatticeSup (BotHom α β)

full_name: BotHom.coe_sup
code: @[simp]
theorem coe_sup : ⇑(f ⊔ g) = ⇑f ⊔ ⇑g 
goal: ⇑(f ⊔ g) = ⇑f ⊔ ⇑g

full_name: BotHom.sup_apply
code: @[simp]
theorem sup_apply (a : α) : (f ⊔ g) a = f a ⊔ g a 
goal: (f ⊔ g) a = f a ⊔ g a

full_name: BotHom.instLattice
code: instance [Lattice β] [OrderBot β] : Lattice (BotHom α β) 
goal: Lattice (BotHom α β)

full_name: BotHom.instDistribLattice
code: instance [DistribLattice β] [OrderBot β] : DistribLattice (BotHom α β) 
goal: DistribLattice (BotHom α β)

full_name: BoundedOrderHom.toTopHom
code: /-- Reinterpret a `BoundedOrderHom` as a `TopHom`. -/
def toTopHom (f : BoundedOrderHom α β) : TopHom α β 
goal: TopHom α β

full_name: BoundedOrderHom.toBotHom
code: /-- Reinterpret a `BoundedOrderHom` as a `BotHom`. -/
def toBotHom (f : BoundedOrderHom α β) : BotHom α β 
goal: BotHom α β

full_name: BoundedOrderHom.instFunLike
code: instance : FunLike (BoundedOrderHom α β) α β 
goal: FunLike (BoundedOrderHom α β) α β

full_name: BoundedOrderHom.instBoundedOrderHomClass
code: instance : BoundedOrderHomClass (BoundedOrderHom α β) α β 
goal: BoundedOrderHomClass (BoundedOrderHom α β) α β

full_name: BoundedOrderHom.ext
code: @[ext]
theorem ext {f g : BoundedOrderHom α β} (h : ∀ a, f a = g a) : f = g 
goal: f = g

full_name: BoundedOrderHom.copy
code: /-- Copy of a `BoundedOrderHom` with a new `toFun` equal to the old one. Useful to fix
definitional equalities. -/
protected def copy (f : BoundedOrderHom α β) (f' : α → β) (h : f' = f) : BoundedOrderHom α β 
goal: BoundedOrderHom α β

full_name: BoundedOrderHom.coe_copy
code: @[simp]
theorem coe_copy (f : BoundedOrderHom α β) (f' : α → β) (h : f' = f) : ⇑(f.copy f' h) = f' 
goal: ⇑(f.copy f' h) = f'

full_name: BoundedOrderHom.copy_eq
code: theorem copy_eq (f : BoundedOrderHom α β) (f' : α → β) (h : f' = f) : f.copy f' h = f 
goal: f.copy f' h = f

full_name: BoundedOrderHom.id
code: /-- `id` as a `BoundedOrderHom`. -/
protected def id : BoundedOrderHom α α 
goal: BoundedOrderHom α α

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

full_name: BoundedOrderHom.coe_id
code: @[simp]
theorem coe_id : ⇑(BoundedOrderHom.id α) = id 
goal: ⇑(BoundedOrderHom.id α) = id

full_name: BoundedOrderHom.id_apply
code: @[simp]
theorem id_apply (a : α) : BoundedOrderHom.id α a = a 
goal: (BoundedOrderHom.id α) a = a

full_name: BoundedOrderHom.comp
code: /-- Composition of `BoundedOrderHom`s as a `BoundedOrderHom`. -/
def comp (f : BoundedOrderHom β γ) (g : BoundedOrderHom α β) : BoundedOrderHom α γ 
goal: BoundedOrderHom α γ

full_name: BoundedOrderHom.coe_comp
code: @[simp]
theorem coe_comp (f : BoundedOrderHom β γ) (g : BoundedOrderHom α β) : (f.comp g : α → γ) = f ∘ g 
goal: ⇑(f.comp g) = ⇑f ∘ ⇑g

full_name: BoundedOrderHom.comp_apply
code: @[simp]
theorem comp_apply (f : BoundedOrderHom β γ) (g : BoundedOrderHom α β) (a : α) :
    (f.comp g) a = f (g a) 
goal: (f.comp g) a = f (g a)

full_name: BoundedOrderHom.coe_comp_orderHom
code: @[simp]
theorem coe_comp_orderHom (f : BoundedOrderHom β γ) (g : BoundedOrderHom α β) :
    (f.comp g : OrderHom α γ) = (f : OrderHom β γ).comp g 
goal: ↑(f.comp g) = (↑f).comp ↑g

full_name: BoundedOrderHom.coe_comp_topHom
code: @[simp]
theorem coe_comp_topHom (f : BoundedOrderHom β γ) (g : BoundedOrderHom α β) :
    (f.comp g : TopHom α γ) = (f : TopHom β γ).comp g 
goal: ↑(f.comp g) = (↑f).comp ↑g

full_name: BoundedOrderHom.coe_comp_botHom
code: @[simp]
theorem coe_comp_botHom (f : BoundedOrderHom β γ) (g : BoundedOrderHom α β) :
    (f.comp g : BotHom α γ) = (f : BotHom β γ).comp g 
goal: ↑(f.comp g) = (↑f).comp ↑g

full_name: BoundedOrderHom.comp_assoc
code: @[simp]
theorem comp_assoc (f : BoundedOrderHom γ δ) (g : BoundedOrderHom β γ) (h : BoundedOrderHom α β) :
    (f.comp g).comp h = f.comp (g.comp h) 
goal: (f.comp g).comp h = f.comp (g.comp h)

full_name: BoundedOrderHom.comp_id
code: @[simp]
theorem comp_id (f : BoundedOrderHom α β) : f.comp (BoundedOrderHom.id α) = f 
goal: f.comp (BoundedOrderHom.id α) = f

full_name: BoundedOrderHom.id_comp
code: @[simp]
theorem id_comp (f : BoundedOrderHom α β) : (BoundedOrderHom.id β).comp f = f 
goal: (BoundedOrderHom.id β).comp f = f

full_name: BoundedOrderHom.cancel_right
code: @[simp]
theorem cancel_right {g₁ g₂ : BoundedOrderHom β γ} {f : BoundedOrderHom α β} (hf : Surjective f) :
    g₁.comp f = g₂.comp f ↔ g₁ = g₂ 
goal: g₁.comp f = g₂.comp f ↔ g₁ = g₂

full_name: BoundedOrderHom.cancel_left
code: @[simp]
theorem cancel_left {g : BoundedOrderHom β γ} {f₁ f₂ : BoundedOrderHom α β} (hg : Injective g) :
    g.comp f₁ = g.comp f₂ ↔ f₁ = f₂ 
goal: g.comp f₁ = g.comp f₂ ↔ f₁ = f₂

full_name: TopHom.dual_apply_apply
code: /-- Reinterpret a top homomorphism as a bot homomorphism between the dual lattices. -/
@[simps]
protected def dual :
    TopHom α β ≃ BotHom αᵒᵈ βᵒᵈ 
goal: (TopHom.dual f) a = f a

full_name: TopHom.dual_symm_apply_apply
code: /-- Reinterpret a top homomorphism as a bot homomorphism between the dual lattices. -/
@[simps]
protected def dual :
    TopHom α β ≃ BotHom αᵒᵈ βᵒᵈ 
goal: (TopHom.dual.symm f) a = f a

full_name: TopHom.dual
code: /-- Reinterpret a top homomorphism as a bot homomorphism between the dual lattices. -/
@[simps]
protected def dual :
    TopHom α β ≃ BotHom αᵒᵈ βᵒᵈ 
goal: TopHom α β ≃ BotHom αᵒᵈ βᵒᵈ

full_name: TopHom.dual_id
code: @[simp]
theorem dual_id : TopHom.dual (TopHom.id α) = BotHom.id _ 
goal: TopHom.dual (TopHom.id α) = BotHom.id αᵒᵈ

full_name: TopHom.dual_comp
code: @[simp]
theorem dual_comp (g : TopHom β γ) (f : TopHom α β) :
    TopHom.dual (g.comp f) = g.dual.comp (TopHom.dual f) 
goal: TopHom.dual (g.comp f) = (TopHom.dual g).comp (TopHom.dual f)

full_name: TopHom.symm_dual_id
code: @[simp]
theorem symm_dual_id : TopHom.dual.symm (BotHom.id _) = TopHom.id α 
goal: TopHom.dual.symm (BotHom.id αᵒᵈ) = TopHom.id α

full_name: TopHom.symm_dual_comp
code: @[simp]
theorem symm_dual_comp (g : BotHom βᵒᵈ γᵒᵈ) (f : BotHom αᵒᵈ βᵒᵈ) :
    TopHom.dual.symm (g.comp f) = (TopHom.dual.symm g).comp (TopHom.dual.symm f) 
goal: TopHom.dual.symm (g.comp f) = (TopHom.dual.symm g).comp (TopHom.dual.symm f)

full_name: BotHom.dual_apply_apply
code: /-- Reinterpret a bot homomorphism as a top homomorphism between the dual lattices. -/
@[simps]
protected def dual :
    BotHom α β ≃ TopHom αᵒᵈ βᵒᵈ 
goal: (BotHom.dual f) a = f a

full_name: BotHom.dual
code: /-- Reinterpret a bot homomorphism as a top homomorphism between the dual lattices. -/
@[simps]
protected def dual :
    BotHom α β ≃ TopHom αᵒᵈ βᵒᵈ 
goal: BotHom α β ≃ TopHom αᵒᵈ βᵒᵈ

full_name: BotHom.dual_symm_apply_apply
code: /-- Reinterpret a bot homomorphism as a top homomorphism between the dual lattices. -/
@[simps]
protected def dual :
    BotHom α β ≃ TopHom αᵒᵈ βᵒᵈ 
goal: (BotHom.dual.symm f) a = f a

full_name: BotHom.dual_id
code: @[simp]
theorem dual_id : BotHom.dual (BotHom.id α) = TopHom.id _ 
goal: BotHom.dual (BotHom.id α) = TopHom.id αᵒᵈ

full_name: BotHom.dual_comp
code: @[simp]
theorem dual_comp (g : BotHom β γ) (f : BotHom α β) :
    BotHom.dual (g.comp f) = g.dual.comp (BotHom.dual f) 
goal: BotHom.dual (g.comp f) = (BotHom.dual g).comp (BotHom.dual f)

full_name: BotHom.symm_dual_id
code: @[simp]
theorem symm_dual_id : BotHom.dual.symm (TopHom.id _) = BotHom.id α 
goal: BotHom.dual.symm (TopHom.id αᵒᵈ) = BotHom.id α

full_name: BotHom.symm_dual_comp
code: @[simp]
theorem symm_dual_comp (g : TopHom βᵒᵈ γᵒᵈ) (f : TopHom αᵒᵈ βᵒᵈ) :
    BotHom.dual.symm (g.comp f) = (BotHom.dual.symm g).comp (BotHom.dual.symm f) 
goal: BotHom.dual.symm (g.comp f) = (BotHom.dual.symm g).comp (BotHom.dual.symm f)

full_name: BoundedOrderHom.dual_apply_toOrderHom
code: /-- Reinterpret a bounded order homomorphism as a bounded order homomorphism between the dual
orders. -/
@[simps]
protected def dual :
    BoundedOrderHom α β ≃
      BoundedOrderHom αᵒᵈ
        βᵒᵈ 
goal: (BoundedOrderHom.dual f).toOrderHom = OrderHom.dual f.toOrderHom

full_name: BoundedOrderHom.dual_symm_apply_toOrderHom
code: /-- Reinterpret a bounded order homomorphism as a bounded order homomorphism between the dual
orders. -/
@[simps]
protected def dual :
    BoundedOrderHom α β ≃
      BoundedOrderHom αᵒᵈ
        βᵒᵈ 
goal: (BoundedOrderHom.dual.symm f).toOrderHom = OrderHom.dual.symm f.toOrderHom

full_name: BoundedOrderHom.dual
code: /-- Reinterpret a bounded order homomorphism as a bounded order homomorphism between the dual
orders. -/
@[simps]
protected def dual :
    BoundedOrderHom α β ≃
      BoundedOrderHom αᵒᵈ
        βᵒᵈ 
goal: BoundedOrderHom α β ≃ BoundedOrderHom αᵒᵈ βᵒᵈ

full_name: BoundedOrderHom.dual_id
code: @[simp]
theorem dual_id : BoundedOrderHom.dual (BoundedOrderHom.id α) = BoundedOrderHom.id _ 
goal: BoundedOrderHom.dual (BoundedOrderHom.id α) = BoundedOrderHom.id αᵒᵈ

full_name: BoundedOrderHom.dual_comp
code: @[simp]
theorem dual_comp (g : BoundedOrderHom β γ) (f : BoundedOrderHom α β) :
    BoundedOrderHom.dual (g.comp f) = g.dual.comp (BoundedOrderHom.dual f) 
goal: BoundedOrderHom.dual (g.comp f) = (BoundedOrderHom.dual g).comp (BoundedOrderHom.dual f)

full_name: BoundedOrderHom.symm_dual_id
code: @[simp]
theorem symm_dual_id : BoundedOrderHom.dual.symm (BoundedOrderHom.id _) = BoundedOrderHom.id α 
goal: BoundedOrderHom.dual.symm (BoundedOrderHom.id αᵒᵈ) = BoundedOrderHom.id α

full_name: BoundedOrderHom.symm_dual_comp
code: @[simp]
theorem symm_dual_comp (g : BoundedOrderHom βᵒᵈ γᵒᵈ) (f : BoundedOrderHom αᵒᵈ βᵒᵈ) :
    BoundedOrderHom.dual.symm (g.comp f) =
      (BoundedOrderHom.dual.symm g).comp (BoundedOrderHom.dual.symm f) 
goal: BoundedOrderHom.dual.symm (g.comp f) = (BoundedOrderHom.dual.symm g).comp (BoundedOrderHom.dual.symm f)