File: Mathlib/Data/Prod/Lex.lean

full_name: Prod.Lex._aux_Mathlib_Data_Prod_Lex___unexpand_Lex_1
code: @[inherit_doc] notation:35 α " ×ₗ " β:34 => Lex (Prod α β)
goal: Lean.PrettyPrinter.Unexpander

full_name: Prod.Lex.«_aux_Mathlib_Data_Prod_Lex___macroRules_Prod_Lex_term_×ₗ__1»
code: @[inherit_doc] notation:35 α " ×ₗ " β:34 => Lex (Prod α β)
goal: Lean.Macro

full_name: Prod.Lex.decidableEq
code: instance decidableEq (α β : Type*) [DecidableEq α] [DecidableEq β] : DecidableEq (α ×ₗ β) 
goal: DecidableEq (Lex (α × β))

full_name: Prod.Lex.inhabited
code: instance inhabited (α β : Type*) [Inhabited α] [Inhabited β] : Inhabited (α ×ₗ β) 
goal: Inhabited (Lex (α × β))

full_name: Prod.Lex.instLE
code: /-- Dictionary / lexicographic ordering on pairs.  -/
instance instLE (α β : Type*) [LT α] [LE β] : LE (α ×ₗ β) 
goal: LE (Lex (α × β))

full_name: Prod.Lex.instLT
code: instance instLT (α β : Type*) [LT α] [LT β] : LT (α ×ₗ β) 
goal: LT (Lex (α × β))

full_name: Prod.Lex.le_iff
code: theorem le_iff [LT α] [LE β] (a b : α × β) :
    toLex a ≤ toLex b ↔ a.1 < b.1 ∨ a.1 = b.1 ∧ a.2 ≤ b.2 
goal: toLex a ≤ toLex b ↔ a.1 < b.1 ∨ a.1 = b.1 ∧ a.2 ≤ b.2

full_name: Prod.Lex.lt_iff
code: theorem lt_iff [LT α] [LT β] (a b : α × β) :
    toLex a < toLex b ↔ a.1 < b.1 ∨ a.1 = b.1 ∧ a.2 < b.2 
goal: toLex a < toLex b ↔ a.1 < b.1 ∨ a.1 = b.1 ∧ a.2 < b.2

full_name: Prod.Lex.preorder
code: /-- Dictionary / lexicographic preorder for pairs. -/
instance preorder (α β : Type*) [Preorder α] [Preorder β] : Preorder (α ×ₗ β) 
goal: Preorder (Lex (α × β))

full_name: Prod.Lex.monotone_fst
code: theorem monotone_fst [Preorder α] [LE β] (t c : α ×ₗ β) (h : t ≤ c) :
    (ofLex t).1 ≤ (ofLex c).1 
goal: (ofLex t).1 ≤ (ofLex c).1

full_name: Prod.Lex.toLex_mono
code: theorem toLex_mono : Monotone (toLex : α × β → α ×ₗ β) 
goal: Monotone ⇑toLex

full_name: Prod.Lex.toLex_strictMono
code: theorem toLex_strictMono : StrictMono (toLex : α × β → α ×ₗ β) 
goal: StrictMono ⇑toLex

full_name: Prod.Lex.partialOrder
code: /-- Dictionary / lexicographic partial order for pairs. -/
instance partialOrder (α β : Type*) [PartialOrder α] [PartialOrder β] : PartialOrder (α ×ₗ β) 
goal: PartialOrder (Lex (α × β))

full_name: Prod.Lex.linearOrder
code: /-- Dictionary / lexicographic linear order for pairs. -/
instance linearOrder (α β : Type*) [LinearOrder α] [LinearOrder β] : LinearOrder (α ×ₗ β) 
goal: LinearOrder (Lex (α × β))

full_name: Prod.Lex.instOrdLex
code: instance [Ord α] [Ord β] : Ord (α ×ₗ β) 
goal: Ord (Lex (α × β))

full_name: Prod.Lex.orderBot
code: instance orderBot [PartialOrder α] [Preorder β] [OrderBot α] [OrderBot β] : OrderBot (α ×ₗ β) 
goal: OrderBot (Lex (α × β))

full_name: Prod.Lex.orderTop
code: instance orderTop [PartialOrder α] [Preorder β] [OrderTop α] [OrderTop β] : OrderTop (α ×ₗ β) 
goal: OrderTop (Lex (α × β))

full_name: Prod.Lex.boundedOrder
code: instance boundedOrder [PartialOrder α] [Preorder β] [BoundedOrder α] [BoundedOrder β] :
    BoundedOrder (α ×ₗ β) 
goal: BoundedOrder (Lex (α × β))

full_name: Prod.Lex.instDenselyOrderedLex
code: instance [Preorder α] [Preorder β] [DenselyOrdered α] [DenselyOrdered β] :
    DenselyOrdered (α ×ₗ β) 
goal: DenselyOrdered (Lex (α × β))

full_name: Prod.Lex.noMaxOrder_of_left
code: instance noMaxOrder_of_left [Preorder α] [Preorder β] [NoMaxOrder α] : NoMaxOrder (α ×ₗ β) 
goal: NoMaxOrder (Lex (α × β))

full_name: Prod.Lex.noMinOrder_of_left
code: instance noMinOrder_of_left [Preorder α] [Preorder β] [NoMinOrder α] : NoMinOrder (α ×ₗ β) 
goal: NoMinOrder (Lex (α × β))

full_name: Prod.Lex.noMaxOrder_of_right
code: instance noMaxOrder_of_right [Preorder α] [Preorder β] [NoMaxOrder β] : NoMaxOrder (α ×ₗ β) 
goal: NoMaxOrder (Lex (α × β))

full_name: Prod.Lex.noMinOrder_of_right
code: instance noMinOrder_of_right [Preorder α] [Preorder β] [NoMinOrder β] : NoMinOrder (α ×ₗ β) 
goal: NoMinOrder (Lex (α × β))