File: Mathlib/Order/MinMax.lean

full_name: le_min_iff
code: @[simp]
theorem le_min_iff : c ≤ min a b ↔ c ≤ a ∧ c ≤ b 
goal: c ≤ min a b ↔ c ≤ a ∧ c ≤ b

full_name: le_max_iff
code: @[simp]
theorem le_max_iff : a ≤ max b c ↔ a ≤ b ∨ a ≤ c 
goal: a ≤ max b c ↔ a ≤ b ∨ a ≤ c

full_name: min_le_iff
code: @[simp]
theorem min_le_iff : min a b ≤ c ↔ a ≤ c ∨ b ≤ c 
goal: min a b ≤ c ↔ a ≤ c ∨ b ≤ c

full_name: max_le_iff
code: @[simp]
theorem max_le_iff : max a b ≤ c ↔ a ≤ c ∧ b ≤ c 
goal: max a b ≤ c ↔ a ≤ c ∧ b ≤ c

full_name: lt_min_iff
code: @[simp]
theorem lt_min_iff : a < min b c ↔ a < b ∧ a < c 
goal: a < min b c ↔ a < b ∧ a < c

full_name: lt_max_iff
code: @[simp]
theorem lt_max_iff : a < max b c ↔ a < b ∨ a < c 
goal: a < max b c ↔ a < b ∨ a < c

full_name: min_lt_iff
code: @[simp]
theorem min_lt_iff : min a b < c ↔ a < c ∨ b < c 
goal: min a b < c ↔ a < c ∨ b < c

full_name: max_lt_iff
code: @[simp]
theorem max_lt_iff : max a b < c ↔ a < c ∧ b < c 
goal: max a b < c ↔ a < c ∧ b < c

full_name: max_le_max
code: @[gcongr]
theorem max_le_max : a ≤ c → b ≤ d → max a b ≤ max c d 
goal: a ≤ c → b ≤ d → max a b ≤ max c d

full_name: max_le_max_left
code: @[gcongr] theorem max_le_max_left (c) (h : a ≤ b) : max c a ≤ max c b 
goal: max c a ≤ max c b

full_name: max_le_max_right
code: @[gcongr] theorem max_le_max_right (c) (h : a ≤ b) : max a c ≤ max b c 
goal: max a c ≤ max b c

full_name: min_le_min
code: @[gcongr]
theorem min_le_min : a ≤ c → b ≤ d → min a b ≤ min c d 
goal: a ≤ c → b ≤ d → min a b ≤ min c d

full_name: min_le_min_left
code: @[gcongr] theorem min_le_min_left (c) (h : a ≤ b) : min c a ≤ min c b 
goal: min c a ≤ min c b

full_name: min_le_min_right
code: @[gcongr] theorem min_le_min_right (c) (h : a ≤ b) : min a c ≤ min b c 
goal: min a c ≤ min b c

full_name: le_max_of_le_left
code: theorem le_max_of_le_left : a ≤ b → a ≤ max b c 
goal: a ≤ b → a ≤ max b c

full_name: le_max_of_le_right
code: theorem le_max_of_le_right : a ≤ c → a ≤ max b c 
goal: a ≤ c → a ≤ max b c

full_name: lt_max_of_lt_left
code: theorem lt_max_of_lt_left (h : a < b) : a < max b c 
goal: a < max b c

full_name: lt_max_of_lt_right
code: theorem lt_max_of_lt_right (h : a < c) : a < max b c 
goal: a < max b c

full_name: min_le_of_left_le
code: theorem min_le_of_left_le : a ≤ c → min a b ≤ c 
goal: a ≤ c → min a b ≤ c

full_name: min_le_of_right_le
code: theorem min_le_of_right_le : b ≤ c → min a b ≤ c 
goal: b ≤ c → min a b ≤ c

full_name: min_lt_of_left_lt
code: theorem min_lt_of_left_lt (h : a < c) : min a b < c 
goal: min a b < c

full_name: min_lt_of_right_lt
code: theorem min_lt_of_right_lt (h : b < c) : min a b < c 
goal: min a b < c

