File: Mathlib/Order/Basic.lean

full_name: le_trans'
code: theorem le_trans' : b ≤ c → a ≤ b → a ≤ c 
goal: b ≤ c → a ≤ b → a ≤ c

full_name: lt_trans'
code: theorem lt_trans' : b < c → a < b → a < c 
goal: b < c → a < b → a < c

full_name: lt_of_le_of_lt'
code: theorem lt_of_le_of_lt' : b ≤ c → a < b → a < c 
goal: b ≤ c → a < b → a < c

full_name: lt_of_lt_of_le'
code: theorem lt_of_lt_of_le' : b < c → a ≤ b → a < c 
goal: b < c → a ≤ b → a < c

full_name: ge_antisymm
code: theorem ge_antisymm : a ≤ b → b ≤ a → b = a 
goal: a ≤ b → b ≤ a → b = a

full_name: lt_of_le_of_ne'
code: theorem lt_of_le_of_ne' : a ≤ b → b ≠ a → a < b 
goal: a ≤ b → b ≠ a → a < b

full_name: Ne.lt_of_le
code: theorem Ne.lt_of_le : a ≠ b → a ≤ b → a < b 
goal: a ≠ b → a ≤ b → a < b

full_name: Ne.lt_of_le'
code: theorem Ne.lt_of_le' : b ≠ a → a ≤ b → a < b 
goal: b ≠ a → a ≤ b → a < b

full_name: lt_self_iff_false
code: @[simp]
theorem lt_self_iff_false (x : α) : x < x ↔ False 
goal: x < x ↔ False

full_name: le_of_le_of_eq'
code: theorem le_of_le_of_eq' : b ≤ c → a = b → a ≤ c 
goal: b ≤ c → a = b → a ≤ c

full_name: le_of_eq_of_le'
code: theorem le_of_eq_of_le' : b = c → a ≤ b → a ≤ c 
goal: b = c → a ≤ b → a ≤ c

full_name: lt_of_lt_of_eq'
code: theorem lt_of_lt_of_eq' : b < c → a = b → a < c 
goal: b < c → a = b → a < c

full_name: lt_of_eq_of_lt'
code: theorem lt_of_eq_of_lt' : b = c → a < b → a < c 
goal: b = c → a < b → a < c

full_name: Eq.ge
code: /-- If `x = y` then `y ≤ x`. Note: this lemma uses `y ≤ x` instead of `x ≥ y`, because `le` is used
almost exclusively in mathlib. -/
protected theorem ge (h : x = y) : y ≤ x 
goal: y ≤ x

full_name: Eq.not_lt
code: theorem not_lt (h : x = y) : ¬x < y 
goal: ¬x < y

full_name: Eq.not_gt
code: theorem not_gt (h : x = y) : ¬y < x 
goal: ¬y < x

full_name: le_of_subsingleton
code: @[simp] lemma le_of_subsingleton [Subsingleton α] : a ≤ b 
goal: a ≤ b

full_name: not_lt_of_subsingleton
code: lemma not_lt_of_subsingleton [Subsingleton α] : ¬a < b 
goal: ¬a < b

full_name: LE.le.ge
code: protected theorem ge [LE α] {x y : α} (h : x ≤ y) : y ≥ x 
goal: y ≥ x

full_name: LE.le.lt_iff_ne
code: theorem lt_iff_ne (h : a ≤ b) : a < b ↔ a ≠ b 
goal: a < b ↔ a ≠ b

full_name: LE.le.gt_iff_ne
code: theorem gt_iff_ne (h : a ≤ b) : a < b ↔ b ≠ a 
goal: a < b ↔ b ≠ a

full_name: LE.le.not_lt_iff_eq
code: theorem not_lt_iff_eq (h : a ≤ b) : ¬a < b ↔ a = b 
goal: ¬a < b ↔ a = b

full_name: LE.le.not_gt_iff_eq
code: theorem not_gt_iff_eq (h : a ≤ b) : ¬a < b ↔ b = a 
goal: ¬a < b ↔ b = a

full_name: LE.le.le_iff_eq
code: theorem le_iff_eq (h : a ≤ b) : b ≤ a ↔ b = a 
goal: b ≤ a ↔ b = a

full_name: LE.le.ge_iff_eq
code: theorem ge_iff_eq (h : a ≤ b) : b ≤ a ↔ a = b 
goal: b ≤ a ↔ a = b

full_name: LE.le.lt_or_le
code: theorem lt_or_le [LinearOrder α] {a b : α} (h : a ≤ b) (c : α) : a < c ∨ c ≤ b 
goal: a < c ∨ c ≤ b

full_name: LE.le.le_or_lt
code: theorem le_or_lt [LinearOrder α] {a b : α} (h : a ≤ b) (c : α) : a ≤ c ∨ c < b 
goal: a ≤ c ∨ c < b

full_name: LE.le.le_or_le
code: theorem le_or_le [LinearOrder α] {a b : α} (h : a ≤ b) (c : α) : a ≤ c ∨ c ≤ b 
goal: a ≤ c ∨ c ≤ b

full_name: LT.lt.gt
code: protected theorem gt [LT α] {x y : α} (h : x < y) : y > x 
goal: y > x

full_name: LT.lt.false
code: protected theorem false [Preorder α] {x : α} : x < x → False 
goal: x < x → False

full_name: LT.lt.ne'
code: theorem ne' [Preorder α] {x y : α} (h : x < y) : y ≠ x 
goal: y ≠ x

full_name: LT.lt.lt_or_lt
code: theorem lt_or_lt [LinearOrder α] {x y : α} (h : x < y) (z : α) : x < z ∨ z < y 
goal: x < z ∨ z < y

full_name: GE.ge.le
code: protected theorem GE.ge.le [LE α] {x y : α} (h : x ≥ y) : y ≤ x 
goal: y ≤ x

full_name: GT.gt.lt
code: protected theorem GT.gt.lt [LT α] {x y : α} (h : x > y) : y < x 
goal: y < x

full_name: ge_of_eq
code: theorem ge_of_eq [Preorder α] {a b : α} (h : a = b) : a ≥ b 
goal: a ≥ b

full_name: not_le_of_lt
code: theorem not_le_of_lt [Preorder α] {a b : α} (h : a < b) : ¬b ≤ a 
goal: ¬b ≤ a

full_name: not_lt_of_le
code: theorem not_lt_of_le [Preorder α] {a b : α} (h : a ≤ b) : ¬b < a 
goal: ¬b < a

full_name: ne_of_not_le
code: theorem ne_of_not_le [Preorder α] {a b : α} (h : ¬a ≤ b) : a ≠ b 
goal: a ≠ b

full_name: Decidable.le_iff_eq_or_lt
code: protected theorem Decidable.le_iff_eq_or_lt [PartialOrder α] [@DecidableRel α (· ≤ ·)] {a b : α} :
    a ≤ b ↔ a = b ∨ a < b 
goal: a ≤ b ↔ a = b ∨ a < b

full_name: le_iff_eq_or_lt
code: theorem le_iff_eq_or_lt [PartialOrder α] {a b : α} : a ≤ b ↔ a = b ∨ a < b 
goal: a ≤ b ↔ a = b ∨ a < b

full_name: lt_iff_le_and_ne
code: theorem lt_iff_le_and_ne [PartialOrder α] {a b : α} : a < b ↔ a ≤ b ∧ a ≠ b 
goal: a < b ↔ a ≤ b ∧ a ≠ b

full_name: eq_iff_not_lt_of_le
code: theorem eq_iff_not_lt_of_le [PartialOrder α] {x y : α} : x ≤ y → y = x ↔ ¬x < y 
goal: x ≤ y → y = x ↔ ¬x < y

full_name: Decidable.eq_iff_le_not_lt
code: protected theorem Decidable.eq_iff_le_not_lt [PartialOrder α] [@DecidableRel α (· ≤ ·)] {a b : α} :
    a = b ↔ a ≤ b ∧ ¬a < b 
goal: a = b ↔ a ≤ b ∧ ¬a < b

