File: Mathlib/Data/Sum/Order.lean

full_name: Sum.LiftRel.refl
code: @[refl]
theorem LiftRel.refl [IsRefl α r] [IsRefl β s] : ∀ x, LiftRel r s x x
  
goal: Sum.LiftRel r s x x

full_name: Sum.instIsReflLiftRel
code: instance [IsRefl α r] [IsRefl β s] : IsRefl (α ⊕ β) (LiftRel r s) 
goal: IsRefl (α ⊕ β) (Sum.LiftRel r s)

full_name: Sum.instIsIrreflLiftRel
code: instance [IsIrrefl α r] [IsIrrefl β s] : IsIrrefl (α ⊕ β) (LiftRel r s) 
goal: IsIrrefl (α ⊕ β) (Sum.LiftRel r s)

full_name: Sum.LiftRel.trans
code: @[trans]
theorem LiftRel.trans [IsTrans α r] [IsTrans β s] :
    ∀ {a b c}, LiftRel r s a b → LiftRel r s b c → LiftRel r s a c
  
goal: Sum.LiftRel r s a b → Sum.LiftRel r s b c → Sum.LiftRel r s a c

full_name: Sum.instIsTransLiftRel
code: instance [IsTrans α r] [IsTrans β s] : IsTrans (α ⊕ β) (LiftRel r s) 
goal: IsTrans (α ⊕ β) (Sum.LiftRel r s)

full_name: Sum.instIsAntisymmLiftRel
code: instance [IsAntisymm α r] [IsAntisymm β s] : IsAntisymm (α ⊕ β) (LiftRel r s) 
goal: IsAntisymm (α ⊕ β) (Sum.LiftRel r s)

full_name: Sum.instIsReflLex
code: instance [IsRefl α r] [IsRefl β s] : IsRefl (α ⊕ β) (Lex r s) 
goal: IsRefl (α ⊕ β) (Sum.Lex r s)

full_name: Sum.instIsIrreflLex
code: instance [IsIrrefl α r] [IsIrrefl β s] : IsIrrefl (α ⊕ β) (Lex r s) 
goal: IsIrrefl (α ⊕ β) (Sum.Lex r s)

full_name: Sum.instIsTransLex
code: instance [IsTrans α r] [IsTrans β s] : IsTrans (α ⊕ β) (Lex r s) 
goal: IsTrans (α ⊕ β) (Sum.Lex r s)

full_name: Sum.instIsAntisymmLex
code: instance [IsAntisymm α r] [IsAntisymm β s] : IsAntisymm (α ⊕ β) (Lex r s) 
goal: IsAntisymm (α ⊕ β) (Sum.Lex r s)

full_name: Sum.instIsTotalLex
code: instance [IsTotal α r] [IsTotal β s] : IsTotal (α ⊕ β) (Lex r s) 
goal: IsTotal (α ⊕ β) (Sum.Lex r s)

full_name: Sum.instIsTrichotomousLex
code: instance [IsTrichotomous α r] [IsTrichotomous β s] : IsTrichotomous (α ⊕ β) (Lex r s) 
goal: IsTrichotomous (α ⊕ β) (Sum.Lex r s)

full_name: Sum.instIsWellOrderLex
code: instance [IsWellOrder α r] [IsWellOrder β s] :
    IsWellOrder (α ⊕ β) (Sum.Lex r s) 
goal: IsWellOrder (α ⊕ β) (Sum.Lex r s)

full_name: Sum.instLESum
code: instance instLESum [LE α] [LE β] : LE (α ⊕ β) 
goal: LE (α ⊕ β)

full_name: Sum.instLTSum
code: instance instLTSum [LT α] [LT β] : LT (α ⊕ β) 
goal: LT (α ⊕ β)

full_name: Sum.le_def
code: theorem le_def [LE α] [LE β] {a b : α ⊕ β} : a ≤ b ↔ LiftRel (· ≤ ·) (· ≤ ·) a b 
goal: a ≤ b ↔ Sum.LiftRel (fun x x_1 => x ≤ x_1) (fun x x_1 => x ≤ x_1) a b

full_name: Sum.lt_def
code: theorem lt_def [LT α] [LT β] {a b : α ⊕ β} : a < b ↔ LiftRel (· < ·) (· < ·) a b 
goal: a < b ↔ Sum.LiftRel (fun x x_1 => x < x_1) (fun x x_1 => x < x_1) a b