full_name: max_min_distrib_left
code: lemma max_min_distrib_left (a b c : α) : max a (min b c) = min (max a b) (max a c) 
goal: max a (min b c) = min (max a b) (max a c)

full_name: max_min_distrib_right
code: lemma max_min_distrib_right (a b c : α) : max (min a b) c = min (max a c) (max b c) 
goal: max (min a b) c = min (max a c) (max b c)

full_name: min_max_distrib_left
code: lemma min_max_distrib_left (a b c : α) : min a (max b c) = max (min a b) (min a c) 
goal: min a (max b c) = max (min a b) (min a c)

full_name: min_max_distrib_right
code: lemma min_max_distrib_right (a b c : α) : min (max a b) c = max (min a c) (min b c) 
goal: min (max a b) c = max (min a c) (min b c)

full_name: min_le_max
code: theorem min_le_max : min a b ≤ max a b 
goal: min a b ≤ max a b

full_name: min_eq_left_iff
code: @[simp]
theorem min_eq_left_iff : min a b = a ↔ a ≤ b 
goal: min a b = a ↔ a ≤ b

full_name: min_eq_right_iff
code: @[simp]
theorem min_eq_right_iff : min a b = b ↔ b ≤ a 
goal: min a b = b ↔ b ≤ a

full_name: max_eq_left_iff
code: @[simp]
theorem max_eq_left_iff : max a b = a ↔ b ≤ a 
goal: max a b = a ↔ b ≤ a

full_name: max_eq_right_iff
code: @[simp]
theorem max_eq_right_iff : max a b = b ↔ a ≤ b 
goal: max a b = b ↔ a ≤ b

full_name: min_cases
code: /-- For elements `a` and `b` of a linear order, either `min a b = a` and `a ≤ b`,
    or `min a b = b` and `b < a`.
    Use cases on this lemma to automate linarith in inequalities -/
theorem min_cases (a b : α) : min a b = a ∧ a ≤ b ∨ min a b = b ∧ b < a 
goal: min a b = a ∧ a ≤ b ∨ min a b = b ∧ b < a

full_name: max_cases
code: /-- For elements `a` and `b` of a linear order, either `max a b = a` and `b ≤ a`,
    or `max a b = b` and `a < b`.
    Use cases on this lemma to automate linarith in inequalities -/
theorem max_cases (a b : α) : max a b = a ∧ b ≤ a ∨ max a b = b ∧ a < b 
goal: max a b = a ∧ b ≤ a ∨ max a b = b ∧ a < b

full_name: min_eq_iff
code: theorem min_eq_iff : min a b = c ↔ a = c ∧ a ≤ b ∨ b = c ∧ b ≤ a 
goal: min a b = c ↔ a = c ∧ a ≤ b ∨ b = c ∧ b ≤ a

full_name: max_eq_iff
code: theorem max_eq_iff : max a b = c ↔ a = c ∧ b ≤ a ∨ b = c ∧ a ≤ b 
goal: max a b = c ↔ a = c ∧ b ≤ a ∨ b = c ∧ a ≤ b

full_name: min_lt_min_left_iff
code: theorem min_lt_min_left_iff : min a c < min b c ↔ a < b ∧ a < c 
goal: min a c < min b c ↔ a < b ∧ a < c

full_name: min_lt_min_right_iff
code: theorem min_lt_min_right_iff : min a b < min a c ↔ b < c ∧ b < a 
goal: min a b < min a c ↔ b < c ∧ b < a

full_name: max_lt_max_left_iff
code: theorem max_lt_max_left_iff : max a c < max b c ↔ a < b ∧ c < b 
goal: max a c < max b c ↔ a < b ∧ c < b

full_name: max_lt_max_right_iff
code: theorem max_lt_max_right_iff : max a b < max a c ↔ b < c ∧ a < c 
goal: max a b < max a c ↔ b < c ∧ a < c