full_name: eq_iff_le_not_lt
code: theorem eq_iff_le_not_lt [PartialOrder α] {a b : α} : a = b ↔ a ≤ b ∧ ¬a < b 
goal: a = b ↔ a ≤ b ∧ ¬a < b

full_name: eq_or_lt_of_le
code: theorem eq_or_lt_of_le [PartialOrder α] {a b : α} (h : a ≤ b) : a = b ∨ a < b 
goal: a = b ∨ a < b

full_name: eq_or_gt_of_le
code: theorem eq_or_gt_of_le [PartialOrder α] {a b : α} (h : a ≤ b) : b = a ∨ a < b 
goal: b = a ∨ a < b

full_name: gt_or_eq_of_le
code: theorem gt_or_eq_of_le [PartialOrder α] {a b : α} (h : a ≤ b) : a < b ∨ b = a 
goal: a < b ∨ b = a

full_name: eq_of_le_of_not_lt
code: theorem eq_of_le_of_not_lt [PartialOrder α] {a b : α} (hab : a ≤ b) (hba : ¬a < b) : a = b 
goal: a = b

full_name: eq_of_ge_of_not_gt
code: theorem eq_of_ge_of_not_gt [PartialOrder α] {a b : α} (hab : a ≤ b) (hba : ¬a < b) : b = a 
goal: b = a

full_name: Ne.le_iff_lt
code: theorem Ne.le_iff_lt [PartialOrder α] {a b : α} (h : a ≠ b) : a ≤ b ↔ a < b 
goal: a ≤ b ↔ a < b

full_name: Ne.not_le_or_not_le
code: theorem Ne.not_le_or_not_le [PartialOrder α] {a b : α} (h : a ≠ b) : ¬a ≤ b ∨ ¬b ≤ a 
goal: ¬a ≤ b ∨ ¬b ≤ a

full_name: Decidable.ne_iff_lt_iff_le
code: protected theorem Decidable.ne_iff_lt_iff_le [PartialOrder α] [DecidableEq α] {a b : α} :
    (a ≠ b ↔ a < b) ↔ a ≤ b 
goal: (a ≠ b ↔ a < b) ↔ a ≤ b

full_name: ne_iff_lt_iff_le
code: @[simp]
theorem ne_iff_lt_iff_le [PartialOrder α] {a b : α} : (a ≠ b ↔ a < b) ↔ a ≤ b 
goal: (a ≠ b ↔ a < b) ↔ a ≤ b

full_name: min_def'
code: theorem min_def' [LinearOrder α] (a b : α) : min a b = if b ≤ a then b else a 
goal: min a b = if b ≤ a then b else a

full_name: max_def'
code: theorem max_def' [LinearOrder α] (a b : α) : max a b = if b ≤ a then a else b 
goal: max a b = if b ≤ a then a else b

full_name: lt_of_not_le
code: theorem lt_of_not_le [LinearOrder α] {a b : α} (h : ¬b ≤ a) : a < b 
goal: a < b

full_name: lt_iff_not_le
code: theorem lt_iff_not_le [LinearOrder α] {x y : α} : x < y ↔ ¬y ≤ x 
goal: x < y ↔ ¬y ≤ x

full_name: Ne.lt_or_lt
code: theorem Ne.lt_or_lt [LinearOrder α] {x y : α} (h : x ≠ y) : x < y ∨ y < x 
goal: x < y ∨ y < x

full_name: lt_or_lt_iff_ne
code: /-- A version of `ne_iff_lt_or_gt` with LHS and RHS reversed. -/
@[simp]
theorem lt_or_lt_iff_ne [LinearOrder α] {x y : α} : x < y ∨ y < x ↔ x ≠ y 
goal: x < y ∨ y < x ↔ x ≠ y

full_name: not_lt_iff_eq_or_lt
code: theorem not_lt_iff_eq_or_lt [LinearOrder α] {a b : α} : ¬a < b ↔ a = b ∨ b < a 
goal: ¬a < b ↔ a = b ∨ b < a

full_name: exists_ge_of_linear
code: theorem exists_ge_of_linear [LinearOrder α] (a b : α) : ∃ c, a ≤ c ∧ b ≤ c 
goal: ∃ c, a ≤ c ∧ b ≤ c

full_name: exists_forall_ge_and
code: lemma exists_forall_ge_and [LinearOrder α] {p q : α → Prop} :
    (∃ i, ∀ j ≥ i, p j) → (∃ i, ∀ j ≥ i, q j) → ∃ i, ∀ j ≥ i, p j ∧ q j
  
goal: (∃ i, ∀ (j : α), j ≥ i → p j) → (∃ i, ∀ (j : α), j ≥ i → q j) → ∃ i, ∀ (j : α), j ≥ i → p j ∧ q j

full_name: lt_imp_lt_of_le_imp_le
code: theorem lt_imp_lt_of_le_imp_le {β} [LinearOrder α] [Preorder β] {a b : α} {c d : β}
    (H : a ≤ b → c ≤ d) (h : d < c) : b < a 
goal: b < a

full_name: le_imp_le_iff_lt_imp_lt
code: theorem le_imp_le_iff_lt_imp_lt {β} [LinearOrder α] [LinearOrder β] {a b : α} {c d : β} :
    a ≤ b → c ≤ d ↔ d < c → b < a 
goal: a ≤ b → c ≤ d ↔ d < c → b < a