full_name: Sum.inl_le_inl_iff
code: @[simp]
theorem inl_le_inl_iff [LE α] [LE β] {a b : α} : (inl a : α ⊕ β) ≤ inl b ↔ a ≤ b 
goal: Sum.inl a ≤ Sum.inl b ↔ a ≤ b

full_name: Sum.inr_le_inr_iff
code: @[simp]
theorem inr_le_inr_iff [LE α] [LE β] {a b : β} : (inr a : α ⊕ β) ≤ inr b ↔ a ≤ b 
goal: Sum.inr a ≤ Sum.inr b ↔ a ≤ b

full_name: Sum.inl_lt_inl_iff
code: @[simp]
theorem inl_lt_inl_iff [LT α] [LT β] {a b : α} : (inl a : α ⊕ β) < inl b ↔ a < b 
goal: Sum.inl a < Sum.inl b ↔ a < b

full_name: Sum.inr_lt_inr_iff
code: @[simp]
theorem inr_lt_inr_iff [LT α] [LT β] {a b : β} : (inr a : α ⊕ β) < inr b ↔ a < b 
goal: Sum.inr a < Sum.inr b ↔ a < b

full_name: Sum.not_inl_le_inr
code: @[simp]
theorem not_inl_le_inr [LE α] [LE β] {a : α} {b : β} : ¬inl b ≤ inr a 
goal: ¬Sum.inl b ≤ Sum.inr a

full_name: Sum.not_inl_lt_inr
code: @[simp]
theorem not_inl_lt_inr [LT α] [LT β] {a : α} {b : β} : ¬inl b < inr a 
goal: ¬Sum.inl b < Sum.inr a

full_name: Sum.not_inr_le_inl
code: @[simp]
theorem not_inr_le_inl [LE α] [LE β] {a : α} {b : β} : ¬inr b ≤ inl a 
goal: ¬Sum.inr b ≤ Sum.inl a

full_name: Sum.not_inr_lt_inl
code: @[simp]
theorem not_inr_lt_inl [LT α] [LT β] {a : α} {b : β} : ¬inr b < inl a 
goal: ¬Sum.inr b < Sum.inl a

full_name: Sum.instPreorderSum
code: instance instPreorderSum : Preorder (α ⊕ β) 
goal: Preorder (α ⊕ β)

full_name: Sum.inl_mono
code: theorem inl_mono : Monotone (inl : α → α ⊕ β) 
goal: Monotone Sum.inl

full_name: Sum.inr_mono
code: theorem inr_mono : Monotone (inr : β → α ⊕ β) 
goal: Monotone Sum.inr

full_name: Sum.inl_strictMono
code: theorem inl_strictMono : StrictMono (inl : α → α ⊕ β) 
goal: StrictMono Sum.inl

full_name: Sum.inr_strictMono
code: theorem inr_strictMono : StrictMono (inr : β → α ⊕ β) 
goal: StrictMono Sum.inr

full_name: Sum.instPartialOrder
code: instance [PartialOrder α] [PartialOrder β] : PartialOrder (α ⊕ β) 
goal: PartialOrder (α ⊕ β)

full_name: Sum.noMinOrder
code: instance noMinOrder [LT α] [LT β] [NoMinOrder α] [NoMinOrder β] : NoMinOrder (α ⊕ β) 
goal: NoMinOrder (α ⊕ β)

full_name: Sum.noMaxOrder
code: instance noMaxOrder [LT α] [LT β] [NoMaxOrder α] [NoMaxOrder β] : NoMaxOrder (α ⊕ β) 
goal: NoMaxOrder (α ⊕ β)

full_name: Sum.noMinOrder_iff
code: @[simp]
theorem noMinOrder_iff [LT α] [LT β] : NoMinOrder (α ⊕ β) ↔ NoMinOrder α ∧ NoMinOrder β 
goal: NoMinOrder (α ⊕ β) ↔ NoMinOrder α ∧ NoMinOrder β

full_name: Sum.noMaxOrder_iff
code: @[simp]
theorem noMaxOrder_iff [LT α] [LT β] : NoMaxOrder (α ⊕ β) ↔ NoMaxOrder α ∧ NoMaxOrder β 
goal: NoMaxOrder (α ⊕ β) ↔ NoMaxOrder α ∧ NoMaxOrder β

