File: Mathlib/Data/Sigma/Order.lean

full_name: Sigma.le
code: /-- Disjoint sum of orders. `⟨i, a⟩ ≤ ⟨j, b⟩` iff `i = j` and `a ≤ b`. -/
protected inductive le [∀ i, LE (α i)] : ∀ _a _b : Σ i, α i, Prop
  | fiber (i : ι) (a b : α i) : a ≤ b → Sigma.le ⟨i, a⟩ ⟨i, b⟩
goal: Prop

full_name: Sigma.le.fiber
code: /-- Disjoint sum of orders. `⟨i, a⟩ ≤ ⟨j, b⟩` iff `i = j` and `a ≤ b`. -/
protected inductive le [∀ i, LE (α i)] : ∀ _a _b : Σ i, α i, Prop
  | fiber (i : ι) (a b : α i) : a ≤ b → Sigma.le ⟨i, a⟩ ⟨i, b⟩
goal: a ≤ b → ⟨i, a⟩.le ⟨i, b⟩

full_name: Sigma.lt.fiber
code: /-- Disjoint sum of orders. `⟨i, a⟩ < ⟨j, b⟩` iff `i = j` and `a < b`. -/
protected inductive lt [∀ i, LT (α i)] : ∀ _a _b : Σi, α i, Prop
  | fiber (i : ι) (a b : α i) : a < b → Sigma.lt ⟨i, a⟩ ⟨i, b⟩
goal: a < b → ⟨i, a⟩.lt ⟨i, b⟩

full_name: Sigma.lt
code: /-- Disjoint sum of orders. `⟨i, a⟩ < ⟨j, b⟩` iff `i = j` and `a < b`. -/
protected inductive lt [∀ i, LT (α i)] : ∀ _a _b : Σi, α i, Prop
  | fiber (i : ι) (a b : α i) : a < b → Sigma.lt ⟨i, a⟩ ⟨i, b⟩
goal: Prop

full_name: Sigma.LE
code: protected instance LE [∀ i, LE (α i)] : LE (Σi, α i) 
goal: LE ((i : ι) × α i)

full_name: Sigma.LT
code: protected instance LT [∀ i, LT (α i)] : LT (Σi, α i) 
goal: LT ((i : ι) × α i)

full_name: Sigma.mk_le_mk_iff
code: @[simp]
theorem mk_le_mk_iff [∀ i, LE (α i)] {i : ι} {a b : α i} : (⟨i, a⟩ : Sigma α) ≤ ⟨i, b⟩ ↔ a ≤ b 
goal: ⟨i, a⟩ ≤ ⟨i, b⟩ ↔ a ≤ b

full_name: Sigma.mk_lt_mk_iff
code: @[simp]
theorem mk_lt_mk_iff [∀ i, LT (α i)] {i : ι} {a b : α i} : (⟨i, a⟩ : Sigma α) < ⟨i, b⟩ ↔ a < b 
goal: ⟨i, a⟩ < ⟨i, b⟩ ↔ a < b

full_name: Sigma.le_def
code: theorem le_def [∀ i, LE (α i)] {a b : Σi, α i} : a ≤ b ↔ ∃ h : a.1 = b.1, h.rec a.2 ≤ b.2 
goal: a ≤ b ↔ ∃ h, h ▸ a.snd ≤ b.snd

full_name: Sigma.lt_def
code: theorem lt_def [∀ i, LT (α i)] {a b : Σi, α i} : a < b ↔ ∃ h : a.1 = b.1, h.rec a.2 < b.2 
goal: a < b ↔ ∃ h, h ▸ a.snd < b.snd

full_name: Sigma.preorder
code: protected instance preorder [∀ i, Preorder (α i)] : Preorder (Σi, α i) 
goal: Preorder ((i : ι) × α i)

full_name: Sigma.instPartialOrder
code: instance [∀ i, PartialOrder (α i)] : PartialOrder (Σi, α i) 
goal: PartialOrder ((i : ι) × α i)

full_name: Sigma.instDenselyOrdered
code: instance [∀ i, Preorder (α i)] [∀ i, DenselyOrdered (α i)] : DenselyOrdered (Σi, α i) 
goal: DenselyOrdered ((i : ι) × α i)

full_name: Sigma.Lex.«_aux_Mathlib_Data_Sigma_Order___macroRules_Sigma_Lex_termΣₗ_,__1»
code: /-- The notation `Σₗ i, α i` refers to a sigma type equipped with the lexicographic order. -/
notation3 "Σₗ "(...)", "r:(scoped p => _root_.Lex (Sigma p)) => r
goal: Lean.Macro

full_name: Sigma.Lex.LE
code: /-- The lexicographical `≤` on a sigma type. -/
protected instance LE [LT ι] [∀ i, LE (α i)] : LE (Σₗ i, α i) 
goal: LE (Σₗ (i : ι), α i)

full_name: Sigma.Lex.LT
code: /-- The lexicographical `<` on a sigma type. -/
protected instance LT [LT ι] [∀ i, LT (α i)] : LT (Σₗ i, α i) 
goal: LT (Σₗ (i : ι), α i)

