fact stringlengths 6 3.84k | type stringclasses 11
values | library stringclasses 32
values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
IsLeast.minimal (h : IsLeast s x) : Minimal (· ∈ s) x :=
⟨h.1, fun _b hb _ ↦ h.2 hb⟩ | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | IsLeast.minimal | null |
IsGreatest.maximal (h : IsGreatest s x) : Maximal (· ∈ s) x :=
⟨h.1, fun _b hb _ ↦ h.2 hb⟩ | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | IsGreatest.maximal | null |
IsLeast.minimal_iff (h : IsLeast s a) : Minimal (· ∈ s) x ↔ x = a :=
⟨fun h' ↦ h'.eq_of_ge h.1 (h.2 h'.prop), fun h' ↦ h' ▸ h.minimal⟩ | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | IsLeast.minimal_iff | null |
IsGreatest.maximal_iff (h : IsGreatest s a) : Maximal (· ∈ s) x ↔ x = a :=
⟨fun h' ↦ h'.eq_of_le h.1 (h.2 h'.prop), fun h' ↦ h' ▸ h.maximal⟩ | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | IsGreatest.maximal_iff | null |
minimal_mem_image_monotone (hf : ∀ ⦃x y⦄, x ∈ s → y ∈ s → (f x ≤ f y ↔ x ≤ y))
(hx : Minimal (· ∈ s) x) : Minimal (· ∈ f '' s) (f x) := by
refine ⟨mem_image_of_mem f hx.prop, ?_⟩
rintro _ ⟨y, hy, rfl⟩
rw [hf hx.prop hy, hf hy hx.prop]
exact hx.le_of_le hy | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | minimal_mem_image_monotone | null |
maximal_mem_image_monotone (hf : ∀ ⦃x y⦄, x ∈ s → y ∈ s → (f x ≤ f y ↔ x ≤ y))
(hx : Maximal (· ∈ s) x) : Maximal (· ∈ f '' s) (f x) :=
minimal_mem_image_monotone (α := αᵒᵈ) (β := βᵒᵈ) (s := s) (fun _ _ hx hy ↦ hf hy hx) hx | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | maximal_mem_image_monotone | null |
minimal_mem_image_monotone_iff (ha : a ∈ s)
(hf : ∀ ⦃x y⦄, x ∈ s → y ∈ s → (f x ≤ f y ↔ x ≤ y)) :
Minimal (· ∈ f '' s) (f a) ↔ Minimal (· ∈ s) a := by
refine ⟨fun h ↦ ⟨ha, fun y hys ↦ ?_⟩, minimal_mem_image_monotone hf⟩
rw [← hf ha hys, ← hf hys ha]
exact h.le_of_le (mem_image_of_mem f hys) | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | minimal_mem_image_monotone_iff | null |
maximal_mem_image_monotone_iff (ha : a ∈ s)
(hf : ∀ ⦃x y⦄, x ∈ s → y ∈ s → (f x ≤ f y ↔ x ≤ y)) :
Maximal (· ∈ f '' s) (f a) ↔ Maximal (· ∈ s) a :=
minimal_mem_image_monotone_iff (α := αᵒᵈ) (β := βᵒᵈ) (s := s) ha fun _ _ hx hy ↦ hf hy hx | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | maximal_mem_image_monotone_iff | null |
minimal_mem_image_antitone (hf : ∀ ⦃x y⦄, x ∈ s → y ∈ s → (f x ≤ f y ↔ y ≤ x))
(hx : Minimal (· ∈ s) x) : Maximal (· ∈ f '' s) (f x) :=
minimal_mem_image_monotone (β := βᵒᵈ) (fun _ _ h h' ↦ hf h' h) hx | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | minimal_mem_image_antitone | null |
maximal_mem_image_antitone (hf : ∀ ⦃x y⦄, x ∈ s → y ∈ s → (f x ≤ f y ↔ y ≤ x))
(hx : Maximal (· ∈ s) x) : Minimal (· ∈ f '' s) (f x) :=
maximal_mem_image_monotone (β := βᵒᵈ) (fun _ _ h h' ↦ hf h' h) hx | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | maximal_mem_image_antitone | null |
minimal_mem_image_antitone_iff (ha : a ∈ s)
(hf : ∀ ⦃x y⦄, x ∈ s → y ∈ s → (f x ≤ f y ↔ y ≤ x)) :
Minimal (· ∈ f '' s) (f a) ↔ Maximal (· ∈ s) a :=
maximal_mem_image_monotone_iff (β := βᵒᵈ) ha (fun _ _ h h' ↦ hf h' h) | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | minimal_mem_image_antitone_iff | null |
maximal_mem_image_antitone_iff (ha : a ∈ s)
(hf : ∀ ⦃x y⦄, x ∈ s → y ∈ s → (f x ≤ f y ↔ y ≤ x)) :
Maximal (· ∈ f '' s) (f a) ↔ Minimal (· ∈ s) a :=
minimal_mem_image_monotone_iff (β := βᵒᵈ) ha (fun _ _ h h' ↦ hf h' h) | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | maximal_mem_image_antitone_iff | null |
image_monotone_setOf_minimal (hf : ∀ ⦃x y⦄, P x → P y → (f x ≤ f y ↔ x ≤ y)) :
f '' {x | Minimal P x} = {x | Minimal (∃ x₀, P x₀ ∧ f x₀ = ·) x} := by
refine Set.ext fun x ↦ ⟨?_, fun h ↦ ?_⟩
· rintro ⟨x, (hx : Minimal _ x), rfl⟩
exact (minimal_mem_image_monotone_iff hx.prop hf).2 hx
obtain ⟨y, hy, rfl⟩ := ... | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | image_monotone_setOf_minimal | null |
image_monotone_setOf_maximal (hf : ∀ ⦃x y⦄, P x → P y → (f x ≤ f y ↔ x ≤ y)) :
f '' {x | Maximal P x} = {x | Maximal (∃ x₀, P x₀ ∧ f x₀ = ·) x} :=
image_monotone_setOf_minimal (α := αᵒᵈ) (β := βᵒᵈ) (fun _ _ hx hy ↦ hf hy hx) | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | image_monotone_setOf_maximal | null |
image_antitone_setOf_minimal (hf : ∀ ⦃x y⦄, P x → P y → (f x ≤ f y ↔ y ≤ x)) :
f '' {x | Minimal P x} = {x | Maximal (∃ x₀, P x₀ ∧ f x₀ = ·) x} :=
image_monotone_setOf_minimal (β := βᵒᵈ) (fun _ _ hx hy ↦ hf hy hx) | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | image_antitone_setOf_minimal | null |
image_antitone_setOf_maximal (hf : ∀ ⦃x y⦄, P x → P y → (f x ≤ f y ↔ y ≤ x)) :
f '' {x | Maximal P x} = {x | Minimal (∃ x₀, P x₀ ∧ f x₀ = ·) x} :=
image_monotone_setOf_maximal (β := βᵒᵈ) (fun _ _ hx hy ↦ hf hy hx) | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | image_antitone_setOf_maximal | null |
image_monotone_setOf_minimal_mem (hf : ∀ ⦃x y⦄, x ∈ s → y ∈ s → (f x ≤ f y ↔ x ≤ y)) :
f '' {x | Minimal (· ∈ s) x} = {x | Minimal (· ∈ f '' s) x} :=
image_monotone_setOf_minimal hf | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | image_monotone_setOf_minimal_mem | null |
image_monotone_setOf_maximal_mem (hf : ∀ ⦃x y⦄, x ∈ s → y ∈ s → (f x ≤ f y ↔ x ≤ y)) :
f '' {x | Maximal (· ∈ s) x} = {x | Maximal (· ∈ f '' s) x} :=
image_monotone_setOf_maximal hf | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | image_monotone_setOf_maximal_mem | null |
image_antitone_setOf_minimal_mem (hf : ∀ ⦃x y⦄, x ∈ s → y ∈ s → (f x ≤ f y ↔ y ≤ x)) :
f '' {x | Minimal (· ∈ s) x} = {x | Maximal (· ∈ f '' s) x} :=
image_antitone_setOf_minimal hf | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | image_antitone_setOf_minimal_mem | null |
image_antitone_setOf_maximal_mem (hf : ∀ ⦃x y⦄, x ∈ s → y ∈ s → (f x ≤ f y ↔ y ≤ x)) :
f '' {x | Maximal (· ∈ s) x} = {x | Minimal (· ∈ f '' s) x} :=
image_antitone_setOf_maximal hf | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | image_antitone_setOf_maximal_mem | null |
minimal_mem_image (f : α ↪o β) (hx : Minimal (· ∈ s) x) : Minimal (· ∈ f '' s) (f x) :=
_root_.minimal_mem_image_monotone (by simp [f.le_iff_le]) hx | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | minimal_mem_image | null |
maximal_mem_image (f : α ↪o β) (hx : Maximal (· ∈ s) x) : Maximal (· ∈ f '' s) (f x) :=
_root_.maximal_mem_image_monotone (by simp [f.le_iff_le]) hx | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | maximal_mem_image | null |
minimal_mem_image_iff (ha : a ∈ s) : Minimal (· ∈ f '' s) (f a) ↔ Minimal (· ∈ s) a :=
_root_.minimal_mem_image_monotone_iff ha (by simp [f.le_iff_le]) | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | minimal_mem_image_iff | null |
maximal_mem_image_iff (ha : a ∈ s) : Maximal (· ∈ f '' s) (f a) ↔ Maximal (· ∈ s) a :=
_root_.maximal_mem_image_monotone_iff ha (by simp [f.le_iff_le]) | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | maximal_mem_image_iff | null |
minimal_apply_mem_inter_range_iff :
Minimal (· ∈ t ∩ range f) (f x) ↔ Minimal (fun x ↦ f x ∈ t) x := by
refine ⟨fun h ↦ ⟨h.prop.1, fun y hy ↦ ?_⟩, fun h ↦ ⟨⟨h.prop, by simp⟩, ?_⟩⟩
· rw [← f.le_iff_le, ← f.le_iff_le]
exact h.le_of_le ⟨hy, by simp⟩
rintro _ ⟨hyt, ⟨y, rfl⟩⟩
simp_rw [f.le_iff_le]
exact h.... | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | minimal_apply_mem_inter_range_iff | null |
maximal_apply_mem_inter_range_iff :
Maximal (· ∈ t ∩ range f) (f x) ↔ Maximal (fun x ↦ f x ∈ t) x :=
f.dual.minimal_apply_mem_inter_range_iff | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | maximal_apply_mem_inter_range_iff | null |
minimal_apply_mem_iff (ht : t ⊆ Set.range f) :
Minimal (· ∈ t) (f x) ↔ Minimal (fun x ↦ f x ∈ t) x := by
rw [← f.minimal_apply_mem_inter_range_iff, inter_eq_self_of_subset_left ht] | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | minimal_apply_mem_iff | null |
maximal_apply_iff (ht : t ⊆ Set.range f) :
Maximal (· ∈ t) (f x) ↔ Maximal (fun x ↦ f x ∈ t) x :=
f.dual.minimal_apply_mem_iff ht
@[simp] theorem image_setOf_minimal : f '' {x | Minimal (· ∈ s) x} = {x | Minimal (· ∈ f '' s) x} :=
_root_.image_monotone_setOf_minimal (by simp [f.le_iff_le])
@[simp] theorem image... | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | maximal_apply_iff | null |
inter_preimage_setOf_minimal_eq_of_subset (hts : t ⊆ f '' s) :
x ∈ s ∩ f ⁻¹' {y | Minimal (· ∈ t) y} ↔ Minimal (· ∈ s ∩ f ⁻¹' t) x := by
simp_rw [mem_inter_iff, preimage_setOf_eq, mem_setOf_eq, mem_preimage,
f.minimal_apply_mem_iff (hts.trans (image_subset_range _ _)),
minimal_and_iff_left_of_imp (fun _ h... | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | inter_preimage_setOf_minimal_eq_of_subset | null |
inter_preimage_setOf_maximal_eq_of_subset (hts : t ⊆ f '' s) :
x ∈ s ∩ f ⁻¹' {y | Maximal (· ∈ t) y} ↔ Maximal (· ∈ s ∩ f ⁻¹' t) x :=
f.dual.inter_preimage_setOf_minimal_eq_of_subset hts | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | inter_preimage_setOf_maximal_eq_of_subset | null |
image_setOf_minimal (f : α ≃o β) (P : α → Prop) :
f '' {x | Minimal P x} = {x | Minimal (fun x ↦ P (f.symm x)) x} := by
convert _root_.image_monotone_setOf_minimal (f := f) (by simp [f.le_iff_le])
aesop | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | image_setOf_minimal | null |
image_setOf_maximal (f : α ≃o β) (P : α → Prop) :
f '' {x | Maximal P x} = {x | Maximal (fun x ↦ P (f.symm x)) x} := by
convert _root_.image_monotone_setOf_maximal (f := f) (by simp [f.le_iff_le])
aesop | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | image_setOf_maximal | null |
map_minimal_mem (f : s ≃o t) (hx : Minimal (· ∈ s) x) :
Minimal (· ∈ t) (f ⟨x, hx.prop⟩) := by
simpa only [show t = range (Subtype.val ∘ f) by simp, mem_univ, minimal_true_subtype, hx,
true_imp_iff, image_univ] using OrderEmbedding.minimal_mem_image
(f.toOrderEmbedding.trans (OrderEmbedding.subtype t)) (s... | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | map_minimal_mem | null |
map_maximal_mem (f : s ≃o t) (hx : Maximal (· ∈ s) x) :
Maximal (· ∈ t) (f ⟨x, hx.prop⟩) := by
simpa only [show t = range (Subtype.val ∘ f) by simp, mem_univ, maximal_true_subtype, hx,
true_imp_iff, image_univ] using OrderEmbedding.maximal_mem_image
(f.toOrderEmbedding.trans (OrderEmbedding.subtype t)) (s... | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | map_maximal_mem | null |
mapSetOfMinimal (f : s ≃o t) : {x | Minimal (· ∈ s) x} ≃o {x | Minimal (· ∈ t) x} where
toFun x := ⟨f ⟨x, x.2.1⟩, f.map_minimal_mem x.2⟩
invFun x := ⟨f.symm ⟨x, x.2.1⟩, f.symm.map_minimal_mem x.2⟩
left_inv x := Subtype.ext (congr_arg Subtype.val <| f.left_inv ⟨x, x.2.1⟩ :)
right_inv x := Subtype.ext (congr_arg ... | def | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | mapSetOfMinimal | If two sets are order isomorphic, their minimals are also order isomorphic. |
mapSetOfMaximal (f : s ≃o t) : {x | Maximal (· ∈ s) x} ≃o {x | Maximal (· ∈ t) x} where
toFun x := ⟨f ⟨x, x.2.1⟩, f.map_maximal_mem x.2⟩
invFun x := ⟨f.symm ⟨x, x.2.1⟩, f.symm.map_maximal_mem x.2⟩
left_inv x := Subtype.ext (congr_arg Subtype.val <| f.left_inv ⟨x, x.2.1⟩ :)
right_inv x := Subtype.ext (congr_arg ... | def | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | mapSetOfMaximal | If two sets are order isomorphic, their maximals are also order isomorphic. |
setOfMinimalIsoSetOfMaximal (f : s ≃o tᵒᵈ) :
{x | Minimal (· ∈ s) x} ≃o {x | Maximal (· ∈ t) (ofDual x)} where
toFun x := ⟨(f ⟨x.1, x.2.1⟩).1, ((show s ≃o ofDual ⁻¹' t from f).mapSetOfMinimal x).2⟩
invFun x := ⟨(f.symm ⟨x.1, x.2.1⟩).1,
((show ofDual ⁻¹' t ≃o s from f.symm).mapSetOfMinimal x).2⟩
... | def | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | setOfMinimalIsoSetOfMaximal | If two sets are antitonically order isomorphic, their minimals/maximals are too. |
setOfMaximalIsoSetOfMinimal (f : s ≃o tᵒᵈ) :
{x | Maximal (· ∈ s) x} ≃o {x | Minimal (· ∈ t) (ofDual x)} where
toFun x := ⟨(f ⟨x.1, x.2.1⟩).1, ((show s ≃o ofDual ⁻¹' t from f).mapSetOfMaximal x).2⟩
invFun x := ⟨(f.symm ⟨x.1, x.2.1⟩).1,
((show ofDual ⁻¹' t ≃o s from f.symm).mapSetOfMaximal x).2⟩
__ := ... | def | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | setOfMaximalIsoSetOfMinimal | If two sets are antitonically order isomorphic, their maximals/minimals are too. |
minimal_mem_Icc (hab : a ≤ b) : Minimal (· ∈ Icc a b) x ↔ x = a :=
minimal_iff_eq ⟨rfl.le, hab⟩ (fun _ ↦ And.left) | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | minimal_mem_Icc | null |
maximal_mem_Icc (hab : a ≤ b) : Maximal (· ∈ Icc a b) x ↔ x = b :=
maximal_iff_eq ⟨hab, rfl.le⟩ (fun _ ↦ And.right) | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | maximal_mem_Icc | null |
minimal_mem_Ico (hab : a < b) : Minimal (· ∈ Ico a b) x ↔ x = a :=
minimal_iff_eq ⟨rfl.le, hab⟩ (fun _ ↦ And.left) | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | minimal_mem_Ico | null |
maximal_mem_Ioc (hab : a < b) : Maximal (· ∈ Ioc a b) x ↔ x = b :=
maximal_iff_eq ⟨hab, rfl.le⟩ (fun _ ↦ And.right)
/- Note : The one-sided interval versions of these lemmas are unnecessary,
since `simp` handles them with `maximal_le_iff` and `minimal_ge_iff`. -/ | theorem | Order | [
"Mathlib.Order.Hom.Basic",
"Mathlib.Order.Interval.Set.Defs",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Minimal.lean | maximal_mem_Ioc | null |
le_min_iff : c ≤ min a b ↔ c ≤ a ∧ c ≤ b :=
le_inf_iff | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | le_min_iff | null |
le_max_iff : a ≤ max b c ↔ a ≤ b ∨ a ≤ c :=
le_sup_iff | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | le_max_iff | null |
min_le_iff : min a b ≤ c ↔ a ≤ c ∨ b ≤ c :=
inf_le_iff | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | min_le_iff | null |
max_le_iff : max a b ≤ c ↔ a ≤ c ∧ b ≤ c :=
sup_le_iff | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | max_le_iff | null |
lt_min_iff : a < min b c ↔ a < b ∧ a < c :=
lt_inf_iff | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | lt_min_iff | null |
lt_max_iff : a < max b c ↔ a < b ∨ a < c :=
lt_sup_iff | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | lt_max_iff | null |
min_lt_iff : min a b < c ↔ a < c ∨ b < c :=
inf_lt_iff | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | min_lt_iff | null |
max_lt_iff : max a b < c ↔ a < c ∧ b < c :=
sup_lt_iff | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | max_lt_iff | null |
max_le_max : a ≤ c → b ≤ d → max a b ≤ max c d :=
sup_le_sup | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | max_le_max | null |
max_le_max_left (c) (h : a ≤ b) : max c a ≤ max c b := sup_le_sup_left h c | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | max_le_max_left | null |
max_le_max_right (c) (h : a ≤ b) : max a c ≤ max b c := sup_le_sup_right h c | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | max_le_max_right | null |
min_le_min : a ≤ c → b ≤ d → min a b ≤ min c d :=
inf_le_inf | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | min_le_min | null |
min_le_min_left (c) (h : a ≤ b) : min c a ≤ min c b := inf_le_inf_left c h | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | min_le_min_left | null |
min_le_min_right (c) (h : a ≤ b) : min a c ≤ min b c := inf_le_inf_right c h | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | min_le_min_right | null |
le_max_of_le_left : a ≤ b → a ≤ max b c :=
le_sup_of_le_left | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | le_max_of_le_left | null |
le_max_of_le_right : a ≤ c → a ≤ max b c :=
le_sup_of_le_right | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | le_max_of_le_right | null |
lt_max_of_lt_left (h : a < b) : a < max b c :=
h.trans_le (le_max_left b c) | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | lt_max_of_lt_left | null |
lt_max_of_lt_right (h : a < c) : a < max b c :=
h.trans_le (le_max_right b c) | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | lt_max_of_lt_right | null |
min_le_of_left_le : a ≤ c → min a b ≤ c :=
inf_le_of_left_le | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | min_le_of_left_le | null |
min_le_of_right_le : b ≤ c → min a b ≤ c :=
inf_le_of_right_le | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | min_le_of_right_le | null |
min_lt_of_left_lt (h : a < c) : min a b < c :=
(min_le_left a b).trans_lt h | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | min_lt_of_left_lt | null |
min_lt_of_right_lt (h : b < c) : min a b < c :=
(min_le_right a b).trans_lt h | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | min_lt_of_right_lt | null |
max_min_distrib_left (a b c : α) : max a (min b c) = min (max a b) (max a c) :=
sup_inf_left _ _ _ | lemma | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | max_min_distrib_left | null |
max_min_distrib_right (a b c : α) : max (min a b) c = min (max a c) (max b c) :=
sup_inf_right _ _ _ | lemma | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | max_min_distrib_right | null |
min_max_distrib_left (a b c : α) : min a (max b c) = max (min a b) (min a c) :=
inf_sup_left _ _ _ | lemma | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | min_max_distrib_left | null |
min_max_distrib_right (a b c : α) : min (max a b) c = max (min a c) (min b c) :=
inf_sup_right _ _ _ | lemma | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | min_max_distrib_right | null |
min_le_max : min a b ≤ max a b :=
le_trans (min_le_left a b) (le_max_left a b) | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | min_le_max | null |
min_eq_left_iff : min a b = a ↔ a ≤ b :=
inf_eq_left | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | min_eq_left_iff | null |
min_eq_right_iff : min a b = b ↔ b ≤ a :=
inf_eq_right | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | min_eq_right_iff | null |
max_eq_left_iff : max a b = a ↔ b ≤ a :=
sup_eq_left | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | max_eq_left_iff | null |
max_eq_right_iff : max a b = b ↔ a ≤ b :=
sup_eq_right | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | max_eq_right_iff | null |
min_cases (a b : α) : min a b = a ∧ a ≤ b ∨ min a b = b ∧ b < a := by
by_cases h : a ≤ b
· left
exact ⟨min_eq_left h, h⟩
· right
exact ⟨min_eq_right (le_of_lt (not_le.mp h)), not_le.mp h⟩ | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | min_cases | 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 |
max_cases (a b : α) : max a b = a ∧ b ≤ a ∨ max a b = b ∧ a < b :=
@min_cases αᵒᵈ _ a b | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | max_cases | 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 |
min_eq_iff : min a b = c ↔ a = c ∧ a ≤ b ∨ b = c ∧ b ≤ a := by
constructor
· intro h
refine Or.imp (fun h' => ?_) (fun h' => ?_) (le_total a b) <;> exact ⟨by simpa [h'] using h, h'⟩
· rintro (⟨rfl, h⟩ | ⟨rfl, h⟩) <;> simp [h] | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | min_eq_iff | null |
max_eq_iff : max a b = c ↔ a = c ∧ b ≤ a ∨ b = c ∧ a ≤ b :=
@min_eq_iff αᵒᵈ _ a b c | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | max_eq_iff | null |
min_lt_min_left_iff : min a c < min b c ↔ a < b ∧ a < c := by
simp_rw [lt_min_iff, min_lt_iff, or_iff_left (lt_irrefl _)]
exact and_congr_left fun h => or_iff_left_of_imp h.trans | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | min_lt_min_left_iff | null |
min_lt_min_right_iff : min a b < min a c ↔ b < c ∧ b < a := by
simp_rw [min_comm a, min_lt_min_left_iff] | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | min_lt_min_right_iff | null |
max_lt_max_left_iff : max a c < max b c ↔ a < b ∧ c < b :=
@min_lt_min_left_iff αᵒᵈ _ _ _ _ | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | max_lt_max_left_iff | null |
max_lt_max_right_iff : max a b < max a c ↔ b < c ∧ a < c :=
@min_lt_min_right_iff αᵒᵈ _ _ _ _ | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | max_lt_max_right_iff | null |
max_idem : Std.IdempotentOp (α := α) max where
idempotent := by simp | instance | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | max_idem | An instance asserting that `max a a = a` |
min_idem : Std.IdempotentOp (α := α) min where
idempotent := by simp | instance | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | min_idem | An instance asserting that `min a a = a` |
min_lt_max : min a b < max a b ↔ a ≠ b :=
inf_lt_sup | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | min_lt_max | null |
max_lt_max (h₁ : a < c) (h₂ : b < d) : max a b < max c d :=
max_lt (lt_max_of_lt_left h₁) (lt_max_of_lt_right h₂) | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | max_lt_max | null |
min_lt_min (h₁ : a < c) (h₂ : b < d) : min a b < min c d :=
@max_lt_max αᵒᵈ _ _ _ _ _ h₁ h₂ | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | min_lt_min | null |
min_right_comm (a b c : α) : min (min a b) c = min (min a c) b := by
rw [min_assoc, min_comm b, min_assoc] | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | min_right_comm | null |
Max.left_comm (a b c : α) : max a (max b c) = max b (max a c) := by
rw [← max_assoc, max_comm a, max_assoc] | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | Max.left_comm | null |
Max.right_comm (a b c : α) : max (max a b) c = max (max a c) b := by
rw [max_assoc, max_comm b, max_assoc] | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | Max.right_comm | null |
MonotoneOn.map_max (hf : MonotoneOn f s) (ha : a ∈ s) (hb : b ∈ s) : f (max a b) =
max (f a) (f b) := by
rcases le_total a b with h | h <;>
simp only [max_eq_right, max_eq_left, hf ha hb, hf hb ha, h] | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | MonotoneOn.map_max | null |
MonotoneOn.map_min (hf : MonotoneOn f s) (ha : a ∈ s) (hb : b ∈ s) : f (min a b) =
min (f a) (f b) := hf.dual.map_max ha hb | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | MonotoneOn.map_min | null |
AntitoneOn.map_max (hf : AntitoneOn f s) (ha : a ∈ s) (hb : b ∈ s) : f (max a b) =
min (f a) (f b) := hf.dual_right.map_max ha hb | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | AntitoneOn.map_max | null |
AntitoneOn.map_min (hf : AntitoneOn f s) (ha : a ∈ s) (hb : b ∈ s) : f (min a b) =
max (f a) (f b) := hf.dual.map_max ha hb | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | AntitoneOn.map_min | null |
Monotone.map_max (hf : Monotone f) : f (max a b) = max (f a) (f b) := by
rcases le_total a b with h | h <;> simp [h, hf h] | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | Monotone.map_max | null |
Monotone.map_min (hf : Monotone f) : f (min a b) = min (f a) (f b) :=
hf.dual.map_max | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | Monotone.map_min | null |
Antitone.map_max (hf : Antitone f) : f (max a b) = min (f a) (f b) := by
rcases le_total a b with h | h <;> simp [h, hf h] | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | Antitone.map_max | null |
Antitone.map_min (hf : Antitone f) : f (min a b) = max (f a) (f b) :=
hf.dual.map_max | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | Antitone.map_min | null |
min_choice (a b : α) : min a b = a ∨ min a b = b := by cases le_total a b <;> simp [*] | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | min_choice | null |
max_choice (a b : α) : max a b = a ∨ max a b = b :=
@min_choice αᵒᵈ _ a b | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | max_choice | null |
le_of_max_le_left {a b c : α} (h : max a b ≤ c) : a ≤ c :=
le_trans (le_max_left _ _) h | theorem | Order | [
"Mathlib.Logic.OpClass",
"Mathlib.Order.Lattice"
] | Mathlib/Order/MinMax.lean | le_of_max_le_left | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.