full_name: Sum.denselyOrdered
code: instance denselyOrdered [LT α] [LT β] [DenselyOrdered α] [DenselyOrdered β] :
    DenselyOrdered (α ⊕ β) 
goal: DenselyOrdered (α ⊕ β)

full_name: Sum.denselyOrdered_iff
code: @[simp]
theorem denselyOrdered_iff [LT α] [LT β] :
    DenselyOrdered (α ⊕ β) ↔ DenselyOrdered α ∧ DenselyOrdered β 
goal: DenselyOrdered (α ⊕ β) ↔ DenselyOrdered α ∧ DenselyOrdered β

full_name: Sum.swap_le_swap_iff
code: @[simp]
theorem swap_le_swap_iff [LE α] [LE β] {a b : α ⊕ β} : a.swap ≤ b.swap ↔ a ≤ b 
goal: a.swap ≤ b.swap ↔ a ≤ b

full_name: Sum.swap_lt_swap_iff
code: @[simp]
theorem swap_lt_swap_iff [LT α] [LT β] {a b : α ⊕ β} : a.swap < b.swap ↔ a < b 
goal: a.swap < b.swap ↔ a < b

full_name: Sum.Lex._aux_Mathlib_Data_Sum_Order___unexpand_Lex_1
code: /-- The linear sum of two orders -/
notation:30 α " ⊕ₗ " β:29 => _root_.Lex (α ⊕ β)
goal: Lean.PrettyPrinter.Unexpander

full_name: Sum.Lex.«_aux_Mathlib_Data_Sum_Order___macroRules_Sum_Lex_term_⊕ₗ__1»
code: /-- The linear sum of two orders -/
notation:30 α " ⊕ₗ " β:29 => _root_.Lex (α ⊕ β)
goal: Lean.Macro

full_name: Sum.inlₗ
code: /-- Lexicographical `Sum.inl`. Only used for pattern matching. -/
@[match_pattern]
abbrev _root_.Sum.inlₗ (x : α) : α ⊕ₗ β 
goal: Lex (α ⊕ β)

full_name: Sum.inrₗ
code: /-- Lexicographical `Sum.inr`. Only used for pattern matching. -/
@[match_pattern]
abbrev _root_.Sum.inrₗ (x : β) : α ⊕ₗ β 
goal: Lex (α ⊕ β)

full_name: Sum.Lex.LE
code: /-- The linear/lexicographical `≤` on a sum. -/
protected instance LE [LE α] [LE β] : LE (α ⊕ₗ β) 
goal: LE (Lex (α ⊕ β))

full_name: Sum.Lex.LT
code: /-- The linear/lexicographical `<` on a sum. -/
protected instance LT [LT α] [LT β] : LT (α ⊕ₗ β) 
goal: LT (Lex (α ⊕ β))

full_name: Sum.Lex.toLex_le_toLex
code: @[simp]
theorem toLex_le_toLex [LE α] [LE β] {a b : α ⊕ β} :
    toLex a ≤ toLex b ↔ Lex (· ≤ ·) (· ≤ ·) a b 
goal: toLex a ≤ toLex b ↔ Sum.Lex (fun x x_1 => x ≤ x_1) (fun x x_1 => x ≤ x_1) a b

full_name: Sum.Lex.toLex_lt_toLex
code: @[simp]
theorem toLex_lt_toLex [LT α] [LT β] {a b : α ⊕ β} :
    toLex a < toLex b ↔ Lex (· < ·) (· < ·) a b 
goal: toLex a < toLex b ↔ Sum.Lex (fun x x_1 => x < x_1) (fun x x_1 => x < x_1) a b

full_name: Sum.Lex.le_def
code: theorem le_def [LE α] [LE β] {a b : α ⊕ₗ β} : a ≤ b ↔ Lex (· ≤ ·) (· ≤ ·) (ofLex a) (ofLex b) 
goal: a ≤ b ↔ Sum.Lex (fun x x_1 => x ≤ x_1) (fun x x_1 => x ≤ x_1) (ofLex a) (ofLex b)

full_name: Sum.Lex.lt_def
code: theorem lt_def [LT α] [LT β] {a b : α ⊕ₗ β} : a < b ↔ Lex (· < ·) (· < ·) (ofLex a) (ofLex b) 
goal: a < b ↔ Sum.Lex (fun x x_1 => x < x_1) (fun x x_1 => x < x_1) (ofLex a) (ofLex b)