full_name: Sigma.Lex.le_def
code: theorem le_def [LT ι] [∀ i, LE (α i)] {a b : Σₗ i, α i} :
    a ≤ b ↔ a.1 < b.1 ∨ ∃ h : a.1 = b.1, h.rec a.2 ≤ b.2 
goal: a ≤ b ↔ a.fst < b.fst ∨ ∃ h, h ▸ a.snd ≤ b.snd

full_name: Sigma.Lex.lt_def
code: theorem lt_def [LT ι] [∀ i, LT (α i)] {a b : Σₗ i, α i} :
    a < b ↔ a.1 < b.1 ∨ ∃ h : a.1 = b.1, h.rec a.2 < b.2 
goal: a < b ↔ a.fst < b.fst ∨ ∃ h, h ▸ a.snd < b.snd

full_name: Sigma.Lex.preorder
code: /-- The lexicographical preorder on a sigma type. -/
instance preorder [Preorder ι] [∀ i, Preorder (α i)] : Preorder (Σₗ i, α i) 
goal: Preorder (Σₗ (i : ι), α i)

full_name: Sigma.Lex.partialOrder
code: /-- The lexicographical partial order on a sigma type. -/
instance partialOrder [Preorder ι] [∀ i, PartialOrder (α i)] :
    PartialOrder (Σₗ i, α i) 
goal: PartialOrder (Σₗ (i : ι), α i)

full_name: Sigma.Lex.linearOrder
code: /-- The lexicographical linear order on a sigma type. -/
instance linearOrder [LinearOrder ι] [∀ i, LinearOrder (α i)] :
    LinearOrder (Σₗ i, α i) 
goal: LinearOrder (Σₗ (i : ι), α i)

full_name: Sigma.Lex.orderBot
code: /-- The lexicographical linear order on a sigma type. -/
instance orderBot [PartialOrder ι] [OrderBot ι] [∀ i, Preorder (α i)] [OrderBot (α ⊥)] :
    OrderBot (Σₗ i, α i) 
goal: OrderBot (Σₗ (i : ι), α i)

full_name: Sigma.Lex.orderTop
code: /-- The lexicographical linear order on a sigma type. -/
instance orderTop [PartialOrder ι] [OrderTop ι] [∀ i, Preorder (α i)] [OrderTop (α ⊤)] :
    OrderTop (Σₗ i, α i) 
goal: OrderTop (Σₗ (i : ι), α i)

full_name: Sigma.Lex.boundedOrder
code: /-- The lexicographical linear order on a sigma type. -/
instance boundedOrder [PartialOrder ι] [BoundedOrder ι] [∀ i, Preorder (α i)] [OrderBot (α ⊥)]
    [OrderTop (α ⊤)] : BoundedOrder (Σₗ i, α i) 
goal: BoundedOrder (Σₗ (i : ι), α i)

full_name: Sigma.Lex.denselyOrdered
code: instance denselyOrdered [Preorder ι] [DenselyOrdered ι] [∀ i, Nonempty (α i)] [∀ i, Preorder (α i)]
    [∀ i, DenselyOrdered (α i)] : DenselyOrdered (Σₗ i, α i) 
goal: DenselyOrdered (Σₗ (i : ι), α i)

full_name: Sigma.Lex.denselyOrdered_of_noMaxOrder
code: instance denselyOrdered_of_noMaxOrder [Preorder ι] [∀ i, Preorder (α i)]
    [∀ i, DenselyOrdered (α i)] [∀ i, NoMaxOrder (α i)] :
    DenselyOrdered (Σₗ i, α i) 
goal: DenselyOrdered (Σₗ (i : ι), α i)

full_name: Sigma.Lex.denselyOrdered_of_noMinOrder
code: instance denselyOrdered_of_noMinOrder [Preorder ι] [∀ i, Preorder (α i)]
    [∀ i, DenselyOrdered (α i)] [∀ i, NoMinOrder (α i)] :
    DenselyOrdered (Σₗ i, α i) 
goal: DenselyOrdered (Σₗ (i : ι), α i)

full_name: Sigma.Lex.noMaxOrder_of_nonempty
code: instance noMaxOrder_of_nonempty [Preorder ι] [∀ i, Preorder (α i)] [NoMaxOrder ι]
    [∀ i, Nonempty (α i)] : NoMaxOrder (Σₗ i, α i) 
goal: NoMaxOrder (Σₗ (i : ι), α i)

full_name: Sigma.Lex.noMinOrder_of_nonempty
code: instance noMinOrder_of_nonempty [Preorder ι] [∀ i, Preorder (α i)] [NoMinOrder ι]
    [∀ i, Nonempty (α i)] : NoMinOrder (Σₗ i, α i) 
goal: NoMinOrder (Σₗ (i : ι), α i)

full_name: Sigma.Lex.noMaxOrder
code: instance noMaxOrder [Preorder ι] [∀ i, Preorder (α i)] [∀ i, NoMaxOrder (α i)] :
    NoMaxOrder (Σₗ i, α i) 
goal: NoMaxOrder (Σₗ (i : ι), α i)

full_name: Sigma.Lex.noMinOrder
code: instance noMinOrder [Preorder ι] [∀ i, Preorder (α i)] [∀ i, NoMinOrder (α i)] :
    NoMinOrder (Σₗ i, α i) 
goal: NoMinOrder (Σₗ (i : ι), α i)