full_name: lt_iff_lt_of_le_iff_le'
code: theorem lt_iff_lt_of_le_iff_le' {β} [Preorder α] [Preorder β] {a b : α} {c d : β}
    (H : a ≤ b ↔ c ≤ d) (H' : b ≤ a ↔ d ≤ c) : b < a ↔ d < c 
goal: b < a ↔ d < c

full_name: lt_iff_lt_of_le_iff_le
code: theorem lt_iff_lt_of_le_iff_le {β} [LinearOrder α] [LinearOrder β] {a b : α} {c d : β}
    (H : a ≤ b ↔ c ≤ d) : b < a ↔ d < c 
goal: b < a ↔ d < c

full_name: le_iff_le_iff_lt_iff_lt
code: theorem le_iff_le_iff_lt_iff_lt {β} [LinearOrder α] [LinearOrder β] {a b : α} {c d : β} :
    (a ≤ b ↔ c ≤ d) ↔ (b < a ↔ d < c) 
goal: (a ≤ b ↔ c ≤ d) ↔ (b < a ↔ d < c)

full_name: eq_of_forall_le_iff
code: theorem eq_of_forall_le_iff [PartialOrder α] {a b : α} (H : ∀ c, c ≤ a ↔ c ≤ b) : a = b 
goal: a = b

full_name: le_of_forall_le
code: theorem le_of_forall_le [Preorder α] {a b : α} (H : ∀ c, c ≤ a → c ≤ b) : a ≤ b 
goal: a ≤ b

full_name: le_of_forall_le'
code: theorem le_of_forall_le' [Preorder α] {a b : α} (H : ∀ c, a ≤ c → b ≤ c) : b ≤ a 
goal: b ≤ a

full_name: le_of_forall_lt
code: theorem le_of_forall_lt [LinearOrder α] {a b : α} (H : ∀ c, c < a → c < b) : a ≤ b 
goal: a ≤ b

full_name: forall_lt_iff_le
code: theorem forall_lt_iff_le [LinearOrder α] {a b : α} : (∀ ⦃c⦄, c < a → c < b) ↔ a ≤ b 
goal: (∀ ⦃c : α⦄, c < a → c < b) ↔ a ≤ b

full_name: le_of_forall_lt'
code: theorem le_of_forall_lt' [LinearOrder α] {a b : α} (H : ∀ c, a < c → b < c) : b ≤ a 
goal: b ≤ a

full_name: forall_lt_iff_le'
code: theorem forall_lt_iff_le' [LinearOrder α] {a b : α} : (∀ ⦃c⦄, a < c → b < c) ↔ b ≤ a 
goal: (∀ ⦃c : α⦄, a < c → b < c) ↔ b ≤ a

full_name: eq_of_forall_ge_iff
code: theorem eq_of_forall_ge_iff [PartialOrder α] {a b : α} (H : ∀ c, a ≤ c ↔ b ≤ c) : a = b 
goal: a = b

full_name: eq_of_forall_lt_iff
code: theorem eq_of_forall_lt_iff [LinearOrder α] {a b : α} (h : ∀ c, c < a ↔ c < b) : a = b 
goal: a = b

full_name: eq_of_forall_gt_iff
code: theorem eq_of_forall_gt_iff [LinearOrder α] {a b : α} (h : ∀ c, a < c ↔ b < c) : a = b 
goal: a = b

full_name: rel_imp_eq_of_rel_imp_le
code: /-- A symmetric relation implies two values are equal, when it implies they're less-equal.  -/
theorem rel_imp_eq_of_rel_imp_le [PartialOrder β] (r : α → α → Prop) [IsSymm α r] {f : α → β}
    (h : ∀ a b, r a b → f a ≤ f b) {a b : α} : r a b → f a = f b 
goal: r a b → f a = f b

full_name: le_implies_le_of_le_of_le
code: /-- monotonicity of `≤` with respect to `→` -/
theorem le_implies_le_of_le_of_le {a b c d : α} [Preorder α] (hca : c ≤ a) (hbd : b ≤ d) :
    a ≤ b → c ≤ d 
goal: a ≤ b → c ≤ d

full_name: commutative_of_le
code: /-- To prove commutativity of a binary operation `○`, we only to check `a ○ b ≤ b ○ a` for all `a`,
`b`. -/
theorem commutative_of_le {f : β → β → α} (comm : ∀ a b, f a b ≤ f b a) : ∀ a b, f a b = f b a 
goal: f a b = f b a

full_name: associative_of_commutative_of_le
code: /-- To prove associativity of a commutative binary operation `○`, we only to check
`(a ○ b) ○ c ≤ a ○ (b ○ c)` for all `a`, `b`, `c`. -/
theorem associative_of_commutative_of_le {f : α → α → α} (comm : Commutative f)
    (assoc : ∀ a b c, f (f a b) c ≤ f a (f b c)) : Associative f 
goal: Associative f

full_name: Preorder.toLE_injective
code: @[ext]
theorem Preorder.toLE_injective : Function.Injective (@Preorder.toLE α) 
goal: Function.Injective (@Preorder.toLE α)

full_name: PartialOrder.toPreorder_injective
code: @[ext]
theorem PartialOrder.toPreorder_injective :
    Function.Injective (@PartialOrder.toPreorder α) 
goal: Function.Injective (@PartialOrder.toPreorder α)

full_name: LinearOrder.toPartialOrder_injective
code: @[ext]
theorem LinearOrder.toPartialOrder_injective :
    Function.Injective (@LinearOrder.toPartialOrder α) 
goal: Function.Injective (@LinearOrder.toPartialOrder α)

full_name: Preorder.ext
code: theorem Preorder.ext {A B : Preorder α}
    (H : ∀ x y : α, (haveI := A; x ≤ y) ↔ x ≤ y) : A = B 
goal: A = B

full_name: PartialOrder.ext
code: theorem PartialOrder.ext {A B : PartialOrder α}
    (H : ∀ x y : α, (haveI := A; x ≤ y) ↔ x ≤ y) : A = B 
goal: A = B

full_name: LinearOrder.ext
code: theorem LinearOrder.ext {A B : LinearOrder α}
    (H : ∀ x y : α, (haveI := A; x ≤ y) ↔ x ≤ y) : A = B 
goal: A = B

full_name: Order.Preimage
code: /-- Given a relation `R` on `β` and a function `f : α → β`, the preimage relation on `α` is defined
by `x ≤ y ↔ f x ≤ f y`. It is the unique relation on `α` making `f` a `RelEmbedding` (assuming `f`
is injective). -/
@[simp]
def Order.Preimage (f : α → β) (s : β → β → Prop) (x y : α) : Prop 
goal: Prop

full_name: «_aux_Mathlib_Order_Basic___macroRules_term_⁻¹'o__1»
code: @[inherit_doc]
infixl:80 " ⁻¹'o " => Order.Preimage
goal: Lean.Macro

full_name: _aux_Mathlib_Order_Basic___unexpand_Order_Preimage_1
code: @[inherit_doc]
infixl:80 " ⁻¹'o " => Order.Preimage
goal: Lean.PrettyPrinter.Unexpander

full_name: Order.Preimage.decidable
code: /-- The preimage of a decidable order is decidable. -/
instance Order.Preimage.decidable (f : α → β) (s : β → β → Prop) [H : DecidableRel s] :
    DecidableRel (f ⁻¹'o s) 
goal: DecidableRel (f ⁻¹'o s)

full_name: ltByCases_lt
code: @[simp]
lemma ltByCases_lt (h : x < y) {h₁ : x < y → P} {h₂ : x = y → P} {h₃ : y < x → P} :
    ltByCases x y h₁ h₂ h₃ = h₁ h 
goal: ltByCases x y h₁ h₂ h₃ = h₁ h

full_name: ltByCases_gt
code: @[simp]
lemma ltByCases_gt (h : y < x) {h₁ : x < y → P} {h₂ : x = y → P} {h₃ : y < x → P} :
    ltByCases x y h₁ h₂ h₃ = h₃ h 
goal: ltByCases x y h₁ h₂ h₃ = h₃ h

full_name: ltByCases_eq
code: @[simp]
lemma ltByCases_eq (h : x = y) {h₁ : x < y → P} {h₂ : x = y → P} {h₃ : y < x → P} :
    ltByCases x y h₁ h₂ h₃ = h₂ h 
goal: ltByCases x y h₁ h₂ h₃ = h₂ h

full_name: ltByCases_not_lt
code: lemma ltByCases_not_lt (h : ¬ x < y) {h₁ : x < y → P} {h₂ : x = y → P} {h₃ : y < x → P}
    (p : ¬ y < x → x = y := fun h' => (le_antisymm (le_of_not_gt h') (le_of_not_gt h))) :
    ltByCases x y h₁ h₂ h₃ = if h' : y < x then h₃ h' else h₂ (p h') 
goal: ltByCases x y h₁ h₂ h₃ = if h' : y < x then h₃ h' else h₂ ⋯

full_name: ltByCases_not_gt
code: lemma ltByCases_not_gt (h : ¬ y < x) {h₁ : x < y → P} {h₂ : x = y → P} {h₃ : y < x → P}
    (p : ¬ x < y → x = y := fun h' => (le_antisymm (le_of_not_gt h) (le_of_not_gt h'))) :
    ltByCases x y h₁ h₂ h₃ = if h' : x < y then h₁ h' else h₂ (p h') 
goal: ltByCases x y h₁ h₂ h₃ = if h' : x < y then h₁ h' else h₂ ⋯

full_name: ltByCases_ne
code: lemma ltByCases_ne (h : x ≠ y) {h₁ : x < y → P} {h₂ : x = y → P} {h₃ : y < x → P}
    (p : ¬ x < y → y < x := fun h' => h.lt_or_lt.resolve_left h') :
    ltByCases x y h₁ h₂ h₃ = if h' : x < y then h₁ h' else h₃ (p h') 
goal: ltByCases x y h₁ h₂ h₃ = if h' : x < y then h₁ h' else h₃ ⋯

full_name: ltByCases_comm
code: lemma ltByCases_comm {h₁ : x < y → P} {h₂ : x = y → P} {h₃ : y < x → P}
    (p : y = x → x = y := fun h' => h'.symm) :
    ltByCases x y h₁ h₂ h₃ = ltByCases y x h₃ (h₂ ∘ p) h₁ 
goal: ltByCases x y h₁ h₂ h₃ = ltByCases y x h₃ (h₂ ∘ p) h₁

full_name: eq_iff_eq_of_lt_iff_lt_of_gt_iff_gt
code: lemma eq_iff_eq_of_lt_iff_lt_of_gt_iff_gt {x' y' : α}
    (ltc : (x < y) ↔ (x' < y')) (gtc : (y < x) ↔ (y' < x')) :
    x = y ↔ x' = y' 
goal: x = y ↔ x' = y'

full_name: ltByCases_rec
code: lemma ltByCases_rec {h₁ : x < y → P} {h₂ : x = y → P} {h₃ : y < x → P} (p : P)
    (hlt : (h : x < y) → h₁ h = p) (heq : (h : x = y) → h₂ h = p)
    (hgt : (h : y < x) → h₃ h = p) :
    ltByCases x y h₁ h₂ h₃ = p 
goal: ltByCases x y h₁ h₂ h₃ = p

full_name: ltByCases_eq_iff
code: lemma ltByCases_eq_iff {h₁ : x < y → P} {h₂ : x = y → P} {h₃ : y < x → P} {p : P} :
    ltByCases x y h₁ h₂ h₃ = p ↔ (∃ h, h₁ h = p) ∨ (∃ h, h₂ h = p) ∨ (∃ h, h₃ h = p) 
goal: ltByCases x y h₁ h₂ h₃ = p ↔ (∃ h, h₁ h = p) ∨ (∃ h, h₂ h = p) ∨ ∃ h, h₃ h = p

full_name: ltByCases_congr
code: lemma ltByCases_congr {x' y' : α} {h₁ : x < y → P} {h₂ : x = y → P} {h₃ : y < x → P}
    {h₁' : x' < y' → P} {h₂' : x' = y' → P} {h₃' : y' < x' → P} (ltc : (x < y) ↔ (x' < y'))
    (gtc : (y < x) ↔ (y' < x')) (hh'₁ : ∀ (h : x' < y'), h₁ (ltc.mpr h) = h₁' h)
    (hh'₂ : ∀ (h : x' = y'), h₂ ((eq_iff_eq_of_lt_iff_lt_of_gt_iff_gt ltc gtc).mpr h) = h₂' h)
    (hh'₃ : ∀ (h : y' < x'), h₃ (gtc.mpr h) = h₃' h) :
    ltByCases x y h₁ h₂ h₃ = ltByCases x' y' h₁' h₂' h₃' 
goal: ltByCases x y h₁ h₂ h₃ = ltByCases x' y' h₁' h₂' h₃'

full_name: ltTrichotomy
code: /-- Perform a case-split on the ordering of `x` and `y` in a decidable linear order,
non-dependently. -/
abbrev ltTrichotomy (x y : α) (p q r : P) 
goal: P

full_name: ltTrichotomy_lt
code: @[simp]
lemma ltTrichotomy_lt (h : x < y) : ltTrichotomy x y p q r = p 
goal: ltTrichotomy x y p q r = p

full_name: ltTrichotomy_gt
code: @[simp]
lemma ltTrichotomy_gt (h : y < x) : ltTrichotomy x y p q r = r 
goal: ltTrichotomy x y p q r = r

full_name: ltTrichotomy_eq
code: @[simp]
lemma ltTrichotomy_eq (h : x = y) : ltTrichotomy x y p q r = q 
goal: ltTrichotomy x y p q r = q

full_name: ltTrichotomy_not_lt
code: lemma ltTrichotomy_not_lt (h : ¬ x < y) :
    ltTrichotomy x y p q r = if y < x then r else q 
goal: ltTrichotomy x y p q r = if y < x then r else q

full_name: ltTrichotomy_not_gt
code: lemma ltTrichotomy_not_gt (h : ¬ y < x) :
    ltTrichotomy x y p q r = if x < y then p else q 
goal: ltTrichotomy x y p q r = if x < y then p else q

full_name: ltTrichotomy_ne
code: lemma ltTrichotomy_ne (h : x ≠ y) :
    ltTrichotomy x y p q r = if x < y then p else r 
goal: ltTrichotomy x y p q r = if x < y then p else r

full_name: ltTrichotomy_comm
code: lemma ltTrichotomy_comm : ltTrichotomy x y p q r = ltTrichotomy y x r q p 
goal: ltTrichotomy x y p q r = ltTrichotomy y x r q p

full_name: ltTrichotomy_self
code: lemma ltTrichotomy_self {p : P} : ltTrichotomy x y p p p = p 
goal: ltTrichotomy x y p p p = p

full_name: ltTrichotomy_eq_iff
code: lemma ltTrichotomy_eq_iff : ltTrichotomy x y p q r = s ↔
    (x < y ∧ p = s) ∨ (x = y ∧ q = s) ∨ (y < x ∧ r = s) 
goal: ltTrichotomy x y p q r = s ↔ x < y ∧ p = s ∨ x = y ∧ q = s ∨ y < x ∧ r = s

full_name: ltTrichotomy_congr
code: lemma ltTrichotomy_congr {x' y' : α} {p' q' r' : P} (ltc : (x < y) ↔ (x' < y'))
    (gtc : (y < x) ↔ (y' < x')) (hh'₁ : x' < y' → p = p')
    (hh'₂ : x' = y' → q = q') (hh'₃ : y' < x' → r = r') :
    ltTrichotomy x y p q r = ltTrichotomy x' y' p' q' r' 
goal: ltTrichotomy x y p q r = ltTrichotomy x' y' p' q' r'

full_name: OrderDual
code: /-- Type synonym to equip a type with the dual order: `≤` means `≥` and `<` means `>`. `αᵒᵈ` is
notation for `OrderDual α`. -/
def OrderDual (α : Type*) : Type _ 
goal: Type u_5

full_name: «_aux_Mathlib_Order_Basic___macroRules_term_ᵒᵈ_1»
code: @[inherit_doc]
notation:max α "ᵒᵈ" => OrderDual α
goal: Lean.Macro

full_name: _aux_Mathlib_Order_Basic___unexpand_OrderDual_1
code: @[inherit_doc]
notation:max α "ᵒᵈ" => OrderDual α
goal: Lean.PrettyPrinter.Unexpander

full_name: OrderDual.instNonempty
code: instance (α : Type*) [h : Nonempty α] : Nonempty αᵒᵈ 
goal: Nonempty αᵒᵈ

full_name: OrderDual.instSubsingleton
code: instance (α : Type*) [h : Subsingleton α] : Subsingleton αᵒᵈ 
goal: Subsingleton αᵒᵈ

full_name: OrderDual.instLE
code: instance (α : Type*) [LE α] : LE αᵒᵈ 
goal: LE αᵒᵈ

full_name: OrderDual.instLT
code: instance (α : Type*) [LT α] : LT αᵒᵈ 
goal: LT αᵒᵈ

full_name: OrderDual.instPreorder
code: instance instPreorder (α : Type*) [Preorder α] : Preorder αᵒᵈ 
goal: Preorder αᵒᵈ

full_name: OrderDual.instPartialOrder
code: instance instPartialOrder (α : Type*) [PartialOrder α] : PartialOrder αᵒᵈ 
goal: PartialOrder αᵒᵈ

full_name: OrderDual.instLinearOrder
code: instance instLinearOrder (α : Type*) [LinearOrder α] : LinearOrder αᵒᵈ 
goal: LinearOrder αᵒᵈ

full_name: OrderDual.instInhabited
code: instance : ∀ [Inhabited α], Inhabited αᵒᵈ 
goal: Inhabited αᵒᵈ

full_name: OrderDual.Preorder.dual_dual
code: theorem Preorder.dual_dual (α : Type*) [H : Preorder α] : OrderDual.instPreorder αᵒᵈ = H 
goal: OrderDual.instPreorder αᵒᵈ = H

full_name: OrderDual.instPartialOrder.dual_dual
code: theorem instPartialOrder.dual_dual (α : Type*) [H : PartialOrder α] :
    OrderDual.instPartialOrder αᵒᵈ = H 
goal: OrderDual.instPartialOrder αᵒᵈ = H

full_name: OrderDual.instLinearOrder.dual_dual
code: theorem instLinearOrder.dual_dual (α : Type*) [H : LinearOrder α] :
    OrderDual.instLinearOrder αᵒᵈ = H 
goal: OrderDual.instLinearOrder αᵒᵈ = H

full_name: Prop.hasCompl
code: instance Prop.hasCompl : HasCompl Prop 
goal: HasCompl Prop

full_name: Pi.hasCompl
code: instance Pi.hasCompl [∀ i, HasCompl (π i)] : HasCompl (∀ i, π i) 
goal: HasCompl ((i : ι) → π i)

full_name: Pi.compl_def
code: theorem Pi.compl_def [∀ i, HasCompl (π i)] (x : ∀ i, π i) :
    xᶜ = fun i ↦ (x i)ᶜ 
goal: xᶜ = fun i => (x i)ᶜ

full_name: Pi.compl_apply
code: @[simp]
theorem Pi.compl_apply [∀ i, HasCompl (π i)] (x : ∀ i, π i) (i : ι) :
    xᶜ i = (x i)ᶜ 
goal: xᶜ i = (x i)ᶜ

full_name: IsIrrefl.compl
code: instance IsIrrefl.compl (r) [IsIrrefl α r] : IsRefl α rᶜ 
goal: IsRefl α rᶜ

full_name: IsRefl.compl
code: instance IsRefl.compl (r) [IsRefl α r] : IsIrrefl α rᶜ 
goal: IsIrrefl α rᶜ

full_name: Pi.hasLe
code: instance Pi.hasLe [∀ i, LE (π i)] :
    LE (∀ i, π i) 
goal: LE ((i : ι) → π i)

full_name: Pi.le_def
code: theorem Pi.le_def [∀ i, LE (π i)] {x y : ∀ i, π i} :
    x ≤ y ↔ ∀ i, x i ≤ y i 
goal: x ≤ y ↔ ∀ (i : ι), x i ≤ y i

full_name: Pi.preorder
code: instance Pi.preorder [∀ i, Preorder (π i)] : Preorder (∀ i, π i) 
goal: Preorder ((i : ι) → π i)

full_name: Pi.lt_def
code: theorem Pi.lt_def [∀ i, Preorder (π i)] {x y : ∀ i, π i} :
    x < y ↔ x ≤ y ∧ ∃ i, x i < y i 
goal: x < y ↔ x ≤ y ∧ ∃ i, x i < y i

full_name: Pi.partialOrder
code: instance Pi.partialOrder [∀ i, PartialOrder (π i)] : PartialOrder (∀ i, π i) 
goal: PartialOrder ((i : ι) → π i)

full_name: Sum.elim_le_elim_iff
code: @[simp]
lemma elim_le_elim_iff {u₁ v₁ : α₁ → β} {u₂ v₂ : α₂ → β} :
    Sum.elim u₁ u₂ ≤ Sum.elim v₁ v₂ ↔ u₁ ≤ v₁ ∧ u₂ ≤ v₂ 
goal: Sum.elim u₁ u₂ ≤ Sum.elim v₁ v₂ ↔ u₁ ≤ v₁ ∧ u₂ ≤ v₂

full_name: Sum.const_le_elim_iff
code: lemma const_le_elim_iff {b : β} {v₁ : α₁ → β} {v₂ : α₂ → β} :
    Function.const _ b ≤ Sum.elim v₁ v₂ ↔ Function.const _ b ≤ v₁ ∧ Function.const _ b ≤ v₂ 
goal: Function.const (α₁ ⊕ α₂) b ≤ Sum.elim v₁ v₂ ↔ Function.const α₁ b ≤ v₁ ∧ Function.const α₂ b ≤ v₂

full_name: Sum.elim_le_const_iff
code: lemma elim_le_const_iff {b : β} {u₁ : α₁ → β} {u₂ : α₂ → β} :
    Sum.elim u₁ u₂ ≤ Function.const _ b ↔ u₁ ≤ Function.const _ b ∧ u₂ ≤ Function.const _ b 
goal: Sum.elim u₁ u₂ ≤ Function.const (α₁ ⊕ α₂) b ↔ u₁ ≤ Function.const α₁ b ∧ u₂ ≤ Function.const α₂ b

full_name: StrongLT
code: /-- A function `a` is strongly less than a function `b` if `a i < b i` for all `i`. -/
def StrongLT [∀ i, LT (π i)] (a b : ∀ i, π i) : Prop 
goal: Prop

full_name: «_aux_Mathlib_Order_Basic___macroRules_term_≺__1»
code: @[inherit_doc]
local infixl:50 " ≺ " => StrongLT
goal: Lean.Macro

full_name: _aux_Mathlib_Order_Basic___unexpand_StrongLT_1
code: @[inherit_doc]
local infixl:50 " ≺ " => StrongLT
goal: Lean.PrettyPrinter.Unexpander

full_name: le_of_strongLT
code: theorem le_of_strongLT (h : a ≺ b) : a ≤ b 
goal: a ≤ b

full_name: lt_of_strongLT
code: theorem lt_of_strongLT [Nonempty ι] (h : a ≺ b) : a < b 
goal: a < b

full_name: strongLT_of_strongLT_of_le
code: theorem strongLT_of_strongLT_of_le (hab : a ≺ b) (hbc : b ≤ c) : a ≺ c 
goal: StrongLT a c

full_name: strongLT_of_le_of_strongLT
code: theorem strongLT_of_le_of_strongLT (hab : a ≤ b) (hbc : b ≺ c) : a ≺ c 
goal: StrongLT a c

full_name: le_update_iff
code: theorem le_update_iff : x ≤ Function.update y i a ↔ x i ≤ a ∧ ∀ (j) (_ : j ≠ i), x j ≤ y j 
goal: x ≤ Function.update y i a ↔ x i ≤ a ∧ ∀ (j : ι), j ≠ i → x j ≤ y j

full_name: update_le_iff
code: theorem update_le_iff : Function.update x i a ≤ y ↔ a ≤ y i ∧ ∀ (j) (_ : j ≠ i), x j ≤ y j 
goal: Function.update x i a ≤ y ↔ a ≤ y i ∧ ∀ (j : ι), j ≠ i → x j ≤ y j

full_name: update_le_update_iff
code: theorem update_le_update_iff :
    Function.update x i a ≤ Function.update y i b ↔ a ≤ b ∧ ∀ (j) (_ : j ≠ i), x j ≤ y j 
goal: Function.update x i a ≤ Function.update y i b ↔ a ≤ b ∧ ∀ (j : ι), j ≠ i → x j ≤ y j

full_name: update_le_update_iff'
code: @[simp]
theorem update_le_update_iff' : update x i a ≤ update x i b ↔ a ≤ b 
goal: Function.update x i a ≤ Function.update x i b ↔ a ≤ b

full_name: update_lt_update_iff
code: @[simp]
theorem update_lt_update_iff : update x i a < update x i b ↔ a < b 
goal: Function.update x i a < Function.update x i b ↔ a < b

full_name: le_update_self_iff
code: @[simp]
theorem le_update_self_iff : x ≤ update x i a ↔ x i ≤ a 
goal: x ≤ Function.update x i a ↔ x i ≤ a

full_name: update_le_self_iff
code: @[simp]
theorem update_le_self_iff : update x i a ≤ x ↔ a ≤ x i 
goal: Function.update x i a ≤ x ↔ a ≤ x i

full_name: lt_update_self_iff
code: @[simp]
theorem lt_update_self_iff : x < update x i a ↔ x i < a 
goal: x < Function.update x i a ↔ x i < a

full_name: update_lt_self_iff
code: @[simp]
theorem update_lt_self_iff : update x i a < x ↔ a < x i 
goal: Function.update x i a < x ↔ a < x i

full_name: Pi.sdiff
code: instance Pi.sdiff [∀ i, SDiff (π i)] : SDiff (∀ i, π i) 
goal: SDiff ((i : ι) → π i)

full_name: Pi.sdiff_def
code: theorem Pi.sdiff_def [∀ i, SDiff (π i)] (x y : ∀ i, π i) :
    x \ y = fun i ↦ x i \ y i 
goal: x \ y = fun i => x i \ y i

full_name: Pi.sdiff_apply
code: @[simp]
theorem Pi.sdiff_apply [∀ i, SDiff (π i)] (x y : ∀ i, π i) (i : ι) :
    (x \ y) i = x i \ y i 
goal: (x \ y) i = x i \ y i

full_name: Function.const_le_const
code: @[simp]
theorem const_le_const : const β a ≤ const β b ↔ a ≤ b 
goal: Function.const β a ≤ Function.const β b ↔ a ≤ b

full_name: Function.const_lt_const
code: @[simp]
theorem const_lt_const : const β a < const β b ↔ a < b 
goal: Function.const β a < Function.const β b ↔ a < b

full_name: min_rec
code: theorem min_rec (hx : x ≤ y → p x) (hy : y ≤ x → p y) : p (min x y) 
goal: p (min x y)

full_name: max_rec
code: theorem max_rec (hx : y ≤ x → p x) (hy : x ≤ y → p y) : p (max x y) 
goal: p (max x y)

full_name: min_rec'
code: theorem min_rec' (p : α → Prop) (hx : p x) (hy : p y) : p (min x y) 
goal: p (min x y)

full_name: max_rec'
code: theorem max_rec' (p : α → Prop) (hx : p x) (hy : p y) : p (max x y) 
goal: p (max x y)

full_name: min_def_lt
code: theorem min_def_lt (x y : α) : min x y = if x < y then x else y 
goal: min x y = if x < y then x else y

full_name: max_def_lt
code: theorem max_def_lt (x y : α) : max x y = if x < y then y else x 
goal: max x y = if x < y then y else x

full_name: Preorder.lift
code: /-- Transfer a `Preorder` on `β` to a `Preorder` on `α` using a function `f : α → β`.
See note [reducible non-instances]. -/
abbrev Preorder.lift [Preorder β] (f : α → β) : Preorder α 
goal: Preorder α

full_name: PartialOrder.lift
code: /-- Transfer a `PartialOrder` on `β` to a `PartialOrder` on `α` using an injective
function `f : α → β`. See note [reducible non-instances]. -/
abbrev PartialOrder.lift [PartialOrder β] (f : α → β) (inj : Injective f) : PartialOrder α 
goal: PartialOrder α

full_name: compare_of_injective_eq_compareOfLessAndEq
code: theorem compare_of_injective_eq_compareOfLessAndEq (a b : α) [LinearOrder β]
    [DecidableEq α] (f : α → β) (inj : Injective f)
    [Decidable (LT.lt (self := PartialOrder.lift f inj |>.toLT) a b)] :
    compare (f a) (f b) =
      @compareOfLessAndEq _ a b (PartialOrder.lift f inj |>.toLT) _ _ 
goal: compare (f a) (f b) = compareOfLessAndEq a b

full_name: LinearOrder.lift
code: /-- Transfer a `LinearOrder` on `β` to a `LinearOrder` on `α` using an injective
function `f : α → β`. This version takes `[Sup α]` and `[Inf α]` as arguments, then uses
them for `max` and `min` fields. See `LinearOrder.lift'` for a version that autogenerates `min` and
`max` fields, and `LinearOrder.liftWithOrd` for one that does not auto-generate `compare`
fields. See note [reducible non-instances]. -/
abbrev LinearOrder.lift [LinearOrder β] [Sup α] [Inf α] (f : α → β) (inj : Injective f)
    (hsup : ∀ x y, f (x ⊔ y) = max (f x) (f y)) (hinf : ∀ x y, f (x ⊓ y) = min (f x) (f y)) :
    LinearOrder α 
goal: LinearOrder α

full_name: LinearOrder.lift'
code: /-- Transfer a `LinearOrder` on `β` to a `LinearOrder` on `α` using an injective
function `f : α → β`. This version autogenerates `min` and `max` fields. See `LinearOrder.lift`
for a version that takes `[Sup α]` and `[Inf α]`, then uses them as `max` and `min`. See
`LinearOrder.liftWithOrd'` for a version which does not auto-generate `compare` fields.
See note [reducible non-instances]. -/
abbrev LinearOrder.lift' [LinearOrder β] (f : α → β) (inj : Injective f) : LinearOrder α 
goal: LinearOrder α

full_name: LinearOrder.liftWithOrd
code: /-- Transfer a `LinearOrder` on `β` to a `LinearOrder` on `α` using an injective
function `f : α → β`. This version takes `[Sup α]` and `[Inf α]` as arguments, then uses
them for `max` and `min` fields. It also takes `[Ord α]` as an argument and uses them for `compare`
fields. See `LinearOrder.lift` for a version that autogenerates `compare` fields, and
`LinearOrder.liftWithOrd'` for one that auto-generates `min` and `max` fields.
fields. See note [reducible non-instances]. -/
abbrev LinearOrder.liftWithOrd [LinearOrder β] [Sup α] [Inf α] [Ord α] (f : α → β)
    (inj : Injective f) (hsup : ∀ x y, f (x ⊔ y) = max (f x) (f y))
    (hinf : ∀ x y, f (x ⊓ y) = min (f x) (f y))
    (compare_f : ∀ a b : α, compare a b = compare (f a) (f b)) : LinearOrder α 
goal: LinearOrder α

full_name: LinearOrder.liftWithOrd'
code: /-- Transfer a `LinearOrder` on `β` to a `LinearOrder` on `α` using an injective
function `f : α → β`. This version auto-generates `min` and `max` fields. It also takes `[Ord α]`
as an argument and uses them for `compare` fields. See `LinearOrder.lift` for a version that
autogenerates `compare` fields, and `LinearOrder.liftWithOrd` for one that doesn't auto-generate
`min` and `max` fields. fields. See note [reducible non-instances]. -/
abbrev LinearOrder.liftWithOrd' [LinearOrder β] [Ord α] (f : α → β)
    (inj : Injective f)
    (compare_f : ∀ a b : α, compare a b = compare (f a) (f b)) : LinearOrder α 
goal: LinearOrder α

full_name: Subtype.le
code: instance le [LE α] {p : α → Prop} : LE (Subtype p) 
goal: LE (Subtype p)

full_name: Subtype.lt
code: instance lt [LT α] {p : α → Prop} : LT (Subtype p) 
goal: LT (Subtype p)

full_name: Subtype.mk_le_mk
code: @[simp]
theorem mk_le_mk [LE α] {p : α → Prop} {x y : α} {hx : p x} {hy : p y} :
    (⟨x, hx⟩ : Subtype p) ≤ ⟨y, hy⟩ ↔ x ≤ y 
goal: ⟨x, hx⟩ ≤ ⟨y, hy⟩ ↔ x ≤ y

full_name: Subtype.mk_lt_mk
code: @[simp]
theorem mk_lt_mk [LT α] {p : α → Prop} {x y : α} {hx : p x} {hy : p y} :
    (⟨x, hx⟩ : Subtype p) < ⟨y, hy⟩ ↔ x < y 
goal: ⟨x, hx⟩ < ⟨y, hy⟩ ↔ x < y

full_name: Subtype.coe_le_coe
code: @[simp, norm_cast]
theorem coe_le_coe [LE α] {p : α → Prop} {x y : Subtype p} : (x : α) ≤ y ↔ x ≤ y 
goal: ↑x ≤ ↑y ↔ x ≤ y

full_name: Subtype.coe_lt_coe
code: @[simp, norm_cast]
theorem coe_lt_coe [LT α] {p : α → Prop} {x y : Subtype p} : (x : α) < y ↔ x < y 
goal: ↑x < ↑y ↔ x < y

full_name: Subtype.preorder
code: instance preorder [Preorder α] (p : α → Prop) : Preorder (Subtype p) 
goal: Preorder (Subtype p)

full_name: Subtype.partialOrder
code: instance partialOrder [PartialOrder α] (p : α → Prop) : PartialOrder (Subtype p) 
goal: PartialOrder (Subtype p)

full_name: Subtype.decidableLE
code: instance decidableLE [Preorder α] [h : @DecidableRel α (· ≤ ·)] {p : α → Prop} :
    @DecidableRel (Subtype p) (· ≤ ·) 
goal: DecidableRel fun x x_1 => x ≤ x_1

full_name: Subtype.decidableLT
code: instance decidableLT [Preorder α] [h : @DecidableRel α (· < ·)] {p : α → Prop} :
    @DecidableRel (Subtype p) (· < ·) 
goal: DecidableRel fun x x_1 => x < x_1

full_name: Subtype.instLinearOrder
code: /-- A subtype of a linear order is a linear order. We explicitly give the proofs of decidable
equality and decidable order in order to ensure the decidability instances are all definitionally
equal. -/
instance instLinearOrder [LinearOrder α] (p : α → Prop) : LinearOrder (Subtype p) 
goal: LinearOrder (Subtype p)

full_name: Prod.instLE_mathlib
code: instance (α β : Type*) [LE α] [LE β] : LE (α × β) 
goal: LE (α × β)

full_name: Prod.instDecidableLE
code: instance instDecidableLE (α β : Type*) [LE α] [LE β] (x y : α × β)
    [Decidable (x.1 ≤ y.1)] [Decidable (x.2 ≤ y.2)] : Decidable (x ≤ y) 
goal: Decidable (x ≤ y)

full_name: Prod.le_def
code: theorem le_def [LE α] [LE β] {x y : α × β} : x ≤ y ↔ x.1 ≤ y.1 ∧ x.2 ≤ y.2 
goal: x ≤ y ↔ x.1 ≤ y.1 ∧ x.2 ≤ y.2

full_name: Prod.mk_le_mk
code: @[simp]
theorem mk_le_mk [LE α] [LE β] {x₁ x₂ : α} {y₁ y₂ : β} : (x₁, y₁) ≤ (x₂, y₂) ↔ x₁ ≤ x₂ ∧ y₁ ≤ y₂ 
goal: (x₁, y₁) ≤ (x₂, y₂) ↔ x₁ ≤ x₂ ∧ y₁ ≤ y₂

full_name: Prod.swap_le_swap
code: @[simp]
theorem swap_le_swap [LE α] [LE β] {x y : α × β} : x.swap ≤ y.swap ↔ x ≤ y 
goal: x.swap ≤ y.swap ↔ x ≤ y

full_name: Prod.instPreorder
code: instance (α β : Type*) [Preorder α] [Preorder β] : Preorder (α × β) 
goal: Preorder (α × β)

full_name: Prod.swap_lt_swap
code: @[simp]
theorem swap_lt_swap : x.swap < y.swap ↔ x < y 
goal: x.swap < y.swap ↔ x < y

full_name: Prod.mk_le_mk_iff_left
code: theorem mk_le_mk_iff_left : (a₁, b) ≤ (a₂, b) ↔ a₁ ≤ a₂ 
goal: (a₁, b) ≤ (a₂, b) ↔ a₁ ≤ a₂

full_name: Prod.mk_le_mk_iff_right
code: theorem mk_le_mk_iff_right : (a, b₁) ≤ (a, b₂) ↔ b₁ ≤ b₂ 
goal: (a, b₁) ≤ (a, b₂) ↔ b₁ ≤ b₂

full_name: Prod.mk_lt_mk_iff_left
code: theorem mk_lt_mk_iff_left : (a₁, b) < (a₂, b) ↔ a₁ < a₂ 
goal: (a₁, b) < (a₂, b) ↔ a₁ < a₂

full_name: Prod.mk_lt_mk_iff_right
code: theorem mk_lt_mk_iff_right : (a, b₁) < (a, b₂) ↔ b₁ < b₂ 
goal: (a, b₁) < (a, b₂) ↔ b₁ < b₂

full_name: Prod.lt_iff
code: theorem lt_iff : x < y ↔ x.1 < y.1 ∧ x.2 ≤ y.2 ∨ x.1 ≤ y.1 ∧ x.2 < y.2 
goal: x < y ↔ x.1 < y.1 ∧ x.2 ≤ y.2 ∨ x.1 ≤ y.1 ∧ x.2 < y.2

full_name: Prod.mk_lt_mk
code: @[simp]
theorem mk_lt_mk : (a₁, b₁) < (a₂, b₂) ↔ a₁ < a₂ ∧ b₁ ≤ b₂ ∨ a₁ ≤ a₂ ∧ b₁ < b₂ 
goal: (a₁, b₁) < (a₂, b₂) ↔ a₁ < a₂ ∧ b₁ ≤ b₂ ∨ a₁ ≤ a₂ ∧ b₁ < b₂

full_name: Prod.lt_of_lt_of_le
code: protected lemma lt_of_lt_of_le (h₁ : x.1 < y.1) (h₂ : x.2 ≤ y.2) : x < y 
goal: x < y

full_name: Prod.lt_of_le_of_lt
code: protected lemma lt_of_le_of_lt (h₁ : x.1 ≤ y.1) (h₂ : x.2 < y.2) : x < y 
goal: x < y

full_name: Prod.mk_lt_mk_of_lt_of_le
code: lemma mk_lt_mk_of_lt_of_le (h₁ : a₁ < a₂) (h₂ : b₁ ≤ b₂) : (a₁, b₁) < (a₂, b₂) 
goal: (a₁, b₁) < (a₂, b₂)

full_name: Prod.mk_lt_mk_of_le_of_lt
code: lemma mk_lt_mk_of_le_of_lt (h₁ : a₁ ≤ a₂) (h₂ : b₁ < b₂) : (a₁, b₁) < (a₂, b₂) 
goal: (a₁, b₁) < (a₂, b₂)

full_name: Prod.instPartialOrder
code: /-- The pointwise partial order on a product.
    (The lexicographic ordering is defined in `Order.Lexicographic`, and the instances are
    available via the type synonym `α ×ₗ β = α × β`.) -/
instance instPartialOrder (α β : Type*) [PartialOrder α] [PartialOrder β] :
    PartialOrder (α × β) 
goal: PartialOrder (α × β)

full_name: DenselyOrdered
code: /-- An order is dense if there is an element between any pair of distinct comparable elements. -/
class DenselyOrdered (α : Type*) [LT α] : Prop where
  /-- An order is dense if there is an element between any pair of distinct elements. -/
  dense : ∀ a₁ a₂ : α, a₁ < a₂ → ∃ a, a₁ < a ∧ a < a₂
goal: Prop

full_name: DenselyOrdered.dense
code: /-- An order is dense if there is an element between any pair of distinct comparable elements. -/
class DenselyOrdered (α : Type*) [LT α] : Prop where
  /-- An order is dense if there is an element between any pair of distinct elements. -/
  dense : ∀ a₁ a₂ : α, a₁ < a₂ → ∃ a, a₁ < a ∧ a < a₂
goal: a₁ < a₂ → ∃ a, a₁ < a ∧ a < a₂

full_name: exists_between
code: theorem exists_between [LT α] [DenselyOrdered α] : ∀ {a₁ a₂ : α}, a₁ < a₂ → ∃ a, a₁ < a ∧ a < a₂ 
goal: a₁ < a₂ → ∃ a, a₁ < a ∧ a < a₂

full_name: OrderDual.denselyOrdered
code: instance OrderDual.denselyOrdered (α : Type*) [LT α] [h : DenselyOrdered α] :
    DenselyOrdered αᵒᵈ 
goal: DenselyOrdered αᵒᵈ

full_name: denselyOrdered_orderDual
code: @[simp]
theorem denselyOrdered_orderDual [LT α] : DenselyOrdered αᵒᵈ ↔ DenselyOrdered α 
goal: DenselyOrdered αᵒᵈ ↔ DenselyOrdered α

full_name: instDenselyOrderedProd
code: instance [Preorder α] [Preorder β] [DenselyOrdered α] [DenselyOrdered β] : DenselyOrdered (α × β) 
goal: DenselyOrdered (α × β)

full_name: instDenselyOrderedForall
code: instance [∀ i, Preorder (π i)] [∀ i, DenselyOrdered (π i)] :
    DenselyOrdered (∀ i, π i) 
goal: DenselyOrdered ((i : ι) → π i)

full_name: le_of_forall_le_of_dense
code: theorem le_of_forall_le_of_dense [LinearOrder α] [DenselyOrdered α] {a₁ a₂ : α}
    (h : ∀ a, a₂ < a → a₁ ≤ a) : a₁ ≤ a₂ 
goal: a₁ ≤ a₂

full_name: eq_of_le_of_forall_le_of_dense
code: theorem eq_of_le_of_forall_le_of_dense [LinearOrder α] [DenselyOrdered α] {a₁ a₂ : α} (h₁ : a₂ ≤ a₁)
    (h₂ : ∀ a, a₂ < a → a₁ ≤ a) : a₁ = a₂ 
goal: a₁ = a₂

full_name: le_of_forall_ge_of_dense
code: theorem le_of_forall_ge_of_dense [LinearOrder α] [DenselyOrdered α] {a₁ a₂ : α}
    (h : ∀ a₃ < a₁, a₃ ≤ a₂) : a₁ ≤ a₂ 
goal: a₁ ≤ a₂

full_name: eq_of_le_of_forall_ge_of_dense
code: theorem eq_of_le_of_forall_ge_of_dense [LinearOrder α] [DenselyOrdered α] {a₁ a₂ : α} (h₁ : a₂ ≤ a₁)
    (h₂ : ∀ a₃ < a₁, a₃ ≤ a₂) : a₁ = a₂ 
goal: a₁ = a₂

full_name: dense_or_discrete
code: theorem dense_or_discrete [LinearOrder α] (a₁ a₂ : α) :
    (∃ a, a₁ < a ∧ a < a₂) ∨ (∀ a, a₁ < a → a₂ ≤ a) ∧ ∀ a < a₂, a ≤ a₁ 
goal: (∃ a, a₁ < a ∧ a < a₂) ∨ (∀ (a : α), a₁ < a → a₂ ≤ a) ∧ ∀ (a : α), a < a₂ → a ≤ a₁

full_name: eq_or_eq_or_eq_of_forall_not_lt_lt
code: /-- If a linear order has no elements `x < y < z`, then it has at most two elements. -/
lemma eq_or_eq_or_eq_of_forall_not_lt_lt [LinearOrder α]
    (h : ∀ ⦃x y z : α⦄, x < y → y < z → False) (x y z : α) : x = y ∨ y = z ∨ x = z 
goal: x = y ∨ y = z ∨ x = z

full_name: PUnit.instLinearOrder
code: instance instLinearOrder : LinearOrder PUnit 
goal: LinearOrder PUnit.{u_5 + 1}

full_name: PUnit.max_eq
code: theorem max_eq : max a b = unit 
goal: max a b = PUnit.unit

full_name: PUnit.min_eq
code: theorem min_eq : min a b = unit 
goal: min a b = PUnit.unit

full_name: PUnit.le
code: protected theorem le : a ≤ b 
goal: a ≤ b

full_name: PUnit.not_lt
code: theorem not_lt : ¬a < b 
goal: ¬a < b

full_name: PUnit.instDenselyOrdered
code: instance : DenselyOrdered PUnit 
goal: DenselyOrdered PUnit.{u_5 + 1}

full_name: Prop.le
code: /-- Propositions form a complete boolean algebra, where the `≤` relation is given by implication. -/
instance Prop.le : LE Prop 
goal: LE Prop

full_name: le_Prop_eq
code: @[simp]
theorem le_Prop_eq : ((· ≤ ·) : Prop → Prop → Prop) = (· → ·) 
goal: (fun x x_1 => x ≤ x_1) = fun x x_1 => x → x_1

full_name: subrelation_iff_le
code: theorem subrelation_iff_le {r s : α → α → Prop} : Subrelation r s ↔ r ≤ s 
goal: Subrelation r s ↔ r ≤ s

full_name: Prop.partialOrder
code: instance Prop.partialOrder : PartialOrder Prop 
goal: PartialOrder Prop

full_name: AsLinearOrder
code: /-- Type synonym to create an instance of `LinearOrder` from a `PartialOrder` and `IsTotal α (≤)` -/
def AsLinearOrder (α : Type*)  
goal: Type u_5

full_name: instInhabitedAsLinearOrder
code: instance [Inhabited α] : Inhabited (AsLinearOrder α) 
goal: Inhabited (AsLinearOrder α)

full_name: AsLinearOrder.linearOrder
code: noncomputable instance AsLinearOrder.linearOrder [PartialOrder α] [IsTotal α (· ≤ ·)] :
    LinearOrder (AsLinearOrder α) 
goal: LinearOrder (AsLinearOrder α)

full_name: dite_nonneg
code: @[to_additive dite_nonneg]
lemma one_le_dite [LE α] (ha : ∀ h, 1 ≤ a h) (hb : ∀ h, 1 ≤ b h) : 1 ≤ dite p a b 
goal: 0 ≤ dite p a b

full_name: one_le_dite
code: @[to_additive dite_nonneg]
lemma one_le_dite [LE α] (ha : ∀ h, 1 ≤ a h) (hb : ∀ h, 1 ≤ b h) : 1 ≤ dite p a b 
goal: 1 ≤ dite p a b

full_name: dite_nonpos
code: @[to_additive]
lemma dite_le_one [LE α] (ha : ∀ h, a h ≤ 1) (hb : ∀ h, b h ≤ 1) : dite p a b ≤ 1 
goal: dite p a b ≤ 0

full_name: dite_le_one
code: @[to_additive]
lemma dite_le_one [LE α] (ha : ∀ h, a h ≤ 1) (hb : ∀ h, b h ≤ 1) : dite p a b ≤ 1 
goal: dite p a b ≤ 1

full_name: dite_pos
code: @[to_additive dite_pos]
lemma one_lt_dite [LT α] (ha : ∀ h, 1 < a h) (hb : ∀ h, 1 < b h) : 1 < dite p a b 
goal: 0 < dite p a b

full_name: one_lt_dite
code: @[to_additive dite_pos]
lemma one_lt_dite [LT α] (ha : ∀ h, 1 < a h) (hb : ∀ h, 1 < b h) : 1 < dite p a b 
goal: 1 < dite p a b

full_name: dite_neg
code: @[to_additive]
lemma dite_lt_one [LT α] (ha : ∀ h, a h < 1) (hb : ∀ h, b h < 1) : dite p a b < 1 
goal: dite p a b < 0

full_name: dite_lt_one
code: @[to_additive]
lemma dite_lt_one [LT α] (ha : ∀ h, a h < 1) (hb : ∀ h, b h < 1) : dite p a b < 1 
goal: dite p a b < 1

full_name: one_le_ite
code: @[to_additive ite_nonneg]
lemma one_le_ite [LE α] (ha : 1 ≤ a) (hb : 1 ≤ b) : 1 ≤ ite p a b 
goal: 1 ≤ if p then a else b

full_name: ite_nonneg
code: @[to_additive ite_nonneg]
lemma one_le_ite [LE α] (ha : 1 ≤ a) (hb : 1 ≤ b) : 1 ≤ ite p a b 
goal: 0 ≤ if p then a else b

full_name: ite_nonpos
code: @[to_additive]
lemma ite_le_one [LE α] (ha : a ≤ 1) (hb : b ≤ 1) : ite p a b ≤ 1 
goal: (if p then a else b) ≤ 0

full_name: ite_le_one
code: @[to_additive]
lemma ite_le_one [LE α] (ha : a ≤ 1) (hb : b ≤ 1) : ite p a b ≤ 1 
goal: (if p then a else b) ≤ 1

full_name: one_lt_ite
code: @[to_additive ite_pos]
lemma one_lt_ite [LT α] (ha : 1 < a) (hb : 1 < b) : 1 < ite p a b 
goal: 1 < if p then a else b

full_name: ite_pos
code: @[to_additive ite_pos]
lemma one_lt_ite [LT α] (ha : 1 < a) (hb : 1 < b) : 1 < ite p a b 
goal: 0 < if p then a else b

full_name: ite_lt_one
code: @[to_additive]
lemma ite_lt_one [LT α] (ha : a < 1) (hb : b < 1) : ite p a b < 1 
goal: (if p then a else b) < 1

full_name: ite_neg
code: @[to_additive]
lemma ite_lt_one [LT α] (ha : a < 1) (hb : b < 1) : ite p a b < 1 
goal: (if p then a else b) < 0