full_name: Sum.Lex.inl_le_inl_iff
code: theorem inl_le_inl_iff [LE α] [LE β] {a b : α} : toLex (inl a : α ⊕ β) ≤ toLex (inl b) ↔ a ≤ b 
goal: toLex (Sum.inl a) ≤ toLex (Sum.inl b) ↔ a ≤ b

full_name: Sum.Lex.inr_le_inr_iff
code: theorem inr_le_inr_iff [LE α] [LE β] {a b : β} : toLex (inr a : α ⊕ β) ≤ toLex (inr b) ↔ a ≤ b 
goal: toLex (Sum.inr a) ≤ toLex (Sum.inr b) ↔ a ≤ b

full_name: Sum.Lex.inl_lt_inl_iff
code: theorem inl_lt_inl_iff [LT α] [LT β] {a b : α} : toLex (inl a : α ⊕ β) < toLex (inl b) ↔ a < b 
goal: toLex (Sum.inl a) < toLex (Sum.inl b) ↔ a < b

full_name: Sum.Lex.inr_lt_inr_iff
code: theorem inr_lt_inr_iff [LT α] [LT β] {a b : β} : toLex (inr a : α ⊕ₗ β) < toLex (inr b) ↔ a < b 
goal: toLex (Sum.inr a) < toLex (Sum.inr b) ↔ a < b

full_name: Sum.Lex.inl_le_inr
code: theorem inl_le_inr [LE α] [LE β] (a : α) (b : β) : toLex (inl a) ≤ toLex (inr b) 
goal: toLex (Sum.inl a) ≤ toLex (Sum.inr b)

full_name: Sum.Lex.inl_lt_inr
code: theorem inl_lt_inr [LT α] [LT β] (a : α) (b : β) : toLex (inl a) < toLex (inr b) 
goal: toLex (Sum.inl a) < toLex (Sum.inr b)

full_name: Sum.Lex.not_inr_le_inl
code: theorem not_inr_le_inl [LE α] [LE β] {a : α} {b : β} : ¬toLex (inr b) ≤ toLex (inl a) 
goal: ¬toLex (Sum.inr b) ≤ toLex (Sum.inl a)

full_name: Sum.Lex.not_inr_lt_inl
code: theorem not_inr_lt_inl [LT α] [LT β] {a : α} {b : β} : ¬toLex (inr b) < toLex (inl a) 
goal: ¬toLex (Sum.inr b) < toLex (Sum.inl a)

full_name: Sum.Lex.preorder
code: instance preorder : Preorder (α ⊕ₗ β) 
goal: Preorder (Lex (α ⊕ β))

full_name: Sum.Lex.toLex_mono
code: theorem toLex_mono : Monotone (@toLex (α ⊕ β)) 
goal: Monotone ⇑toLex

full_name: Sum.Lex.toLex_strictMono
code: theorem toLex_strictMono : StrictMono (@toLex (α ⊕ β)) 
goal: StrictMono ⇑toLex

full_name: Sum.Lex.inl_mono
code: theorem inl_mono : Monotone (toLex ∘ inl : α → α ⊕ₗ β) 
goal: Monotone (⇑toLex ∘ Sum.inl)

full_name: Sum.Lex.inr_mono
code: theorem inr_mono : Monotone (toLex ∘ inr : β → α ⊕ₗ β) 
goal: Monotone (⇑toLex ∘ Sum.inr)

full_name: Sum.Lex.inl_strictMono
code: theorem inl_strictMono : StrictMono (toLex ∘ inl : α → α ⊕ₗ β) 
goal: StrictMono (⇑toLex ∘ Sum.inl)

full_name: Sum.Lex.inr_strictMono
code: theorem inr_strictMono : StrictMono (toLex ∘ inr : β → α ⊕ₗ β) 
goal: StrictMono (⇑toLex ∘ Sum.inr)

full_name: Sum.Lex.partialOrder
code: instance partialOrder [PartialOrder α] [PartialOrder β] : PartialOrder (α ⊕ₗ β) 
goal: PartialOrder (Lex (α ⊕ β))

