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 ⌀ |
|---|---|---|---|---|---|---|
@[simps! toEquiv apply symm_apply]
prodEquiv (L : Sublattice α) (M : Sublattice β) : L.prod M ≃o L × M where
toEquiv := Equiv.Set.prod _ _
map_rel_iff' := Iff.rfl | def | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | prodEquiv | The product of sublattices is isomorphic to their product as lattices. |
@[simps]
pi (s : Set κ) (L : ∀ i, Sublattice (π i)) : Sublattice (∀ i, π i) where
carrier := s.pi fun i ↦ L i
supClosed' := supClosed_pi fun i _ ↦ (L i).supClosed
infClosed' := infClosed_pi fun i _ ↦ (L i).infClosed
attribute [norm_cast] coe_pi
@[simp] lemma mem_pi {s : Set κ} {L : ∀ i, Sublattice (π i)} {x : ∀ i... | def | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | pi | Arbitrary product of sublattices. Given an index set `s` and a family of sublattices
`L : Π i, Sublattice (α i)`, `pi s L` is the sublattice of dependent functions `f : Π i, α i` such
that `f i` belongs to `L i` whenever `i ∈ s`. |
pi_univ_bot [Nonempty κ] : (pi univ fun _ ↦ ⊥ : Sublattice (∀ i, π i)) = ⊥ := by simp | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | pi_univ_bot | null |
le_pi {s : Set κ} {L : ∀ i, Sublattice (π i)} {M : Sublattice (∀ i, π i)} :
M ≤ pi s L ↔ ∀ i ∈ s, M ≤ comap (Pi.evalLatticeHom i) (L i) := by simp [SetLike.le_def]; aesop
@[simp] lemma pi_univ_eq_bot_iff {L : ∀ i, Sublattice (π i)} : pi univ L = ⊥ ↔ ∃ i, L i = ⊥ := by
simp_rw [← coe_inj]; simp | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | le_pi | null |
pi_univ_eq_bot {L : ∀ i, Sublattice (π i)} {i : κ} (hL : L i = ⊥) : pi univ L = ⊥ :=
pi_univ_eq_bot_iff.2 ⟨i, hL⟩ | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | pi_univ_eq_bot | null |
Sublocale (X : Type*) [Order.Frame X] where
/-- The set corresponding to the sublocale. -/
carrier : Set X
/-- A sublocale is closed under all meets.
Do NOT use directly. Use `Sublocale.sInf_mem` instead. -/
sInf_mem' : ∀ s ⊆ carrier, sInf s ∈ carrier
/-- A sublocale is closed under heyting implication.
D... | structure | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | Sublocale | A sublocale of a locale `X` is a set `S` which is closed under all meets and such that
`x ⇨ s ∈ S` for all `x : X` and `s ∈ S`.
Note that locales are the same thing as frames, but with reverse morphisms, which is why we assume
`Frame X`. We only need to define locales categorically. See `Locale`. |
instSetLike : SetLike (Sublocale X) X where
coe x := x.carrier
coe_injective' s1 s2 h := by cases s1; congr
@[simp] lemma mem_carrier : a ∈ S.carrier ↔ a ∈ S := .rfl
@[simp] lemma mem_mk (carrier : Set X) (sInf_mem' himp_mem') :
a ∈ mk carrier sInf_mem' himp_mem' ↔ a ∈ carrier := .rfl
@[simp] lemma mk_le_mk (ca... | instance | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | instSetLike | null |
sInf_mem (hs : s ⊆ S) : sInf s ∈ S := S.sInf_mem' _ hs | lemma | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | sInf_mem | null |
iInf_mem (hf : ∀ i, f i ∈ S) : ⨅ i, f i ∈ S := S.sInf_mem <| by simpa [range_subset_iff] | lemma | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | iInf_mem | null |
infClosed : InfClosed (S : Set X) := by
rintro a ha b hb; rw [← sInf_pair]; exact S.sInf_mem (pair_subset ha hb) | lemma | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | infClosed | null |
inf_mem (ha : a ∈ S) (hb : b ∈ S) : a ⊓ b ∈ S := S.infClosed ha hb | lemma | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | inf_mem | null |
top_mem : ⊤ ∈ S := by simpa using S.sInf_mem <| empty_subset _ | lemma | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | top_mem | null |
himp_mem (hb : b ∈ S) : a ⇨ b ∈ S := S.himp_mem' _ _ hb | lemma | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | himp_mem | null |
carrier.instSemilatticeInf : SemilatticeInf S := Subtype.semilatticeInf fun _ _ ↦ inf_mem | instance | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | carrier.instSemilatticeInf | null |
carrier.instOrderTop : OrderTop S := Subtype.orderTop top_mem | instance | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | carrier.instOrderTop | null |
carrier.instHImp : HImp S where himp a b := ⟨a ⇨ b, S.himp_mem b.2⟩ | instance | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | carrier.instHImp | null |
carrier.instInfSet : InfSet S where
sInf x := ⟨sInf (Subtype.val '' x), S.sInf_mem' _
(by simp_rw [image_subset_iff, subset_def]; simp)⟩
@[simp, norm_cast] lemma coe_inf (a b : S) : (a ⊓ b).val = ↑a ⊓ ↑b := rfl
@[simp, norm_cast] lemma coe_sInf (s : Set S) : (sInf s).val = sInf (Subtype.val '' s) := rfl
@[simp, n... | instance | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | carrier.instInfSet | null |
carrier.instCompleteLattice : CompleteLattice S where
__ := instSemilatticeInf
__ := instOrderTop
__ := completeLatticeOfInf S <| by simp [isGLB_iff_le_iff, lowerBounds, ← Subtype.coe_le_coe]
@[simp, norm_cast] lemma coe_himp (a b : S) : (a ⇨ b).val = a.val ⇨ b.val := rfl | instance | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | carrier.instCompleteLattice | null |
carrier.instHeytingAlgebra : HeytingAlgebra S where
le_himp_iff a b c := by simp [← Subtype.coe_le_coe, ← @Sublocale.coe_inf, himp]
compl a := a ⇨ ⊥
himp_bot _ := rfl | instance | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | carrier.instHeytingAlgebra | null |
carrier.instFrame : Order.Frame S where
__ := carrier.instHeytingAlgebra
__ := carrier.instCompleteLattice | instance | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | carrier.instFrame | null |
private restrictAux (S : Sublocale X) (a : X) : S := sInf {s : S | a ≤ s} | def | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | restrictAux | See `Sublocale.restrict` for the public-facing version. |
private le_restrictAux : a ≤ S.restrictAux a := by simp +contextual [restrictAux] | lemma | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | le_restrictAux | null |
private giAux (S : Sublocale X) : GaloisInsertion S.restrictAux Subtype.val where
choice x hx := ⟨x, by
rw [le_antisymm le_restrictAux hx]
exact S.sInf_mem <| by simp +contextual [Set.subset_def]⟩
gc a b := by
constructor <;> intro h
· exact le_trans (by simp +contextual [restrictAux]) h
· exact... | def | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | giAux | See `Sublocale.giRestrict` for the public-facing version. |
restrict (S : Sublocale X) : FrameHom X S where
toFun x := sInf {s : S | x ≤ s}
map_inf' a b := by
change Sublocale.restrictAux S (a ⊓ b) = Sublocale.restrictAux S a ⊓ Sublocale.restrictAux S b
refine eq_of_forall_ge_iff (fun s ↦ Iff.symm ?_)
calc
_ ↔ S.restrictAux a ≤ S.restrictAux b ⇨ s := by si... | def | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | restrict | The restriction from a locale X into the sublocale S. |
giRestrict (S : Sublocale X) : GaloisInsertion S.restrict Subtype.val := S.giAux
@[simp] lemma restrict_of_mem (ha : a ∈ S) : S.restrict a = ⟨a, ha⟩ := S.giRestrict.l_u_eq ⟨a, ha⟩ | def | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | giRestrict | The restriction corresponding to a sublocale forms a Galois insertion with the forgetful map
from the sublocale to the original locale. |
@[simps]
toNucleus (S : Sublocale X) : Nucleus X where
toFun x := S.restrict x
map_inf' _ _ := by simp [S.giRestrict.gc.u_inf]
idempotent' _ := by rw [S.giRestrict.gc.l_u_l_eq_l]
le_apply' _ := S.giRestrict.gc.le_u_l _
@[simp] lemma range_toNucleus : range S.toNucleus = S := by
ext x
constructor
· simp +c... | def | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | toNucleus | The restriction from the locale X into a sublocale is a nucleus. |
@[simps]
toSublocale (n : Nucleus X) : Sublocale X where
carrier := range n
sInf_mem' a h := by
rw [mem_range]
refine le_antisymm (le_sInf_iff.mpr (fun b h1 ↦ ?_)) le_apply
simp_rw [subset_def, mem_range] at h
rw [← h b h1]
exact n.monotone (sInf_le h1)
himp_mem' a b h := by rw [mem_range, ← h... | def | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | toSublocale | The range of a nucleus is a sublocale. |
mem_toSublocale {n : Nucleus X} {x : X} : x ∈ n.toSublocale ↔ ∃ y, n y = x := .rfl
@[simp] lemma toSublocale_le_toSublocale {m n : Nucleus X} :
m.toSublocale ≤ n.toSublocale ↔ n ≤ m := by simp [← SetLike.coe_subset_coe]
@[gcongr]
alias ⟨_, _root_.GCongr.Nucleus.toSublocale_le_toSublocale⟩ := toSublocale_le_toSubloc... | lemma | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | mem_toSublocale | null |
nucleusIsoSublocale : (Nucleus X)ᵒᵈ ≃o Sublocale X where
toFun n := n.ofDual.toSublocale
invFun s := .toDual s.toNucleus
left_inv := by simp [Function.LeftInverse, Nucleus.ext_iff]
right_inv S := by ext x; simpa using ⟨by simp +contextual [eq_comm], fun hx ↦ ⟨x, by simp [hx]⟩⟩
map_rel_iff' := by simp | def | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | nucleusIsoSublocale | The nuclei on a frame corresponds exactly to the sublocales on this frame.
The sublocales are ordered dually to the nuclei. |
nucleusIsoSublocale.eq_toSublocale : Nucleus.toSublocale = @nucleusIsoSublocale X _ := rfl | lemma | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | nucleusIsoSublocale.eq_toSublocale | null |
nucleusIsoSublocale.symm_eq_toNucleus :
Sublocale.toNucleus = (@nucleusIsoSublocale X _).symm := rfl | lemma | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | nucleusIsoSublocale.symm_eq_toNucleus | null |
Sublocale.instCompleteLattice : CompleteLattice (Sublocale X) :=
nucleusIsoSublocale.toGaloisInsertion.liftCompleteLattice | instance | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | Sublocale.instCompleteLattice | null |
Sublocale.instCoframeMinimalAxioms : Order.Coframe.MinimalAxioms (Sublocale X) where
iInf_sup_le_sup_sInf a s := by simp [← toNucleus_le_toNucleus,
nucleusIsoSublocale.symm_eq_toNucleus, nucleusIsoSublocale.symm.map_sup,
nucleusIsoSublocale.symm.map_sInf, sup_iInf_eq, nucleusIsoSublocale.symm.map_iInf] | instance | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | Sublocale.instCoframeMinimalAxioms | null |
Sublocale.instCoframe : Order.Coframe (Sublocale X) :=
.ofMinimalAxioms instCoframeMinimalAxioms | instance | Order | [
"Mathlib.Order.Nucleus",
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublocale.lean | Sublocale.instCoframe | null |
SupClosed (s : Set α) : Prop := ∀ ⦃a⦄, a ∈ s → ∀ ⦃b⦄, b ∈ s → a ⊔ b ∈ s
@[simp] lemma supClosed_empty : SupClosed (∅ : Set α) := by simp [SupClosed]
@[simp] lemma supClosed_singleton : SupClosed ({a} : Set α) := by simp [SupClosed]
@[simp] lemma supClosed_univ : SupClosed (univ : Set α) := by simp [SupClosed] | def | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | SupClosed | A set `s` is *sup-closed* if `a ⊔ b ∈ s` for all `a ∈ s`, `b ∈ s`. |
SupClosed.inter (hs : SupClosed s) (ht : SupClosed t) : SupClosed (s ∩ t) :=
fun _a ha _b hb ↦ ⟨hs ha.1 hb.1, ht ha.2 hb.2⟩ | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | SupClosed.inter | null |
supClosed_sInter (hS : ∀ s ∈ S, SupClosed s) : SupClosed (⋂₀ S) :=
fun _a ha _b hb _s hs ↦ hS _ hs (ha _ hs) (hb _ hs) | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | supClosed_sInter | null |
supClosed_iInter (hf : ∀ i, SupClosed (f i)) : SupClosed (⋂ i, f i) :=
supClosed_sInter <| forall_mem_range.2 hf | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | supClosed_iInter | null |
SupClosed.directedOn (hs : SupClosed s) : DirectedOn (· ≤ ·) s :=
fun _a ha _b hb ↦ ⟨_, hs ha hb, le_sup_left, le_sup_right⟩ | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | SupClosed.directedOn | null |
IsUpperSet.supClosed (hs : IsUpperSet s) : SupClosed s := fun _a _ _b ↦ hs le_sup_right | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | IsUpperSet.supClosed | null |
SupClosed.preimage [FunLike F β α] [SupHomClass F β α] (hs : SupClosed s) (f : F) :
SupClosed (f ⁻¹' s) :=
fun a ha b hb ↦ by simpa [map_sup] using hs ha hb | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | SupClosed.preimage | null |
SupClosed.image [FunLike F α β] [SupHomClass F α β] (hs : SupClosed s) (f : F) :
SupClosed (f '' s) := by
rintro _ ⟨a, ha, rfl⟩ _ ⟨b, hb, rfl⟩
rw [← map_sup]
exact Set.mem_image_of_mem _ <| hs ha hb | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | SupClosed.image | null |
supClosed_range [FunLike F α β] [SupHomClass F α β] (f : F) : SupClosed (Set.range f) := by
simpa using supClosed_univ.image f | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | supClosed_range | null |
SupClosed.prod {t : Set β} (hs : SupClosed s) (ht : SupClosed t) : SupClosed (s ×ˢ t) :=
fun _a ha _b hb ↦ ⟨hs ha.1 hb.1, ht ha.2 hb.2⟩ | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | SupClosed.prod | null |
supClosed_pi {ι : Type*} {α : ι → Type*} [∀ i, SemilatticeSup (α i)] {s : Set ι}
{t : ∀ i, Set (α i)} (ht : ∀ i ∈ s, SupClosed (t i)) : SupClosed (s.pi t) :=
fun _a ha _b hb _i hi ↦ ht _ hi (ha _ hi) (hb _ hi) | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | supClosed_pi | null |
SupClosed.insert_upperBounds {s : Set α} {a : α} (hs : SupClosed s) (ha : a ∈ upperBounds s) :
SupClosed (insert a s) := by
rw [SupClosed]
aesop | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | SupClosed.insert_upperBounds | null |
SupClosed.insert_lowerBounds {s : Set α} {a : α} (h : SupClosed s) (ha : a ∈ lowerBounds s) :
SupClosed (insert a s) := by
rw [SupClosed]
have ha' : ∀ b ∈ s, a ≤ b := fun _ a ↦ ha a
aesop | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | SupClosed.insert_lowerBounds | null |
SupClosed.finsetSup'_mem (hs : SupClosed s) (ht : t.Nonempty) :
(∀ i ∈ t, f i ∈ s) → t.sup' ht f ∈ s :=
sup'_induction _ _ hs | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | SupClosed.finsetSup'_mem | null |
SupClosed.finsetSup_mem [OrderBot α] (hs : SupClosed s) (ht : t.Nonempty) :
(∀ i ∈ t, f i ∈ s) → t.sup f ∈ s :=
sup'_eq_sup ht f ▸ hs.finsetSup'_mem ht | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | SupClosed.finsetSup_mem | null |
InfClosed (s : Set α) : Prop := ∀ ⦃a⦄, a ∈ s → ∀ ⦃b⦄, b ∈ s → a ⊓ b ∈ s
@[simp] lemma infClosed_empty : InfClosed (∅ : Set α) := by simp [InfClosed]
@[simp] lemma infClosed_singleton : InfClosed ({a} : Set α) := by simp [InfClosed]
@[simp] lemma infClosed_univ : InfClosed (univ : Set α) := by simp [InfClosed] | def | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | InfClosed | A set `s` is *inf-closed* if `a ⊓ b ∈ s` for all `a ∈ s`, `b ∈ s`. |
InfClosed.inter (hs : InfClosed s) (ht : InfClosed t) : InfClosed (s ∩ t) :=
fun _a ha _b hb ↦ ⟨hs ha.1 hb.1, ht ha.2 hb.2⟩ | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | InfClosed.inter | null |
infClosed_sInter (hS : ∀ s ∈ S, InfClosed s) : InfClosed (⋂₀ S) :=
fun _a ha _b hb _s hs ↦ hS _ hs (ha _ hs) (hb _ hs) | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | infClosed_sInter | null |
infClosed_iInter (hf : ∀ i, InfClosed (f i)) : InfClosed (⋂ i, f i) :=
infClosed_sInter <| forall_mem_range.2 hf | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | infClosed_iInter | null |
InfClosed.codirectedOn (hs : InfClosed s) : DirectedOn (· ≥ ·) s :=
fun _a ha _b hb ↦ ⟨_, hs ha hb, inf_le_left, inf_le_right⟩ | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | InfClosed.codirectedOn | null |
IsLowerSet.infClosed (hs : IsLowerSet s) : InfClosed s := fun _a _ _b ↦ hs inf_le_right | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | IsLowerSet.infClosed | null |
InfClosed.preimage [FunLike F β α] [InfHomClass F β α] (hs : InfClosed s) (f : F) :
InfClosed (f ⁻¹' s) :=
fun a ha b hb ↦ by simpa [map_inf] using hs ha hb | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | InfClosed.preimage | null |
InfClosed.image [FunLike F α β] [InfHomClass F α β] (hs : InfClosed s) (f : F) :
InfClosed (f '' s) := by
rintro _ ⟨a, ha, rfl⟩ _ ⟨b, hb, rfl⟩
rw [← map_inf]
exact Set.mem_image_of_mem _ <| hs ha hb | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | InfClosed.image | null |
infClosed_range [FunLike F α β] [InfHomClass F α β] (f : F) : InfClosed (Set.range f) := by
simpa using infClosed_univ.image f | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | infClosed_range | null |
InfClosed.prod {t : Set β} (hs : InfClosed s) (ht : InfClosed t) : InfClosed (s ×ˢ t) :=
fun _a ha _b hb ↦ ⟨hs ha.1 hb.1, ht ha.2 hb.2⟩ | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | InfClosed.prod | null |
infClosed_pi {ι : Type*} {α : ι → Type*} [∀ i, SemilatticeInf (α i)] {s : Set ι}
{t : ∀ i, Set (α i)} (ht : ∀ i ∈ s, InfClosed (t i)) : InfClosed (s.pi t) :=
fun _a ha _b hb _i hi ↦ ht _ hi (ha _ hi) (hb _ hi) | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | infClosed_pi | null |
InfClosed.insert_upperBounds {s : Set α} {a : α} (hs : InfClosed s) (ha : a ∈ upperBounds s) :
InfClosed (insert a s) := by
rw [InfClosed]
have ha' : ∀ b ∈ s, b ≤ a := fun _ a ↦ ha a
aesop | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | InfClosed.insert_upperBounds | null |
InfClosed.insert_lowerBounds {s : Set α} {a : α} (h : InfClosed s) (ha : a ∈ lowerBounds s) :
InfClosed (insert a s) := by
rw [InfClosed]
aesop | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | InfClosed.insert_lowerBounds | null |
InfClosed.finsetInf'_mem (hs : InfClosed s) (ht : t.Nonempty) :
(∀ i ∈ t, f i ∈ s) → t.inf' ht f ∈ s :=
inf'_induction _ _ hs | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | InfClosed.finsetInf'_mem | null |
InfClosed.finsetInf_mem [OrderTop α] (hs : InfClosed s) (ht : t.Nonempty) :
(∀ i ∈ t, f i ∈ s) → t.inf f ∈ s :=
inf'_eq_inf ht f ▸ hs.finsetInf'_mem ht | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | InfClosed.finsetInf_mem | null |
IsSublattice (s : Set α) : Prop where
supClosed : SupClosed s
infClosed : InfClosed s
@[simp] lemma isSublattice_empty : IsSublattice (∅ : Set α) := ⟨supClosed_empty, infClosed_empty⟩
@[simp] lemma isSublattice_singleton : IsSublattice ({a} : Set α) :=
⟨supClosed_singleton, infClosed_singleton⟩
@[simp] lemma isSu... | structure | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | IsSublattice | A set `s` is a *sublattice* if `a ⊔ b ∈ s` and `a ⊓ b ∈ s` for all `a ∈ s`, `b ∈ s`.
Note: This is not the preferred way to declare a sublattice. One should instead use `Sublattice`.
TODO: Define `Sublattice`. |
IsSublattice.inter (hs : IsSublattice s) (ht : IsSublattice t) : IsSublattice (s ∩ t) :=
⟨hs.1.inter ht.1, hs.2.inter ht.2⟩ | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | IsSublattice.inter | null |
isSublattice_sInter (hS : ∀ s ∈ S, IsSublattice s) : IsSublattice (⋂₀ S) :=
⟨supClosed_sInter fun _s hs ↦ (hS _ hs).1, infClosed_sInter fun _s hs ↦ (hS _ hs).2⟩ | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | isSublattice_sInter | null |
isSublattice_iInter (hf : ∀ i, IsSublattice (f i)) : IsSublattice (⋂ i, f i) :=
⟨supClosed_iInter fun _i ↦ (hf _).1, infClosed_iInter fun _i ↦ (hf _).2⟩ | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | isSublattice_iInter | null |
IsSublattice.preimage [FunLike F β α] [LatticeHomClass F β α]
(hs : IsSublattice s) (f : F) :
IsSublattice (f ⁻¹' s) := ⟨hs.1.preimage _, hs.2.preimage _⟩ | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | IsSublattice.preimage | null |
IsSublattice.image [FunLike F α β] [LatticeHomClass F α β] (hs : IsSublattice s) (f : F) :
IsSublattice (f '' s) := ⟨hs.1.image _, hs.2.image _⟩ | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | IsSublattice.image | null |
IsSublattice_range [FunLike F α β] [LatticeHomClass F α β] (f : F) :
IsSublattice (Set.range f) :=
⟨supClosed_range _, infClosed_range _⟩ | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | IsSublattice_range | null |
IsSublattice.prod {t : Set β} (hs : IsSublattice s) (ht : IsSublattice t) :
IsSublattice (s ×ˢ t) := ⟨hs.1.prod ht.1, hs.2.prod ht.2⟩ | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | IsSublattice.prod | null |
isSublattice_pi {ι : Type*} {α : ι → Type*} [∀ i, Lattice (α i)] {s : Set ι}
{t : ∀ i, Set (α i)} (ht : ∀ i ∈ s, IsSublattice (t i)) : IsSublattice (s.pi t) :=
⟨supClosed_pi fun _i hi ↦ (ht _ hi).1, infClosed_pi fun _i hi ↦ (ht _ hi).2⟩
@[simp] lemma supClosed_preimage_toDual {s : Set αᵒᵈ} :
SupClosed (toDual... | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | isSublattice_pi | null |
@[simp] protected LinearOrder.supClosed (s : Set α) : SupClosed s :=
fun a ha b hb ↦ by cases le_total a b <;> simp [*]
@[simp] protected lemma LinearOrder.infClosed (s : Set α) : InfClosed s :=
fun a ha b hb ↦ by cases le_total a b <;> simp [*]
@[simp] protected lemma LinearOrder.isSublattice (s : Set α) : IsSubla... | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | LinearOrder.supClosed | null |
@[simps! isClosed]
supClosure : ClosureOperator (Set α) := .ofPred
(fun s ↦ {a | ∃ (t : Finset α) (ht : t.Nonempty), ↑t ⊆ s ∧ t.sup' ht id = a})
SupClosed
(fun s a ha ↦ ⟨{a}, singleton_nonempty _, by simpa⟩)
(by
classical
rintro s _ ⟨t, ht, hts, rfl⟩ _ ⟨u, hu, hus, rfl⟩
refine ⟨_, ht.mono subset_uni... | def | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | supClosure | Every set in a join-semilattice generates a set closed under join. |
supClosure_mono : Monotone (supClosure : Set α → Set α) := supClosure.monotone
@[simp] lemma supClosure_eq_self : supClosure s = s ↔ SupClosed s := supClosure.isClosed_iff.symm
alias ⟨_, SupClosed.supClosure_eq⟩ := supClosure_eq_self | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | supClosure_mono | null |
supClosure_idem (s : Set α) : supClosure (supClosure s) = supClosure s :=
supClosure.idempotent _
@[simp] lemma supClosure_empty : supClosure (∅ : Set α) = ∅ := by simp
@[simp] lemma supClosure_singleton : supClosure {a} = {a} := by simp
@[simp] lemma supClosure_univ : supClosure (Set.univ : Set α) = Set.univ := by s... | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | supClosure_idem | null |
sup_mem_supClosure (ha : a ∈ s) (hb : b ∈ s) : a ⊔ b ∈ supClosure s :=
supClosed_supClosure (subset_supClosure ha) (subset_supClosure hb) | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | sup_mem_supClosure | null |
finsetSup'_mem_supClosure {ι : Type*} {t : Finset ι} (ht : t.Nonempty) {f : ι → α}
(hf : ∀ i ∈ t, f i ∈ s) : t.sup' ht f ∈ supClosure s :=
supClosed_supClosure.finsetSup'_mem _ fun _i hi ↦ subset_supClosure <| hf _ hi | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | finsetSup'_mem_supClosure | null |
supClosure_min : s ⊆ t → SupClosed t → supClosure s ⊆ t := supClosure.closure_min | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | supClosure_min | null |
protected Set.Finite.supClosure (hs : s.Finite) : (supClosure s).Finite := by
lift s to Finset α using hs
classical
refine ({t ∈ s.powerset | t.Nonempty}.attach.image
fun t ↦ t.1.sup' (mem_filter.1 t.2).2 id).finite_toSet.subset ?_
rintro _ ⟨t, ht, hts, rfl⟩
simp only [id_eq, coe_image, mem_image, mem_coe... | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | Set.Finite.supClosure | The semilattice generated by a finite set is finite. |
@[simps! isClosed]
infClosure : ClosureOperator (Set α) := ClosureOperator.ofPred
(fun s ↦ {a | ∃ (t : Finset α) (ht : t.Nonempty), ↑t ⊆ s ∧ t.inf' ht id = a})
InfClosed
(fun s a ha ↦ ⟨{a}, singleton_nonempty _, by simpa⟩)
(by
classical
rintro s _ ⟨t, ht, hts, rfl⟩ _ ⟨u, hu, hus, rfl⟩
refine ⟨_, ht.... | def | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | infClosure | Every set in a join-semilattice generates a set closed under join. |
infClosure_mono : Monotone (infClosure : Set α → Set α) := infClosure.monotone
@[simp] lemma infClosure_eq_self : infClosure s = s ↔ InfClosed s := infClosure.isClosed_iff.symm
alias ⟨_, InfClosed.infClosure_eq⟩ := infClosure_eq_self | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | infClosure_mono | null |
infClosure_idem (s : Set α) : infClosure (infClosure s) = infClosure s :=
infClosure.idempotent _
@[simp] lemma infClosure_empty : infClosure (∅ : Set α) = ∅ := by simp
@[simp] lemma infClosure_singleton : infClosure {a} = {a} := by simp
@[simp] lemma infClosure_univ : infClosure (Set.univ : Set α) = Set.univ := by s... | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | infClosure_idem | null |
inf_mem_infClosure (ha : a ∈ s) (hb : b ∈ s) : a ⊓ b ∈ infClosure s :=
infClosed_infClosure (subset_infClosure ha) (subset_infClosure hb) | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | inf_mem_infClosure | null |
finsetInf'_mem_infClosure {ι : Type*} {t : Finset ι} (ht : t.Nonempty) {f : ι → α}
(hf : ∀ i ∈ t, f i ∈ s) : t.inf' ht f ∈ infClosure s :=
infClosed_infClosure.finsetInf'_mem _ fun _i hi ↦ subset_infClosure <| hf _ hi | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | finsetInf'_mem_infClosure | null |
infClosure_min : s ⊆ t → InfClosed t → infClosure s ⊆ t := infClosure.closure_min | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | infClosure_min | null |
protected Set.Finite.infClosure (hs : s.Finite) : (infClosure s).Finite := by
lift s to Finset α using hs
classical
refine ({t ∈ s.powerset | t.Nonempty}.attach.image
fun t ↦ t.1.inf' (mem_filter.1 t.2).2 id).finite_toSet.subset ?_
rintro _ ⟨t, ht, hts, rfl⟩
simp only [id_eq, coe_image, mem_image, mem_coe... | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | Set.Finite.infClosure | The semilattice generated by a finite set is finite. |
@[simps! isClosed]
latticeClosure : ClosureOperator (Set α) :=
.ofCompletePred IsSublattice fun _ ↦ isSublattice_sInter
@[simp] lemma subset_latticeClosure : s ⊆ latticeClosure s := latticeClosure.le_closure _
@[simp] lemma isSublattice_latticeClosure : IsSublattice (latticeClosure s) :=
latticeClosure.isClosed_clo... | def | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | latticeClosure | Every set in a join-semilattice generates a set closed under join. |
latticeClosure_min : s ⊆ t → IsSublattice t → latticeClosure s ⊆ t :=
latticeClosure.closure_min | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | latticeClosure_min | null |
latticeClosure_sup_inf_induction (p : (a : α) → a ∈ latticeClosure s → Prop)
(mem : ∀ (a : α) (has : a ∈ s), p a (subset_latticeClosure has))
(sup : ∀ (a : α) (has : a ∈ latticeClosure s) (b : α) (hbs : b ∈ latticeClosure s),
p a has → p b hbs → p (a ⊔ b) (isSublattice_latticeClosure.supClosed has hbs))
... | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | latticeClosure_sup_inf_induction | null |
latticeClosure_mono : Monotone (latticeClosure : Set α → Set α) := latticeClosure.monotone
@[simp] lemma latticeClosure_eq_self : latticeClosure s = s ↔ IsSublattice s :=
latticeClosure.isClosed_iff.symm
alias ⟨_, IsSublattice.latticeClosure_eq⟩ := latticeClosure_eq_self | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | latticeClosure_mono | null |
latticeClosure_idem (s : Set α) : latticeClosure (latticeClosure s) = latticeClosure s :=
latticeClosure.idempotent _
@[simp] lemma latticeClosure_empty : latticeClosure (∅ : Set α) = ∅ := by simp
@[simp] lemma latticeClosure_singleton (a : α) : latticeClosure {a} = {a} := by simp
@[simp] lemma latticeClosure_univ : ... | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | latticeClosure_idem | null |
image_latticeClosure (s : Set α) (f : α → β)
(map_sup : ∀ a b, f (a ⊔ b) = f a ⊔ f b) (map_inf : ∀ a b, f (a ⊓ b) = f a ⊓ f b) :
f '' latticeClosure s = latticeClosure (f '' s) := by
simp only [subset_antisymm_iff, Set.image_subset_iff]
constructor <;> apply latticeClosure_sup_inf_induction
· exact fun a ... | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | image_latticeClosure | null |
ofDual_preimage_latticeClosure (s : Set α) :
ofDual ⁻¹' latticeClosure s = latticeClosure (ofDual ⁻¹' s) := by
change ClosureOperator.ofCompletePred _ _ _ = ClosureOperator.ofCompletePred _ _ _
congr 2
ext
exact ⟨fun h => ⟨h.2, h.1⟩, fun h => ⟨h.2, h.1⟩⟩ | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | ofDual_preimage_latticeClosure | null |
image_latticeClosure' (s : Set α) (f : α → β)
(map_sup : ∀ a b, f (a ⊔ b) = f a ⊓ f b) (map_inf : ∀ a b, f (a ⊓ b) = f a ⊔ f b) :
f '' latticeClosure s = latticeClosure (f '' s) := by
simpa only [Set.image_comp, ← Set.preimage_equiv_eq_image_symm, ← ofDual_preimage_latticeClosure]
using image_latticeClosu... | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | image_latticeClosure' | null |
protected SupClosed.infClosure (hs : SupClosed s) : SupClosed (infClosure s) := by
rintro _ ⟨t, ht, hts, rfl⟩ _ ⟨u, hu, hus, rfl⟩
rw [inf'_sup_inf']
exact finsetInf'_mem_infClosure _
fun i hi ↦ hs (hts (mem_product.1 hi).1) (hus (mem_product.1 hi).2) | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | SupClosed.infClosure | null |
protected InfClosed.supClosure (hs : InfClosed s) : InfClosed (supClosure s) := by
rintro _ ⟨t, ht, hts, rfl⟩ _ ⟨u, hu, hus, rfl⟩
rw [sup'_inf_sup']
exact finsetSup'_mem_supClosure _
fun i hi ↦ hs (hts (mem_product.1 hi).1) (hus (mem_product.1 hi).2)
@[simp] lemma supClosure_infClosure (s : Set α) : supClosur... | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | InfClosed.supClosure | null |
Set.Finite.latticeClosure (hs : s.Finite) : (latticeClosure s).Finite := by
rw [← supClosure_infClosure]; exact hs.infClosure.supClosure
@[simp] lemma latticeClosure_prod (s : Set α) (t : Set β) :
latticeClosure (s ×ˢ t) = latticeClosure s ×ˢ latticeClosure t := by
simp_rw [← supClosure_infClosure]; simp | lemma | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | Set.Finite.latticeClosure | null |
SemilatticeSup.toCompleteSemilatticeSup [SemilatticeSup α] (sSup : Set α → α)
(h : ∀ s, SupClosed s → IsLUB s (sSup s)) : CompleteSemilatticeSup α where
sSup := fun s => sSup (supClosure s)
le_sSup _ _ ha := (h _ supClosed_supClosure).1 <| subset_supClosure ha
sSup_le s a ha := (isLUB_le_iff <| h _ supClosed_... | def | Order | [
"Mathlib.Data.Finset.Lattice.Prod",
"Mathlib.Data.Finset.Powerset",
"Mathlib.Data.Set.Finite.Basic",
"Mathlib.Order.Closure",
"Mathlib.Order.ConditionallyCompleteLattice.Finset"
] | Mathlib/Order/SupClosed.lean | SemilatticeSup.toCompleteSemilatticeSup | A join-semilattice where every sup-closed set has a least upper bound is automatically complete. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.