full_name: max_idem
code: /-- An instance asserting that `max a a = a` -/
instance max_idem : Std.IdempotentOp (α := α) max 
goal: Std.IdempotentOp max

full_name: min_idem
code: /-- An instance asserting that `min a a = a` -/
instance min_idem : Std.IdempotentOp (α := α) min 
goal: Std.IdempotentOp min

full_name: min_lt_max
code: theorem min_lt_max : min a b < max a b ↔ a ≠ b 
goal: min a b < max a b ↔ a ≠ b

full_name: max_lt_max
code: theorem max_lt_max (h₁ : a < c) (h₂ : b < d) : max a b < max c d 
goal: max a b < max c d

full_name: min_lt_min
code: theorem min_lt_min (h₁ : a < c) (h₂ : b < d) : min a b < min c d 
goal: min a b < min c d

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

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.right_comm
code: theorem Max.right_comm (a b c : α) : max (max a b) c = max (max a c) b 
goal: max (max a b) c = max (max a c) b

full_name: MonotoneOn.map_max
code: theorem MonotoneOn.map_max (hf : MonotoneOn f s) (ha : a ∈ s) (hb : b ∈ s) : f (max a b) =
    max (f a) (f b) 
goal: f (max a b) = max (f a) (f b)

full_name: MonotoneOn.map_min
code: theorem MonotoneOn.map_min (hf : MonotoneOn f s) (ha : a ∈ s) (hb : b ∈ s) : f (min a b) =
    min (f a) (f b) 
goal: f (min a b) = min (f a) (f b)

full_name: AntitoneOn.map_max
code: theorem AntitoneOn.map_max (hf : AntitoneOn f s) (ha : a ∈ s) (hb : b ∈ s) : f (max a b) =
    min (f a) (f b) 
goal: f (max a b) = min (f a) (f b)

full_name: AntitoneOn.map_min
code: theorem AntitoneOn.map_min (hf : AntitoneOn f s) (ha : a ∈ s) (hb : b ∈ s) : f (min a b) =
    max (f a) (f b) 
goal: f (min a b) = max (f a) (f b)

full_name: Monotone.map_max
code: theorem Monotone.map_max (hf : Monotone f) : f (max a b) = max (f a) (f b) 
goal: f (max a b) = max (f a) (f b)

full_name: Monotone.map_min
code: theorem Monotone.map_min (hf : Monotone f) : f (min a b) = min (f a) (f b) 
goal: f (min a b) = min (f a) (f b)

full_name: Antitone.map_max
code: theorem Antitone.map_max (hf : Antitone f) : f (max a b) = min (f a) (f b) 
goal: f (max a b) = min (f a) (f b)

full_name: Antitone.map_min
code: theorem Antitone.map_min (hf : Antitone f) : f (min a b) = max (f a) (f b) 
goal: f (min a b) = max (f a) (f b)

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

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

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

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

full_name: max_commutative
code: theorem max_commutative : Commutative (max : α → α → α) 
goal: Commutative max

full_name: max_associative
code: theorem max_associative : Associative (max : α → α → α) 
goal: Associative max

full_name: instCommutativeMax_mathlib
code: instance : Std.Commutative (α := α) max 
goal: Std.Commutative max

full_name: instAssociativeMax_mathlib
code: instance : Std.Associative (α := α) max 
goal: Std.Associative max

full_name: max_left_commutative
code: theorem max_left_commutative : LeftCommutative (max : α → α → α) 
goal: LeftCommutative max

full_name: min_commutative
code: theorem min_commutative : Commutative (min : α → α → α) 
goal: Commutative min

full_name: min_associative
code: theorem min_associative : Associative (α := α) min 
goal: Associative min

full_name: instCommutativeMin_mathlib
code: instance : Std.Commutative (α := α) min 
goal: Std.Commutative min

full_name: instAssociativeMin_mathlib
code: instance : Std.Associative (α := α) min 
goal: Std.Associative min

full_name: min_left_commutative
code: theorem min_left_commutative : LeftCommutative (min : α → α → α) 
goal: LeftCommutative min