full_name: Sum.Lex.linearOrder
code: instance linearOrder [LinearOrder α] [LinearOrder β] : LinearOrder (α ⊕ₗ β) 
goal: LinearOrder (Lex (α ⊕ β))

full_name: Sum.Lex.orderBot
code: /-- The lexicographical bottom of a sum is the bottom of the left component. -/
instance orderBot [LE α] [OrderBot α] [LE β] :
    OrderBot (α ⊕ₗ β) 
goal: OrderBot (Lex (α ⊕ β))

full_name: Sum.Lex.inl_bot
code: @[simp]
theorem inl_bot [LE α] [OrderBot α] [LE β] : toLex (inl ⊥ : α ⊕ β) = ⊥ 
goal: toLex (Sum.inl ⊥) = ⊥

full_name: Sum.Lex.orderTop
code: /-- The lexicographical top of a sum is the top of the right component. -/
instance orderTop [LE α] [LE β] [OrderTop β] :
    OrderTop (α ⊕ₗ β) 
goal: OrderTop (Lex (α ⊕ β))

full_name: Sum.Lex.inr_top
code: @[simp]
theorem inr_top [LE α] [LE β] [OrderTop β] : toLex (inr ⊤ : α ⊕ β) = ⊤ 
goal: toLex (Sum.inr ⊤) = ⊤

full_name: Sum.Lex.boundedOrder
code: instance boundedOrder [LE α] [LE β] [OrderBot α] [OrderTop β] : BoundedOrder (α ⊕ₗ β) 
goal: BoundedOrder (Lex (α ⊕ β))

full_name: Sum.Lex.noMinOrder
code: instance noMinOrder [LT α] [LT β] [NoMinOrder α] [NoMinOrder β] : NoMinOrder (α ⊕ₗ β) 
goal: NoMinOrder (Lex (α ⊕ β))

full_name: Sum.Lex.noMaxOrder
code: instance noMaxOrder [LT α] [LT β] [NoMaxOrder α] [NoMaxOrder β] : NoMaxOrder (α ⊕ₗ β) 
goal: NoMaxOrder (Lex (α ⊕ β))

full_name: Sum.Lex.noMinOrder_of_nonempty
code: instance noMinOrder_of_nonempty [LT α] [LT β] [NoMinOrder α] [Nonempty α] : NoMinOrder (α ⊕ₗ β) 
goal: NoMinOrder (Lex (α ⊕ β))

full_name: Sum.Lex.noMaxOrder_of_nonempty
code: instance noMaxOrder_of_nonempty [LT α] [LT β] [NoMaxOrder β] [Nonempty β] : NoMaxOrder (α ⊕ₗ β) 
goal: NoMaxOrder (Lex (α ⊕ β))

full_name: Sum.Lex.denselyOrdered_of_noMaxOrder
code: instance denselyOrdered_of_noMaxOrder [LT α] [LT β] [DenselyOrdered α] [DenselyOrdered β]
    [NoMaxOrder α] : DenselyOrdered (α ⊕ₗ β) 
goal: DenselyOrdered (Lex (α ⊕ β))

full_name: Sum.Lex.denselyOrdered_of_noMinOrder
code: instance denselyOrdered_of_noMinOrder [LT α] [LT β] [DenselyOrdered α] [DenselyOrdered β]
    [NoMinOrder β] : DenselyOrdered (α ⊕ₗ β) 
goal: DenselyOrdered (Lex (α ⊕ β))

full_name: OrderIso.sumComm_apply
code: /-- `Equiv.sumComm` promoted to an order isomorphism. -/
@[simps! apply]
def sumComm (α β : Type*) [LE α] [LE β] : α ⊕ β ≃o β ⊕ α 
goal: ∀ (a : α ⊕ β), (OrderIso.sumComm α β) a = a.swap

full_name: OrderIso.sumComm
code: /-- `Equiv.sumComm` promoted to an order isomorphism. -/
@[simps! apply]
def sumComm (α β : Type*) [LE α] [LE β] : α ⊕ β ≃o β ⊕ α 
goal: α ⊕ β ≃o β ⊕ α

full_name: OrderIso.sumComm_symm
code: @[simp]
theorem sumComm_symm (α β : Type*) [LE α] [LE β] :
    (OrderIso.sumComm α β).symm = OrderIso.sumComm β α 
goal: (OrderIso.sumComm α β).symm = OrderIso.sumComm β α

