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 ⌀ |
|---|---|---|---|---|---|---|
codisjoint_ofDual_iff [PartialOrder α] [OrderTop α] {a b : αᵒᵈ} :
Codisjoint (ofDual a) (ofDual b) ↔ Disjoint a b :=
Iff.rfl | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | codisjoint_ofDual_iff | null |
Disjoint.le_of_codisjoint (hab : Disjoint a b) (hbc : Codisjoint b c) : a ≤ c := by
rw [← @inf_top_eq _ _ _ a, ← @bot_sup_eq _ _ _ c, ← hab.eq_bot, ← hbc.eq_top, sup_inf_right]
exact inf_le_inf_right _ le_sup_left | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | Disjoint.le_of_codisjoint | null |
IsCompl [PartialOrder α] [BoundedOrder α] (x y : α) : Prop where
/-- If `x` and `y` are to be complementary in an order, they should be disjoint. -/
protected disjoint : Disjoint x y
/-- If `x` and `y` are to be complementary in an order, they should be codisjoint. -/
protected codisjoint : Codisjoint x y | structure | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | IsCompl | Two elements `x` and `y` are complements of each other if `x ⊔ y = ⊤` and `x ⊓ y = ⊥`. |
isCompl_iff [PartialOrder α] [BoundedOrder α] {a b : α} :
IsCompl a b ↔ Disjoint a b ∧ Codisjoint a b :=
⟨fun h ↦ ⟨h.1, h.2⟩, fun h ↦ ⟨h.1, h.2⟩⟩ | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | isCompl_iff | null |
@[symm]
protected symm (h : IsCompl x y) : IsCompl y x :=
⟨h.1.symm, h.2.symm⟩ | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | symm | null |
_root_.isCompl_comm : IsCompl x y ↔ IsCompl y x := ⟨IsCompl.symm, IsCompl.symm⟩ | lemma | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | _root_.isCompl_comm | null |
dual (h : IsCompl x y) : IsCompl (toDual x) (toDual y) :=
⟨h.2, h.1⟩ | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | dual | null |
ofDual {a b : αᵒᵈ} (h : IsCompl a b) : IsCompl (ofDual a) (ofDual b) :=
⟨h.2, h.1⟩ | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | ofDual | null |
of_le (h₁ : x ⊓ y ≤ ⊥) (h₂ : ⊤ ≤ x ⊔ y) : IsCompl x y :=
⟨disjoint_iff_inf_le.mpr h₁, codisjoint_iff_le_sup.mpr h₂⟩ | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | of_le | null |
of_eq (h₁ : x ⊓ y = ⊥) (h₂ : x ⊔ y = ⊤) : IsCompl x y :=
⟨disjoint_iff.mpr h₁, codisjoint_iff.mpr h₂⟩ | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | of_eq | null |
inf_eq_bot (h : IsCompl x y) : x ⊓ y = ⊥ :=
h.disjoint.eq_bot | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | inf_eq_bot | null |
sup_eq_top (h : IsCompl x y) : x ⊔ y = ⊤ :=
h.codisjoint.eq_top | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | sup_eq_top | null |
inf_left_le_of_le_sup_right (h : IsCompl x y) (hle : a ≤ b ⊔ y) : a ⊓ x ≤ b :=
calc
a ⊓ x ≤ (b ⊔ y) ⊓ x := inf_le_inf hle le_rfl
_ = b ⊓ x ⊔ y ⊓ x := inf_sup_right _ _ _
_ = b ⊓ x := by rw [h.symm.inf_eq_bot, sup_bot_eq]
_ ≤ b := inf_le_left | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | inf_left_le_of_le_sup_right | null |
le_sup_right_iff_inf_left_le {a b} (h : IsCompl x y) : a ≤ b ⊔ y ↔ a ⊓ x ≤ b :=
⟨h.inf_left_le_of_le_sup_right, h.symm.dual.inf_left_le_of_le_sup_right⟩ | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | le_sup_right_iff_inf_left_le | null |
inf_left_eq_bot_iff (h : IsCompl y z) : x ⊓ y = ⊥ ↔ x ≤ z := by
rw [← le_bot_iff, ← h.le_sup_right_iff_inf_left_le, bot_sup_eq] | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | inf_left_eq_bot_iff | null |
inf_right_eq_bot_iff (h : IsCompl y z) : x ⊓ z = ⊥ ↔ x ≤ y :=
h.symm.inf_left_eq_bot_iff | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | inf_right_eq_bot_iff | null |
disjoint_left_iff (h : IsCompl y z) : Disjoint x y ↔ x ≤ z := by
rw [disjoint_iff]
exact h.inf_left_eq_bot_iff | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | disjoint_left_iff | null |
disjoint_right_iff (h : IsCompl y z) : Disjoint x z ↔ x ≤ y :=
h.symm.disjoint_left_iff | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | disjoint_right_iff | null |
le_left_iff (h : IsCompl x y) : z ≤ x ↔ Disjoint z y :=
h.disjoint_right_iff.symm | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | le_left_iff | null |
le_right_iff (h : IsCompl x y) : z ≤ y ↔ Disjoint z x :=
h.symm.le_left_iff | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | le_right_iff | null |
left_le_iff (h : IsCompl x y) : x ≤ z ↔ Codisjoint z y :=
h.dual.le_left_iff | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | left_le_iff | null |
right_le_iff (h : IsCompl x y) : y ≤ z ↔ Codisjoint z x :=
h.symm.left_le_iff | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | right_le_iff | null |
protected Antitone {x' y'} (h : IsCompl x y) (h' : IsCompl x' y') (hx : x ≤ x') : y' ≤ y :=
h'.right_le_iff.2 <| h.symm.codisjoint.mono_right hx | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | Antitone | null |
right_unique (hxy : IsCompl x y) (hxz : IsCompl x z) : y = z :=
le_antisymm (hxz.Antitone hxy <| le_refl x) (hxy.Antitone hxz <| le_refl x) | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | right_unique | null |
left_unique (hxz : IsCompl x z) (hyz : IsCompl y z) : x = y :=
hxz.symm.right_unique hyz.symm | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | left_unique | null |
sup_inf {x' y'} (h : IsCompl x y) (h' : IsCompl x' y') : IsCompl (x ⊔ x') (y ⊓ y') :=
of_eq
(by rw [inf_sup_right, ← inf_assoc, h.inf_eq_bot, bot_inf_eq, bot_sup_eq, inf_left_comm,
h'.inf_eq_bot, inf_bot_eq])
(by rw [sup_inf_left, sup_comm x, sup_assoc, h.sup_eq_top, sup_top_eq, top_inf_eq,
sup_as... | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | sup_inf | null |
inf_sup {x' y'} (h : IsCompl x y) (h' : IsCompl x' y') : IsCompl (x ⊓ x') (y ⊔ y') :=
(h.symm.sup_inf h'.symm).symm | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | inf_sup | null |
protected disjoint_iff [OrderBot α] [OrderBot β] {x y : α × β} :
Disjoint x y ↔ Disjoint x.1 y.1 ∧ Disjoint x.2 y.2 := by
constructor
· intro h
refine ⟨fun a hx hy ↦ (@h (a, ⊥) ⟨hx, ?_⟩ ⟨hy, ?_⟩).1,
fun b hx hy ↦ (@h (⊥, b) ⟨?_, hx⟩ ⟨?_, hy⟩).2⟩
all_goals exact bot_le
· rintro ⟨ha, hb⟩ z hza hzb... | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | disjoint_iff | null |
protected codisjoint_iff [OrderTop α] [OrderTop β] {x y : α × β} :
Codisjoint x y ↔ Codisjoint x.1 y.1 ∧ Codisjoint x.2 y.2 :=
@Prod.disjoint_iff αᵒᵈ βᵒᵈ _ _ _ _ _ _ | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | codisjoint_iff | null |
protected isCompl_iff [BoundedOrder α] [BoundedOrder β] {x y : α × β} :
IsCompl x y ↔ IsCompl x.1 y.1 ∧ IsCompl x.2 y.2 := by
simp_rw [isCompl_iff, Prod.disjoint_iff, Prod.codisjoint_iff, and_and_and_comm] | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | isCompl_iff | null |
@[simp]
isCompl_toDual_iff : IsCompl (toDual a) (toDual b) ↔ IsCompl a b :=
⟨IsCompl.ofDual, IsCompl.dual⟩
@[simp] | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | isCompl_toDual_iff | null |
isCompl_ofDual_iff {a b : αᵒᵈ} : IsCompl (ofDual a) (ofDual b) ↔ IsCompl a b :=
⟨IsCompl.dual, IsCompl.ofDual⟩ | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | isCompl_ofDual_iff | null |
isCompl_bot_top : IsCompl (⊥ : α) ⊤ :=
IsCompl.of_eq (bot_inf_eq _) (sup_top_eq _) | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | isCompl_bot_top | null |
isCompl_top_bot : IsCompl (⊤ : α) ⊥ :=
IsCompl.of_eq (inf_bot_eq _) (top_sup_eq _) | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | isCompl_top_bot | null |
eq_top_of_isCompl_bot (h : IsCompl x ⊥) : x = ⊤ := by rw [← sup_bot_eq x, h.sup_eq_top] | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | eq_top_of_isCompl_bot | null |
eq_top_of_bot_isCompl (h : IsCompl ⊥ x) : x = ⊤ :=
eq_top_of_isCompl_bot h.symm | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | eq_top_of_bot_isCompl | null |
eq_bot_of_isCompl_top (h : IsCompl x ⊤) : x = ⊥ :=
eq_top_of_isCompl_bot h.dual | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | eq_bot_of_isCompl_top | null |
eq_bot_of_top_isCompl (h : IsCompl ⊤ x) : x = ⊥ :=
eq_top_of_bot_isCompl h.dual | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | eq_bot_of_top_isCompl | null |
IsComplemented (a : α) : Prop :=
∃ b, IsCompl a b | def | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | IsComplemented | An element is *complemented* if it has a complement. |
isComplemented_bot : IsComplemented (⊥ : α) :=
⟨⊤, isCompl_bot_top⟩ | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | isComplemented_bot | null |
isComplemented_top : IsComplemented (⊤ : α) :=
⟨⊥, isCompl_top_bot⟩ | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | isComplemented_top | null |
IsComplemented.sup : IsComplemented a → IsComplemented b → IsComplemented (a ⊔ b) :=
fun ⟨a', ha⟩ ⟨b', hb⟩ => ⟨a' ⊓ b', ha.sup_inf hb⟩ | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | IsComplemented.sup | null |
IsComplemented.inf : IsComplemented a → IsComplemented b → IsComplemented (a ⊓ b) :=
fun ⟨a', ha⟩ ⟨b', hb⟩ => ⟨a' ⊔ b', ha.inf_sup hb⟩ | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | IsComplemented.inf | null |
ComplementedLattice (α) [Lattice α] [BoundedOrder α] : Prop where
/-- In a `ComplementedLattice`, every element admits a complement. -/
exists_isCompl : ∀ a : α, ∃ b : α, IsCompl a b | class | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | ComplementedLattice | A complemented bounded lattice is one where every element has a (not necessarily unique)
complement. |
complementedLattice_iff (α) [Lattice α] [BoundedOrder α] :
ComplementedLattice α ↔ ∀ a : α, ∃ b : α, IsCompl a b :=
⟨fun ⟨h⟩ ↦ h, fun h ↦ ⟨h⟩⟩
export ComplementedLattice (exists_isCompl) | lemma | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | complementedLattice_iff | null |
Subsingleton.instComplementedLattice
[Lattice α] [BoundedOrder α] [Subsingleton α] : ComplementedLattice α := by
refine ⟨fun a ↦ ⟨⊥, disjoint_bot_right, ?_⟩⟩
rw [Subsingleton.elim ⊥ ⊤]
exact codisjoint_top_right | lemma | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | Subsingleton.instComplementedLattice | null |
Complementeds (α : Type*) [Lattice α] [BoundedOrder α] : Type _ :=
{a : α // IsComplemented a} | abbrev | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | Complementeds | The sublattice of complemented elements. |
hasCoeT : CoeTC (Complementeds α) α := ⟨Subtype.val⟩ | instance | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | hasCoeT | null |
coe_injective : Injective ((↑) : Complementeds α → α) := Subtype.coe_injective
@[simp, norm_cast] | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | coe_injective | null |
coe_inj : (a : α) = b ↔ a = b := Subtype.coe_inj
@[norm_cast] | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | coe_inj | null |
coe_le_coe : (a : α) ≤ b ↔ a ≤ b := by simp
@[norm_cast] | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | coe_le_coe | null |
coe_lt_coe : (a : α) < b ↔ a < b := by simp | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | coe_lt_coe | null |
@[simp, norm_cast]
coe_bot : ((⊥ : Complementeds α) : α) = ⊥ := rfl
@[simp, norm_cast] | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | coe_bot | null |
coe_top : ((⊤ : Complementeds α) : α) = ⊤ := rfl | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | coe_top | null |
mk_bot : (⟨⊥, isComplemented_bot⟩ : Complementeds α) = ⊥ := by simp | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | mk_bot | null |
mk_top : (⟨⊤, isComplemented_top⟩ : Complementeds α) = ⊤ := by simp | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | mk_top | null |
@[simp, norm_cast]
coe_sup (a b : Complementeds α) : ↑(a ⊔ b) = (a : α) ⊔ b := rfl
@[simp, norm_cast] | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | coe_sup | null |
coe_inf (a b : Complementeds α) : ↑(a ⊓ b) = (a : α) ⊓ b := rfl
@[simp] | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | coe_inf | null |
mk_sup_mk {a b : α} (ha : IsComplemented a) (hb : IsComplemented b) :
(⟨a, ha⟩ ⊔ ⟨b, hb⟩ : Complementeds α) = ⟨a ⊔ b, ha.sup hb⟩ := rfl
@[simp] | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | mk_sup_mk | null |
mk_inf_mk {a b : α} (ha : IsComplemented a) (hb : IsComplemented b) :
(⟨a, ha⟩ ⊓ ⟨b, hb⟩ : Complementeds α) = ⟨a ⊓ b, ha.inf hb⟩ := rfl | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | mk_inf_mk | null |
@[simp, norm_cast]
disjoint_coe : Disjoint (a : α) b ↔ Disjoint a b := by
rw [disjoint_iff, disjoint_iff, ← coe_inf, ← coe_bot, coe_inj]
@[simp, norm_cast] | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | disjoint_coe | null |
codisjoint_coe : Codisjoint (a : α) b ↔ Codisjoint a b := by
rw [codisjoint_iff, codisjoint_iff, ← coe_sup, ← coe_top, coe_inj]
@[simp, norm_cast] | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | codisjoint_coe | null |
isCompl_coe : IsCompl (a : α) b ↔ IsCompl a b := by
simp_rw [isCompl_iff, disjoint_coe, codisjoint_coe] | theorem | Order | [
"Aesop",
"Mathlib.Order.BoundedOrder.Lattice"
] | Mathlib/Order/Disjoint.lean | isCompl_coe | null |
disjointed (f : ι → α) (i : ι) : α := f i \ (Iio i).sup f | def | Order | [
"Mathlib.Order.PartialSups",
"Mathlib.Order.Interval.Finset.Fin"
] | Mathlib/Order/Disjointed.lean | disjointed | The function mapping `i` to `f i \ (⨆ j < i, f j)`. When `ι` is a partial order, this is the
unique function `g` having the same `partialSups` as `f` and such that `g i` and `g j` are
disjoint whenever `i < j`. |
disjointed_apply (f : ι → α) (i : ι) : disjointed f i = f i \ (Iio i).sup f := rfl | lemma | Order | [
"Mathlib.Order.PartialSups",
"Mathlib.Order.Interval.Finset.Fin"
] | Mathlib/Order/Disjointed.lean | disjointed_apply | null |
disjointed_of_isMin (f : ι → α) {i : ι} (hn : IsMin i) :
disjointed f i = f i := by
have : Iio i = ∅ := by rwa [← Finset.coe_eq_empty, coe_Iio, Set.Iio_eq_empty_iff]
simp only [disjointed_apply, this, sup_empty, sdiff_bot]
@[simp] lemma disjointed_bot [OrderBot ι] (f : ι → α) : disjointed f ⊥ = f ⊥ :=
disjoin... | lemma | Order | [
"Mathlib.Order.PartialSups",
"Mathlib.Order.Interval.Finset.Fin"
] | Mathlib/Order/Disjointed.lean | disjointed_of_isMin | null |
disjointed_le_id : disjointed ≤ (id : (ι → α) → ι → α) :=
fun _ _ ↦ sdiff_le | theorem | Order | [
"Mathlib.Order.PartialSups",
"Mathlib.Order.Interval.Finset.Fin"
] | Mathlib/Order/Disjointed.lean | disjointed_le_id | null |
disjointed_le (f : ι → α) : disjointed f ≤ f :=
disjointed_le_id f | theorem | Order | [
"Mathlib.Order.PartialSups",
"Mathlib.Order.Interval.Finset.Fin"
] | Mathlib/Order/Disjointed.lean | disjointed_le | null |
disjoint_disjointed_of_lt (f : ι → α) {i j : ι} (h : i < j) :
Disjoint (disjointed f i) (disjointed f j) :=
(disjoint_sdiff_self_right.mono_left <| le_sup (mem_Iio.mpr h)).mono_left (disjointed_le f i) | theorem | Order | [
"Mathlib.Order.PartialSups",
"Mathlib.Order.Interval.Finset.Fin"
] | Mathlib/Order/Disjointed.lean | disjoint_disjointed_of_lt | null |
disjointed_eq_self {f : ι → α} {i : ι} (hf : ∀ j < i, Disjoint (f j) (f i)) :
disjointed f i = f i := by
rw [disjointed_apply, sdiff_eq_left, disjoint_iff, sup_inf_distrib_left,
sup_congr rfl <| fun j hj ↦ disjoint_iff.mp <| (hf _ (mem_Iio.mp hj)).symm]
exact sup_bot _
/- NB: The original statement for `ι =... | lemma | Order | [
"Mathlib.Order.PartialSups",
"Mathlib.Order.Interval.Finset.Fin"
] | Mathlib/Order/Disjointed.lean | disjointed_eq_self | null |
disjointedRec {f : ι → α} {p : α → Prop} (hdiff : ∀ ⦃t i⦄, p t → p (t \ f i)) :
∀ ⦃i⦄, p (f i) → p (disjointed f i) := by
classical
intro i hpi
rw [disjointed]
suffices ∀ (s : Finset ι), p (f i \ s.sup f) from this _
intro s
induction s using Finset.induction with
| empty => simpa only [sup_empty, sdi... | lemma | Order | [
"Mathlib.Order.PartialSups",
"Mathlib.Order.Interval.Finset.Fin"
] | Mathlib/Order/Disjointed.lean | disjointedRec | An induction principle for `disjointed`. To prove something about `disjointed f i`, it's
enough to prove it for `f i` and being able to extend through diffs. |
@[simp]
partialSups_disjointed (f : ι → α) :
partialSups (disjointed f) = partialSups f := by
classical
suffices ∀ r i (hi : #(Iio i) ≤ r), partialSups (disjointed f) i = partialSups f i from
OrderHom.ext _ _ (funext fun i ↦ this _ i le_rfl)
intro r i hi
induction r generalizing i with
| zero =>
s... | theorem | Order | [
"Mathlib.Order.PartialSups",
"Mathlib.Order.Interval.Finset.Fin"
] | Mathlib/Order/Disjointed.lean | partialSups_disjointed | null |
Fintype.sup_disjointed [Fintype ι] (f : ι → α) :
univ.sup (disjointed f) = univ.sup f := by
classical
have hun : univ.biUnion Iic = (univ : Finset ι) := by
ext r; simpa only [mem_biUnion, mem_univ, mem_Iic, true_and, iff_true] using ⟨r, le_rfl⟩
rw [← hun, sup_biUnion, sup_biUnion, sup_congr rfl (fun i _ ↦... | lemma | Order | [
"Mathlib.Order.PartialSups",
"Mathlib.Order.Interval.Finset.Fin"
] | Mathlib/Order/Disjointed.lean | Fintype.sup_disjointed | null |
disjointed_partialSups (f : ι → α) :
disjointed (partialSups f) = disjointed f := by
classical
ext i
have step1 : f i \ (Iio i).sup f = partialSups f i \ (Iio i).sup f := by
rw [sdiff_eq_symm (sdiff_le.trans (le_partialSups f i))]
simp only [funext (partialSups_apply f), sup'_eq_sup]
rw [sdiff_sdi... | lemma | Order | [
"Mathlib.Order.PartialSups",
"Mathlib.Order.Interval.Finset.Fin"
] | Mathlib/Order/Disjointed.lean | disjointed_partialSups | null |
disjointed_unique {f d : ι → α} (hdisj : ∀ {i j : ι} (_ : i < j), Disjoint (d i) (d j))
(hsups : partialSups d = partialSups f) :
d = disjointed f := by
rw [← disjointed_partialSups, ← hsups, disjointed_partialSups]
exact funext fun _ ↦ (disjointed_eq_self (fun _ hj ↦ hdisj hj)).symm | theorem | Order | [
"Mathlib.Order.PartialSups",
"Mathlib.Order.Interval.Finset.Fin"
] | Mathlib/Order/Disjointed.lean | disjointed_unique | `disjointed f` is the unique map `d : ι → α` such that `d` has the same partial sups as `f`,
and `d i` and `d j` are disjoint whenever `i < j`. |
disjoint_disjointed (f : ι → α) : Pairwise (Disjoint on disjointed f) :=
(pairwise_disjoint_on _).mpr fun _ _ ↦ disjoint_disjointed_of_lt f | theorem | Order | [
"Mathlib.Order.PartialSups",
"Mathlib.Order.Interval.Finset.Fin"
] | Mathlib/Order/Disjointed.lean | disjoint_disjointed | null |
disjointed_unique' {f d : ι → α} (hdisj : Pairwise (Disjoint on d))
(hsups : partialSups d = partialSups f) : d = disjointed f :=
disjointed_unique (fun hij ↦ hdisj hij.ne) hsups | theorem | Order | [
"Mathlib.Order.PartialSups",
"Mathlib.Order.Interval.Finset.Fin"
] | Mathlib/Order/Disjointed.lean | disjointed_unique' | `disjointed f` is the unique sequence that is pairwise disjoint and has the same partial sups
as `f`. |
disjointed_succ (f : ι → α) {i : ι} (hi : ¬IsMax i) :
disjointed f (succ i) = f (succ i) \ partialSups f i := by
rw [disjointed_apply, partialSups_apply, sup'_eq_sup]
congr 2 with m
simpa only [mem_Iio, mem_Iic] using lt_succ_iff_of_not_isMax hi | lemma | Order | [
"Mathlib.Order.PartialSups",
"Mathlib.Order.Interval.Finset.Fin"
] | Mathlib/Order/Disjointed.lean | disjointed_succ | null |
protected Monotone.disjointed_succ {f : ι → α} (hf : Monotone f) {i : ι} (hn : ¬IsMax i) :
disjointed f (succ i) = f (succ i) \ f i := by
rwa [disjointed_succ, hf.partialSups_eq] | lemma | Order | [
"Mathlib.Order.PartialSups",
"Mathlib.Order.Interval.Finset.Fin"
] | Mathlib/Order/Disjointed.lean | Monotone.disjointed_succ | null |
Monotone.disjointed_succ_sup {f : ι → α} (hf : Monotone f) (i : ι) :
disjointed f (succ i) ⊔ f i = f (succ i) := by
by_cases h : IsMax i
· simpa only [succ_eq_iff_isMax.mpr h, sup_eq_right] using disjointed_le f i
· rw [disjointed_apply]
have : Iio (succ i) = Iic i := by
ext
simp only [mem_Iio... | lemma | Order | [
"Mathlib.Order.PartialSups",
"Mathlib.Order.Interval.Finset.Fin"
] | Mathlib/Order/Disjointed.lean | Monotone.disjointed_succ_sup | Note this lemma does not require `¬IsMax i`, unlike `disjointed_succ`. |
Fintype.exists_disjointed_le {ι : Type*} [Fintype ι] (f : ι → α) :
∃ g, g ≤ f ∧ univ.sup g = univ.sup f ∧ Pairwise (Disjoint on g) := by
rcases isEmpty_or_nonempty ι with hι | hι
· -- do `ι = ∅` separately since `⊤ : Fin n` isn't defined for `n = 0`
exact ⟨f, le_rfl, rfl, Subsingleton.pairwise⟩
let R : ι... | lemma | Order | [
"Mathlib.Order.PartialSups",
"Mathlib.Order.Interval.Finset.Fin"
] | Mathlib/Order/Disjointed.lean | Fintype.exists_disjointed_le | For any finite family of elements `f : ι → α`, we can find a pairwise-disjoint family `g`
bounded above by `f` and having the same supremum. This is non-canonical, depending on an arbitrary
choice of ordering of `ι`. |
iSup_disjointed [PartialOrder ι] [LocallyFiniteOrderBot ι] (f : ι → α) :
⨆ i, disjointed f i = ⨆ i, f i :=
iSup_eq_iSup_of_partialSups_eq_partialSups (partialSups_disjointed f) | theorem | Order | [
"Mathlib.Order.PartialSups",
"Mathlib.Order.Interval.Finset.Fin"
] | Mathlib/Order/Disjointed.lean | iSup_disjointed | null |
disjointed_eq_inf_compl [Preorder ι] [LocallyFiniteOrderBot ι] (f : ι → α) (i : ι) :
disjointed f i = f i ⊓ ⨅ j < i, (f j)ᶜ := by
simp only [disjointed_apply, Finset.sup_eq_iSup, mem_Iio, sdiff_eq, compl_iSup] | theorem | Order | [
"Mathlib.Order.PartialSups",
"Mathlib.Order.Interval.Finset.Fin"
] | Mathlib/Order/Disjointed.lean | disjointed_eq_inf_compl | null |
disjointed_subset [Preorder ι] [LocallyFiniteOrderBot ι] (f : ι → Set α) (i : ι) :
disjointed f i ⊆ f i :=
disjointed_le f i | theorem | Order | [
"Mathlib.Order.PartialSups",
"Mathlib.Order.Interval.Finset.Fin"
] | Mathlib/Order/Disjointed.lean | disjointed_subset | null |
iUnion_disjointed [PartialOrder ι] [LocallyFiniteOrderBot ι] {f : ι → Set α} :
⋃ i, disjointed f i = ⋃ i, f i :=
iSup_disjointed f | theorem | Order | [
"Mathlib.Order.PartialSups",
"Mathlib.Order.Interval.Finset.Fin"
] | Mathlib/Order/Disjointed.lean | iUnion_disjointed | null |
disjointed_eq_inter_compl [Preorder ι] [LocallyFiniteOrderBot ι] (f : ι → Set α) (i : ι) :
disjointed f i = f i ∩ ⋂ j < i, (f j)ᶜ :=
disjointed_eq_inf_compl f i | theorem | Order | [
"Mathlib.Order.PartialSups",
"Mathlib.Order.Interval.Finset.Fin"
] | Mathlib/Order/Disjointed.lean | disjointed_eq_inter_compl | null |
preimage_find_eq_disjointed (s : ℕ → Set α) (H : ∀ x, ∃ n, x ∈ s n)
[∀ x n, Decidable (x ∈ s n)] (n : ℕ) : (fun x => Nat.find (H x)) ⁻¹' {n} = disjointed s n := by
ext x
simp [Nat.find_eq_iff, disjointed_eq_inter_compl] | theorem | Order | [
"Mathlib.Order.PartialSups",
"Mathlib.Order.Interval.Finset.Fin"
] | Mathlib/Order/Disjointed.lean | preimage_find_eq_disjointed | null |
@[simp]
disjointed_zero (f : ℕ → α) : disjointed f 0 = f 0 :=
disjointed_bot f | theorem | Order | [
"Mathlib.Order.PartialSups",
"Mathlib.Order.Interval.Finset.Fin"
] | Mathlib/Order/Disjointed.lean | disjointed_zero | null |
lfp : (α →o α) →o α where
toFun f := sInf { a | f a ≤ a }
monotone' _ _ hle := sInf_le_sInf fun a ha => (hle a).trans ha | def | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | lfp | Least fixed point of a monotone function |
gfp : (α →o α) →o α where
toFun f := sSup { a | a ≤ f a }
monotone' _ _ hle := sSup_le_sSup fun a ha => le_trans ha (hle a) | def | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | gfp | Greatest fixed point of a monotone function |
lfp_le {a : α} (h : f a ≤ a) : f.lfp ≤ a :=
sInf_le h | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | lfp_le | null |
lfp_le_fixed {a : α} (h : f a = a) : f.lfp ≤ a :=
f.lfp_le h.le | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | lfp_le_fixed | null |
le_lfp {a : α} (h : ∀ b, f b ≤ b → a ≤ b) : a ≤ f.lfp :=
le_sInf h | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | le_lfp | null |
map_le_lfp {a : α} (ha : a ≤ f.lfp) : f a ≤ f.lfp :=
f.le_lfp fun _ hb => (f.mono <| le_sInf_iff.1 ha _ hb).trans hb
@[simp] | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | map_le_lfp | null |
map_lfp : f f.lfp = f.lfp :=
have h : f f.lfp ≤ f.lfp := f.map_le_lfp le_rfl
h.antisymm <| f.lfp_le <| f.mono h | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | map_lfp | null |
isFixedPt_lfp : IsFixedPt f f.lfp :=
f.map_lfp | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | isFixedPt_lfp | null |
lfp_le_map {a : α} (ha : f.lfp ≤ a) : f.lfp ≤ f a :=
calc
f.lfp = f f.lfp := f.map_lfp.symm
_ ≤ f a := f.mono ha | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | lfp_le_map | null |
isLeast_lfp_le : IsLeast { a | f a ≤ a } f.lfp :=
⟨f.map_lfp.le, fun _ => f.lfp_le⟩ | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | isLeast_lfp_le | null |
isLeast_lfp : IsLeast (fixedPoints f) f.lfp :=
⟨f.isFixedPt_lfp, fun _ => f.lfp_le_fixed⟩ | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | isLeast_lfp | null |
lfp_induction {p : α → Prop} (step : ∀ a, p a → a ≤ f.lfp → p (f a))
(hSup : ∀ s, (∀ a ∈ s, p a) → p (sSup s)) : p f.lfp := by
set s := { a | a ≤ f.lfp ∧ p a }
specialize hSup s fun a => And.right
suffices sSup s = f.lfp from this ▸ hSup
have h : sSup s ≤ f.lfp := sSup_le fun b => And.left
have hmem : f (... | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | lfp_induction | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.