File: Mathlib/Init/Order/LinearOrder.lean

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

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

full_name: min_le_left
code: theorem min_le_left (a b : α) : min a b ≤ a 
goal: min a b ≤ a

full_name: min_le_right
code: theorem min_le_right (a b : α) : min a b ≤ b 
goal: min a b ≤ b

full_name: le_min
code: theorem le_min {a b c : α} (h₁ : c ≤ a) (h₂ : c ≤ b) : c ≤ min a b 
goal: c ≤ min a b

full_name: le_max_left
code: theorem le_max_left (a b : α) : a ≤ max a b 
goal: a ≤ max a b

full_name: le_max_right
code: theorem le_max_right (a b : α) : b ≤ max a b 
goal: b ≤ max a b

full_name: max_le
code: theorem max_le {a b c : α} (h₁ : a ≤ c) (h₂ : b ≤ c) : max a b ≤ c 
goal: max a b ≤ c

full_name: eq_min
code: theorem eq_min {a b c : α} (h₁ : c ≤ a) (h₂ : c ≤ b) (h₃ : ∀ {d}, d ≤ a → d ≤ b → d ≤ c) :
    c = min a b 
goal: c = min a b

full_name: min_comm
code: theorem min_comm (a b : α) : min a b = min b a 
goal: min a b = min b a

full_name: min_assoc
code: theorem min_assoc (a b c : α) : min (min a b) c = min a (min b c) 
goal: min (min a b) c = min a (min b c)

full_name: min_left_comm
code: theorem min_left_comm : ∀ a b c : α, min a (min b c) = min b (min a c) 
goal: min a (min b c) = min b (min a c)

full_name: min_self
code: @[simp]
theorem min_self (a : α) : min a a = a 
goal: min a a = a

full_name: min_eq_left
code: theorem min_eq_left {a b : α} (h : a ≤ b) : min a b = a 
goal: min a b = a

full_name: min_eq_right
code: theorem min_eq_right {a b : α} (h : b ≤ a) : min a b = b 
goal: min a b = b

full_name: eq_max
code: theorem eq_max {a b c : α} (h₁ : a ≤ c) (h₂ : b ≤ c) (h₃ : ∀ {d}, a ≤ d → b ≤ d → c ≤ d) :
    c = max a b 
goal: c = max a b

full_name: max_comm
code: theorem max_comm (a b : α) : max a b = max b a 
goal: max a b = max b a

full_name: max_assoc
code: theorem max_assoc (a b c : α) : max (max a b) c = max a (max b c) 
goal: max (max a b) c = max a (max b c)

full_name: max_left_comm
code: theorem max_left_comm : ∀ a b c : α, max a (max b c) = max b (max a c) 
goal: max a (max b c) = max b (max a c)

full_name: max_self
code: @[simp]
theorem max_self (a : α) : max a a = a 
goal: max a a = a

full_name: max_eq_left
code: theorem max_eq_left {a b : α} (h : b ≤ a) : max a b = a 
goal: max a b = a

full_name: max_eq_right
code: theorem max_eq_right {a b : α} (h : a ≤ b) : max a b = b 
goal: max a b = b

full_name: min_eq_left_of_lt
code: theorem min_eq_left_of_lt {a b : α} (h : a < b) : min a b = a 
goal: min a b = a

full_name: min_eq_right_of_lt
code: theorem min_eq_right_of_lt {a b : α} (h : b < a) : min a b = b 
goal: min a b = b

full_name: max_eq_left_of_lt
code: theorem max_eq_left_of_lt {a b : α} (h : b < a) : max a b = a 
goal: max a b = a

full_name: max_eq_right_of_lt
code: theorem max_eq_right_of_lt {a b : α} (h : a < b) : max a b = b 
goal: max a b = b

full_name: lt_min
code: theorem lt_min {a b c : α} (h₁ : a < b) (h₂ : a < c) : a < min b c 
goal: a < min b c

full_name: max_lt
code: theorem max_lt {a b c : α} (h₁ : a < c) (h₂ : b < c) : max a b < c 
goal: max a b < c