full_name: OrderIso.sumAssoc
code: /-- `Equiv.sumAssoc` promoted to an order isomorphism. -/
def sumAssoc (α β γ : Type*) [LE α] [LE β] [LE γ] : (α ⊕ β) ⊕ γ ≃o α ⊕ (β ⊕ γ) 
goal: (α ⊕ β) ⊕ γ ≃o α ⊕ β ⊕ γ

full_name: OrderIso.sumAssoc_apply_inl_inl
code: @[simp]
theorem sumAssoc_apply_inl_inl : sumAssoc α β γ (inl (inl a)) = inl a 
goal: (OrderIso.sumAssoc α β γ) (Sum.inl (Sum.inl a)) = Sum.inl a

full_name: OrderIso.sumAssoc_apply_inl_inr
code: @[simp]
theorem sumAssoc_apply_inl_inr : sumAssoc α β γ (inl (inr b)) = inr (inl b) 
goal: (OrderIso.sumAssoc α β γ) (Sum.inl (Sum.inr b)) = Sum.inr (Sum.inl b)

full_name: OrderIso.sumAssoc_apply_inr
code: @[simp]
theorem sumAssoc_apply_inr : sumAssoc α β γ (inr c) = inr (inr c) 
goal: (OrderIso.sumAssoc α β γ) (Sum.inr c) = Sum.inr (Sum.inr c)

full_name: OrderIso.sumAssoc_symm_apply_inl
code: @[simp]
theorem sumAssoc_symm_apply_inl : (sumAssoc α β γ).symm (inl a) = inl (inl a) 
goal: (OrderIso.sumAssoc α β γ).symm (Sum.inl a) = Sum.inl (Sum.inl a)

full_name: OrderIso.sumAssoc_symm_apply_inr_inl
code: @[simp]
theorem sumAssoc_symm_apply_inr_inl : (sumAssoc α β γ).symm (inr (inl b)) = inl (inr b) 
goal: (OrderIso.sumAssoc α β γ).symm (Sum.inr (Sum.inl b)) = Sum.inl (Sum.inr b)

full_name: OrderIso.sumAssoc_symm_apply_inr_inr
code: @[simp]
theorem sumAssoc_symm_apply_inr_inr : (sumAssoc α β γ).symm (inr (inr c)) = inr c 
goal: (OrderIso.sumAssoc α β γ).symm (Sum.inr (Sum.inr c)) = Sum.inr c

full_name: OrderIso.sumDualDistrib
code: /-- `orderDual` is distributive over `⊕` up to an order isomorphism. -/
def sumDualDistrib (α β : Type*) [LE α] [LE β] : (α ⊕ β)ᵒᵈ ≃o αᵒᵈ ⊕ βᵒᵈ 
goal: (α ⊕ β)ᵒᵈ ≃o αᵒᵈ ⊕ βᵒᵈ

full_name: OrderIso.sumDualDistrib_inl
code: @[simp]
theorem sumDualDistrib_inl : sumDualDistrib α β (toDual (inl a)) = inl (toDual a) 
goal: (OrderIso.sumDualDistrib α β) (OrderDual.toDual (Sum.inl a)) = Sum.inl (OrderDual.toDual a)

full_name: OrderIso.sumDualDistrib_inr
code: @[simp]
theorem sumDualDistrib_inr : sumDualDistrib α β (toDual (inr b)) = inr (toDual b) 
goal: (OrderIso.sumDualDistrib α β) (OrderDual.toDual (Sum.inr b)) = Sum.inr (OrderDual.toDual b)

full_name: OrderIso.sumDualDistrib_symm_inl
code: @[simp]
theorem sumDualDistrib_symm_inl : (sumDualDistrib α β).symm (inl (toDual a)) = toDual (inl a) 
goal: (OrderIso.sumDualDistrib α β).symm (Sum.inl (OrderDual.toDual a)) = OrderDual.toDual (Sum.inl a)

full_name: OrderIso.sumDualDistrib_symm_inr
code: @[simp]
theorem sumDualDistrib_symm_inr : (sumDualDistrib α β).symm (inr (toDual b)) = toDual (inr b) 
goal: (OrderIso.sumDualDistrib α β).symm (Sum.inr (OrderDual.toDual b)) = OrderDual.toDual (Sum.inr b)

full_name: OrderIso.sumLexAssoc
code: /-- `Equiv.SumAssoc` promoted to an order isomorphism. -/
def sumLexAssoc (α β γ : Type*) [LE α] [LE β] [LE γ] : (α ⊕ₗ β) ⊕ₗ γ ≃o α ⊕ₗ β ⊕ₗ γ 
goal: Lex (Lex (α ⊕ β) ⊕ γ) ≃o Lex (α ⊕ Lex (β ⊕ γ))

full_name: OrderIso.sumLexAssoc_apply_inl_inl
code: @[simp]
theorem sumLexAssoc_apply_inl_inl :
    sumLexAssoc α β γ (toLex <| inl <| toLex <| inl a) = toLex (inl a) 
goal: (OrderIso.sumLexAssoc α β γ) (toLex (Sum.inl (toLex (Sum.inl a)))) = toLex (Sum.inl a)

full_name: OrderIso.sumLexAssoc_apply_inl_inr
code: @[simp]
theorem sumLexAssoc_apply_inl_inr :
    sumLexAssoc α β γ (toLex <| inl <| toLex <| inr b) = toLex (inr <| toLex <| inl b) 
goal: (OrderIso.sumLexAssoc α β γ) (toLex (Sum.inl (toLex (Sum.inr b)))) = toLex (Sum.inr (toLex (Sum.inl b)))

full_name: OrderIso.sumLexAssoc_apply_inr
code: @[simp]
theorem sumLexAssoc_apply_inr :
    sumLexAssoc α β γ (toLex <| inr c) = toLex (inr <| toLex <| inr c) 
goal: (OrderIso.sumLexAssoc α β γ) (toLex (Sum.inr c)) = toLex (Sum.inr (toLex (Sum.inr c)))

full_name: OrderIso.sumLexAssoc_symm_apply_inl
code: @[simp]
theorem sumLexAssoc_symm_apply_inl : (sumLexAssoc α β γ).symm (inl a) = inl (inl a) 
goal: (OrderIso.sumLexAssoc α β γ).symm (Sum.inl a) = Sum.inl (Sum.inl a)

full_name: OrderIso.sumLexAssoc_symm_apply_inr_inl
code: @[simp]
theorem sumLexAssoc_symm_apply_inr_inl : (sumLexAssoc α β γ).symm (inr (inl b)) = inl (inr b) 
goal: (OrderIso.sumLexAssoc α β γ).symm (Sum.inr (Sum.inl b)) = Sum.inl (Sum.inr b)

full_name: OrderIso.sumLexAssoc_symm_apply_inr_inr
code: @[simp]
theorem sumLexAssoc_symm_apply_inr_inr : (sumLexAssoc α β γ).symm (inr (inr c)) = inr c 
goal: (OrderIso.sumLexAssoc α β γ).symm (Sum.inr (Sum.inr c)) = Sum.inr c

full_name: OrderIso.sumLexDualAntidistrib
code: /-- `OrderDual` is antidistributive over `⊕ₗ` up to an order isomorphism. -/
def sumLexDualAntidistrib (α β : Type*) [LE α] [LE β] : (α ⊕ₗ β)ᵒᵈ ≃o βᵒᵈ ⊕ₗ αᵒᵈ 
goal: (Lex (α ⊕ β))ᵒᵈ ≃o Lex (βᵒᵈ ⊕ αᵒᵈ)

full_name: OrderIso.sumLexDualAntidistrib_inl
code: @[simp]
theorem sumLexDualAntidistrib_inl :
    sumLexDualAntidistrib α β (toDual (inl a)) = inr (toDual a) 
goal: (OrderIso.sumLexDualAntidistrib α β) (OrderDual.toDual (Sum.inl a)) = Sum.inr (OrderDual.toDual a)

full_name: OrderIso.sumLexDualAntidistrib_inr
code: @[simp]
theorem sumLexDualAntidistrib_inr :
    sumLexDualAntidistrib α β (toDual (inr b)) = inl (toDual b) 
goal: (OrderIso.sumLexDualAntidistrib α β) (OrderDual.toDual (Sum.inr b)) = Sum.inl (OrderDual.toDual b)

full_name: OrderIso.sumLexDualAntidistrib_symm_inl
code: @[simp]
theorem sumLexDualAntidistrib_symm_inl :
    (sumLexDualAntidistrib α β).symm (inl (toDual b)) = toDual (inr b) 
goal: (OrderIso.sumLexDualAntidistrib α β).symm (Sum.inl (OrderDual.toDual b)) = OrderDual.toDual (Sum.inr b)

full_name: OrderIso.sumLexDualAntidistrib_symm_inr
code: @[simp]
theorem sumLexDualAntidistrib_symm_inr :
    (sumLexDualAntidistrib α β).symm (inr (toDual a)) = toDual (inl a) 
goal: (OrderIso.sumLexDualAntidistrib α β).symm (Sum.inr (OrderDual.toDual a)) = OrderDual.toDual (Sum.inl a)

full_name: WithBot.orderIsoPUnitSumLex
code: /-- `WithBot α` is order-isomorphic to `PUnit ⊕ₗ α`, by sending `⊥` to `Unit` and `↑a` to
`a`. -/
def orderIsoPUnitSumLex : WithBot α ≃o PUnit ⊕ₗ α 
goal: WithBot α ≃o Lex (PUnit.{u_5 + 1} ⊕ α)

full_name: WithBot.orderIsoPUnitSumLex_bot
code: @[simp]
theorem orderIsoPUnitSumLex_bot : @orderIsoPUnitSumLex α _ ⊥ = toLex (inl PUnit.unit) 
goal: WithBot.orderIsoPUnitSumLex ⊥ = toLex (Sum.inl PUnit.unit)

full_name: WithBot.orderIsoPUnitSumLex_toLex
code: @[simp]
theorem orderIsoPUnitSumLex_toLex (a : α) : orderIsoPUnitSumLex ↑a = toLex (inr a) 
goal: WithBot.orderIsoPUnitSumLex ↑a = toLex (Sum.inr a)

full_name: WithBot.orderIsoPUnitSumLex_symm_inl
code: @[simp]
theorem orderIsoPUnitSumLex_symm_inl (x : PUnit) :
    (@orderIsoPUnitSumLex α _).symm (toLex <| inl x) = ⊥ 
goal: WithBot.orderIsoPUnitSumLex.symm (toLex (Sum.inl x)) = ⊥

full_name: WithBot.orderIsoPUnitSumLex_symm_inr
code: @[simp]
theorem orderIsoPUnitSumLex_symm_inr (a : α) : orderIsoPUnitSumLex.symm (toLex <| inr a) = a 
goal: WithBot.orderIsoPUnitSumLex.symm (toLex (Sum.inr a)) = ↑a

full_name: WithTop.orderIsoSumLexPUnit
code: /-- `WithTop α` is order-isomorphic to `α ⊕ₗ PUnit`, by sending `⊤` to `Unit` and `↑a` to
`a`. -/
def orderIsoSumLexPUnit : WithTop α ≃o α ⊕ₗ PUnit 
goal: WithTop α ≃o Lex (α ⊕ PUnit.{u_5 + 1})

full_name: WithTop.orderIsoSumLexPUnit_top
code: @[simp]
theorem orderIsoSumLexPUnit_top : @orderIsoSumLexPUnit α _ ⊤ = toLex (inr PUnit.unit) 
goal: WithTop.orderIsoSumLexPUnit ⊤ = toLex (Sum.inr PUnit.unit)

full_name: WithTop.orderIsoSumLexPUnit_toLex
code: @[simp]
theorem orderIsoSumLexPUnit_toLex (a : α) : orderIsoSumLexPUnit ↑a = toLex (inl a) 
goal: WithTop.orderIsoSumLexPUnit ↑a = toLex (Sum.inl a)

full_name: WithTop.orderIsoSumLexPUnit_symm_inr
code: @[simp]
theorem orderIsoSumLexPUnit_symm_inr (x : PUnit) :
    (@orderIsoSumLexPUnit α _).symm (toLex <| inr x) = ⊤ 
goal: WithTop.orderIsoSumLexPUnit.symm (toLex (Sum.inr x)) = ⊤

full_name: WithTop.orderIsoSumLexPUnit_symm_inl
code: @[simp]
theorem orderIsoSumLexPUnit_symm_inl (a : α) : orderIsoSumLexPUnit.symm (toLex <| inl a) = a 
goal: WithTop.orderIsoSumLexPUnit.symm (toLex (Sum.inl a)) = ↑a