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 ⌀ |
|---|---|---|---|---|---|---|
ScottContinuousOn.sup₂ {D : Set (Set (β × β))} :
ScottContinuousOn D fun (a, b) => (a ⊔ b : β) :=
ScottContinuous.sup₂.scottContinuousOn | lemma | Order | [
"Mathlib.Order.Bounds.Basic"
] | Mathlib/Order/ScottContinuity.lean | ScottContinuousOn.sup₂ | null |
IsOrderRightAdjoint [Preorder α] [Preorder β] (f : α → β) (g : β → α) :=
∀ y, IsLUB { x | f x ≤ y } (g y) | def | Order | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.Algebra.Order.Group.End",
"Mathlib.Logic.Function.Conjugate",
"Mathlib.Order.Bounds.OrderIso",
"Mathlib.Order.OrdContinuous"
] | Mathlib/Order/SemiconjSup.lean | IsOrderRightAdjoint | We say that `g : β → α` is an order right adjoint function for `f : α → β` if it sends each `y`
to a least upper bound for `{x | f x ≤ y}`. If `α` is a partial order, and `f : α → β` has
a right adjoint, then this right adjoint is unique. |
isOrderRightAdjoint_sSup [CompleteSemilatticeSup α] [Preorder β] (f : α → β) :
IsOrderRightAdjoint f fun y => sSup { x | f x ≤ y } := fun _ => isLUB_sSup _ | theorem | Order | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.Algebra.Order.Group.End",
"Mathlib.Logic.Function.Conjugate",
"Mathlib.Order.Bounds.OrderIso",
"Mathlib.Order.OrdContinuous"
] | Mathlib/Order/SemiconjSup.lean | isOrderRightAdjoint_sSup | null |
isOrderRightAdjoint_csSup [ConditionallyCompleteLattice α] [Preorder β] (f : α → β)
(hne : ∀ y, ∃ x, f x ≤ y) (hbdd : ∀ y, BddAbove { x | f x ≤ y }) :
IsOrderRightAdjoint f fun y => sSup { x | f x ≤ y } := fun y => isLUB_csSup (hne y) (hbdd y) | theorem | Order | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.Algebra.Order.Group.End",
"Mathlib.Logic.Function.Conjugate",
"Mathlib.Order.Bounds.OrderIso",
"Mathlib.Order.OrdContinuous"
] | Mathlib/Order/SemiconjSup.lean | isOrderRightAdjoint_csSup | null |
protected unique [PartialOrder α] [Preorder β] {f : α → β} {g₁ g₂ : β → α}
(h₁ : IsOrderRightAdjoint f g₁) (h₂ : IsOrderRightAdjoint f g₂) : g₁ = g₂ :=
funext fun y => (h₁ y).unique (h₂ y) | theorem | Order | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.Algebra.Order.Group.End",
"Mathlib.Logic.Function.Conjugate",
"Mathlib.Order.Bounds.OrderIso",
"Mathlib.Order.OrdContinuous"
] | Mathlib/Order/SemiconjSup.lean | unique | null |
right_mono [Preorder α] [Preorder β] {f : α → β} {g : β → α} (h : IsOrderRightAdjoint f g) :
Monotone g := fun y₁ y₂ hy => ((h y₁).mono (h y₂)) fun _ hx => le_trans hx hy | theorem | Order | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.Algebra.Order.Group.End",
"Mathlib.Logic.Function.Conjugate",
"Mathlib.Order.Bounds.OrderIso",
"Mathlib.Order.OrdContinuous"
] | Mathlib/Order/SemiconjSup.lean | right_mono | null |
orderIso_comp [Preorder α] [Preorder β] [Preorder γ] {f : α → β} {g : β → α}
(h : IsOrderRightAdjoint f g) (e : β ≃o γ) : IsOrderRightAdjoint (e ∘ f) (g ∘ e.symm) :=
fun y => by simpa [e.le_symm_apply] using h (e.symm y) | theorem | Order | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.Algebra.Order.Group.End",
"Mathlib.Logic.Function.Conjugate",
"Mathlib.Order.Bounds.OrderIso",
"Mathlib.Order.OrdContinuous"
] | Mathlib/Order/SemiconjSup.lean | orderIso_comp | null |
comp_orderIso [Preorder α] [Preorder β] [Preorder γ] {f : α → β} {g : β → α}
(h : IsOrderRightAdjoint f g) (e : γ ≃o α) : IsOrderRightAdjoint (f ∘ e) (e.symm ∘ g) := by
intro y
change IsLUB (e ⁻¹' { x | f x ≤ y }) (e.symm (g y))
rw [e.isLUB_preimage, e.apply_symm_apply]
exact h y | theorem | Order | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.Algebra.Order.Group.End",
"Mathlib.Logic.Function.Conjugate",
"Mathlib.Order.Bounds.OrderIso",
"Mathlib.Order.OrdContinuous"
] | Mathlib/Order/SemiconjSup.lean | comp_orderIso | null |
Semiconj.symm_adjoint [PartialOrder α] [Preorder β] {fa : α ≃o α} {fb : β ↪o β} {g : α → β}
(h : Function.Semiconj g fa fb) {g' : β → α} (hg' : IsOrderRightAdjoint g g') :
Function.Semiconj g' fb fa := by
refine fun y => (hg' _).unique ?_
rw [← fa.surjective.image_preimage { x | g x ≤ fb y }, preimage_setOf... | theorem | Order | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.Algebra.Order.Group.End",
"Mathlib.Logic.Function.Conjugate",
"Mathlib.Order.Bounds.OrderIso",
"Mathlib.Order.OrdContinuous"
] | Mathlib/Order/SemiconjSup.lean | Semiconj.symm_adjoint | If an order automorphism `fa` is semiconjugate to an order embedding `fb` by a function `g`
and `g'` is an order right adjoint of `g` (i.e. `g' y = sSup {x | f x ≤ y}`), then `fb` is
semiconjugate to `fa` by `g'`.
This is a version of Proposition 2.1 from [Étienne Ghys, Groupes d'homéomorphismes du cercle et
cohomolog... |
semiconj_of_isLUB [PartialOrder α] [Group G] (f₁ f₂ : G →* α ≃o α) {h : α → α}
(H : ∀ x, IsLUB (range fun g' => (f₁ g')⁻¹ (f₂ g' x)) (h x)) (g : G) :
Function.Semiconj h (f₂ g) (f₁ g) := by
refine fun y => (H _).unique ?_
have := (f₁ g).leftOrdContinuous (H y)
rw [← range_comp, ← (Equiv.mulRight g).surjec... | theorem | Order | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.Algebra.Order.Group.End",
"Mathlib.Logic.Function.Conjugate",
"Mathlib.Order.Bounds.OrderIso",
"Mathlib.Order.OrdContinuous"
] | Mathlib/Order/SemiconjSup.lean | semiconj_of_isLUB | null |
sSup_div_semiconj [CompleteLattice α] [Group G] (f₁ f₂ : G →* α ≃o α) (g : G) :
Function.Semiconj (fun x => ⨆ g' : G, (f₁ g')⁻¹ (f₂ g' x)) (f₂ g) (f₁ g) :=
semiconj_of_isLUB f₁ f₂ (fun _ => isLUB_iSup) _ | theorem | Order | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.Algebra.Order.Group.End",
"Mathlib.Logic.Function.Conjugate",
"Mathlib.Order.Bounds.OrderIso",
"Mathlib.Order.OrdContinuous"
] | Mathlib/Order/SemiconjSup.lean | sSup_div_semiconj | Consider two actions `f₁ f₂ : G → α → α` of a group on a complete lattice by order
isomorphisms. Then the map `x ↦ ⨆ g : G, (f₁ g)⁻¹ (f₂ g x)` semiconjugates each `f₁ g'` to `f₂ g'`.
This is a version of Proposition 5.4 from [Étienne Ghys, Groupes d'homéomorphismes du cercle et
cohomologie bornée][ghys87:groupes]. |
csSup_div_semiconj [ConditionallyCompleteLattice α] [Group G] (f₁ f₂ : G →* α ≃o α)
(hbdd : ∀ x, BddAbove (range fun g => (f₁ g)⁻¹ (f₂ g x))) (g : G) :
Function.Semiconj (fun x => ⨆ g' : G, (f₁ g')⁻¹ (f₂ g' x)) (f₂ g) (f₁ g) :=
semiconj_of_isLUB f₁ f₂ (fun x => isLUB_csSup (range_nonempty _) (hbdd x)) _ | theorem | Order | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.Algebra.Order.Group.End",
"Mathlib.Logic.Function.Conjugate",
"Mathlib.Order.Bounds.OrderIso",
"Mathlib.Order.OrdContinuous"
] | Mathlib/Order/SemiconjSup.lean | csSup_div_semiconj | Consider two actions `f₁ f₂ : G → α → α` of a group on a conditionally complete lattice by order
isomorphisms. Suppose that each set $s(x)=\{f_1(g)^{-1} (f_2(g)(x)) | g \in G\}$ is bounded above.
Then the map `x ↦ sSup s(x)` semiconjugates each `f₁ g'` to `f₂ g'`.
This is a version of Proposition 5.4 from [Étienne Ghy... |
WithBot.range_eq (f : WithBot α → β) :
range f = insert (f ⊥) (range (f ∘ WithBot.some : α → β)) :=
Option.range_eq f | theorem | Order | [
"Mathlib.Data.Set.Image",
"Mathlib.Order.TypeTags"
] | Mathlib/Order/Set.lean | WithBot.range_eq | null |
WithTop.range_eq (f : WithTop α → β) :
range f = insert (f ⊤) (range (f ∘ WithBot.some : α → β)) :=
Option.range_eq f | theorem | Order | [
"Mathlib.Data.Set.Image",
"Mathlib.Order.TypeTags"
] | Mathlib/Order/Set.lean | WithTop.range_eq | null |
not_isMax_coe (hm : ¬ IsMax m) :
¬ IsMax m.1 :=
fun h ↦ hm (fun _ hb ↦ h hb) | lemma | Order | [
"Mathlib.Order.Max",
"Mathlib.Data.Set.CoeSort"
] | Mathlib/Order/SetIsMax.lean | not_isMax_coe | null |
not_isMin_coe (hm : ¬ IsMin m) :
¬ IsMin m.1 :=
fun h ↦ hm (fun _ hb ↦ h hb) | lemma | Order | [
"Mathlib.Order.Max",
"Mathlib.Data.Set.CoeSort"
] | Mathlib/Order/SetIsMax.lean | not_isMin_coe | null |
SupSet (α : Type*) where
/-- Supremum of a set -/
sSup : Set α → α | class | Order | [
"Mathlib.Data.Set.Operations",
"Mathlib.Util.Notation3"
] | Mathlib/Order/SetNotation.lean | SupSet | Class for the `sSup` operator |
InfSet (α : Type*) where
/-- Infimum of a set -/
sInf : Set α → α
export SupSet (sSup)
export InfSet (sInf) | class | Order | [
"Mathlib.Data.Set.Operations",
"Mathlib.Util.Notation3"
] | Mathlib/Order/SetNotation.lean | InfSet | Class for the `sInf` operator |
iSup [SupSet α] (s : ι → α) : α :=
sSup (range s) | def | Order | [
"Mathlib.Data.Set.Operations",
"Mathlib.Util.Notation3"
] | Mathlib/Order/SetNotation.lean | iSup | Indexed supremum |
iInf [InfSet α] (s : ι → α) : α :=
sInf (range s) | def | Order | [
"Mathlib.Data.Set.Operations",
"Mathlib.Util.Notation3"
] | Mathlib/Order/SetNotation.lean | iInf | Indexed infimum |
@[app_delab iSup]
iSup_delab : Delab := whenPPOption Lean.getPPNotation <| withOverApp 4 do
let #[_, ι, _, f] := (← SubExpr.getExpr).getAppArgs | failure
unless f.isLambda do failure
let prop ← Meta.isProp ι
let dep := f.bindingBody!.hasLooseBVar 0
let ppTypes ← getPPOption getPPFunBinderTypes
let stx ← Sub... | def | Order | [
"Mathlib.Data.Set.Operations",
"Mathlib.Util.Notation3"
] | Mathlib/Order/SetNotation.lean | iSup_delab | Indexed supremum. -/
notation3 "⨆ "(...)", "r:60:(scoped f => iSup f) => r
/-- Indexed infimum. -/
notation3 "⨅ "(...)", "r:60:(scoped f => iInf f) => r
section delaborators
open Lean Lean.PrettyPrinter.Delaborator
/-- Delaborator for indexed supremum. |
@[app_delab iInf]
iInf_delab : Delab := whenPPOption Lean.getPPNotation <| withOverApp 4 do
let #[_, ι, _, f] := (← SubExpr.getExpr).getAppArgs | failure
unless f.isLambda do failure
let prop ← Meta.isProp ι
let dep := f.bindingBody!.hasLooseBVar 0
let ppTypes ← getPPOption getPPFunBinderTypes
let stx ← Sub... | def | Order | [
"Mathlib.Data.Set.Operations",
"Mathlib.Util.Notation3"
] | Mathlib/Order/SetNotation.lean | iInf_delab | Delaborator for indexed infimum. |
sInter (S : Set (Set α)) : Set α :=
sInf S | def | Order | [
"Mathlib.Data.Set.Operations",
"Mathlib.Util.Notation3"
] | Mathlib/Order/SetNotation.lean | sInter | Intersection of a set of sets. |
sUnion (S : Set (Set α)) : Set α :=
sSup S | def | Order | [
"Mathlib.Data.Set.Operations",
"Mathlib.Util.Notation3"
] | Mathlib/Order/SetNotation.lean | sUnion | Notation for `Set.sInter` Intersection of a set of sets. -/
prefix:110 "⋂₀ " => sInter
/-- Union of a set of sets. |
iUnion (s : ι → Set α) : Set α :=
iSup s | def | Order | [
"Mathlib.Data.Set.Operations",
"Mathlib.Util.Notation3"
] | Mathlib/Order/SetNotation.lean | iUnion | Notation for `Set.sUnion`. Union of a set of sets. -/
prefix:110 "⋃₀ " => sUnion
@[simp, grind =]
theorem mem_sInter {x : α} {S : Set (Set α)} : x ∈ ⋂₀ S ↔ ∀ t ∈ S, x ∈ t :=
Iff.rfl
@[simp, grind =]
theorem mem_sUnion {x : α} {S : Set (Set α)} : x ∈ ⋃₀ S ↔ ∃ t ∈ S, x ∈ t :=
Iff.rfl
/-- Indexed union of a family ... |
iInter (s : ι → Set α) : Set α :=
iInf s | def | Order | [
"Mathlib.Data.Set.Operations",
"Mathlib.Util.Notation3"
] | Mathlib/Order/SetNotation.lean | iInter | Indexed intersection of a family of sets |
@[app_delab Set.iUnion]
iUnion_delab : Delab := whenPPOption Lean.getPPNotation do
let #[_, ι, f] := (← SubExpr.getExpr).getAppArgs | failure
unless f.isLambda do failure
let prop ← Meta.isProp ι
let dep := f.bindingBody!.hasLooseBVar 0
let ppTypes ← getPPOption getPPFunBinderTypes
let stx ← SubExpr.withApp... | def | Order | [
"Mathlib.Data.Set.Operations",
"Mathlib.Util.Notation3"
] | Mathlib/Order/SetNotation.lean | iUnion_delab | Notation for `Set.iUnion`. Indexed union of a family of sets -/
notation3 "⋃ "(...)", "r:60:(scoped f => iUnion f) => r
/-- Notation for `Set.iInter`. Indexed intersection of a family of sets -/
notation3 "⋂ "(...)", "r:60:(scoped f => iInter f) => r
section delaborators
open Lean Lean.PrettyPrinter.Delaborator
/--... |
@[app_delab Set.iInter]
sInter_delab : Delab := whenPPOption Lean.getPPNotation do
let #[_, ι, f] := (← SubExpr.getExpr).getAppArgs | failure
unless f.isLambda do failure
let prop ← Meta.isProp ι
let dep := f.bindingBody!.hasLooseBVar 0
let ppTypes ← getPPOption getPPFunBinderTypes
let stx ← SubExpr.withApp... | def | Order | [
"Mathlib.Data.Set.Operations",
"Mathlib.Util.Notation3"
] | Mathlib/Order/SetNotation.lean | sInter_delab | Delaborator for indexed intersections. |
@[simp]
mem_iUnion {x : α} {s : ι → Set α} : (x ∈ ⋃ i, s i) ↔ ∃ i, x ∈ s i :=
⟨fun ⟨_, ⟨⟨a, (t_eq : s a = _)⟩, (h : x ∈ _)⟩⟩ => ⟨a, t_eq.symm ▸ h⟩, fun ⟨a, h⟩ =>
⟨s a, ⟨⟨a, rfl⟩, h⟩⟩⟩
@[simp] | theorem | Order | [
"Mathlib.Data.Set.Operations",
"Mathlib.Util.Notation3"
] | Mathlib/Order/SetNotation.lean | mem_iUnion | null |
mem_iInter {x : α} {s : ι → Set α} : (x ∈ ⋂ i, s i) ↔ ∀ i, x ∈ s i :=
⟨fun (h : ∀ a ∈ { a : Set α | ∃ i, s i = a }, x ∈ a) a => h (s a) ⟨a, rfl⟩,
fun h _ ⟨a, (eq : s a = _)⟩ => eq ▸ h a⟩
@[simp] | theorem | Order | [
"Mathlib.Data.Set.Operations",
"Mathlib.Util.Notation3"
] | Mathlib/Order/SetNotation.lean | mem_iInter | null |
sSup_eq_sUnion (S : Set (Set α)) : sSup S = ⋃₀S :=
rfl
@[simp] | theorem | Order | [
"Mathlib.Data.Set.Operations",
"Mathlib.Util.Notation3"
] | Mathlib/Order/SetNotation.lean | sSup_eq_sUnion | null |
sInf_eq_sInter (S : Set (Set α)) : sInf S = ⋂₀ S :=
rfl
@[simp] | theorem | Order | [
"Mathlib.Data.Set.Operations",
"Mathlib.Util.Notation3"
] | Mathlib/Order/SetNotation.lean | sInf_eq_sInter | null |
iSup_eq_iUnion (s : ι → Set α) : iSup s = iUnion s :=
rfl
@[simp] | theorem | Order | [
"Mathlib.Data.Set.Operations",
"Mathlib.Util.Notation3"
] | Mathlib/Order/SetNotation.lean | iSup_eq_iUnion | null |
iInf_eq_iInter (s : ι → Set α) : iInf s = iInter s :=
rfl | theorem | Order | [
"Mathlib.Data.Set.Operations",
"Mathlib.Util.Notation3"
] | Mathlib/Order/SetNotation.lean | iInf_eq_iInter | null |
noncomputable orderIsoShrink [Preorder α] : α ≃o Shrink.{u} α where
toEquiv := equivShrink α
map_rel_iff' {a b} := by
obtain ⟨a, rfl⟩ := (equivShrink.{u} α).symm.surjective a
obtain ⟨b, rfl⟩ := (equivShrink.{u} α).symm.surjective b
simp only [Equiv.apply_symm_apply]
rfl
variable {α}
@[simp] | def | Order | [
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Logic.Small.Defs"
] | Mathlib/Order/Shrink.lean | orderIsoShrink | The order isomorphism `α ≃o Shrink.{u} α`. |
orderIsoShrink_apply [Preorder α] (a : α) :
orderIsoShrink α a = equivShrink α a := rfl
@[simp] | lemma | Order | [
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Logic.Small.Defs"
] | Mathlib/Order/Shrink.lean | orderIsoShrink_apply | null |
orderIsoShrink_symm_apply [Preorder α] (a : Shrink.{u} α) :
(orderIsoShrink α).symm a = (equivShrink α).symm a := rfl | lemma | Order | [
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Logic.Small.Defs"
] | Mathlib/Order/Shrink.lean | orderIsoShrink_symm_apply | null |
@[simp]
equivShrink_bot [Bot α] : equivShrink.{u} α ⊥ = ⊥ := rfl
@[simp] | lemma | Order | [
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Logic.Small.Defs"
] | Mathlib/Order/Shrink.lean | equivShrink_bot | null |
equivShrink_symm_bot [Bot α] : (equivShrink.{u} α).symm ⊥ = ⊥ :=
(equivShrink.{u} α).injective (by simp) | lemma | Order | [
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Logic.Small.Defs"
] | Mathlib/Order/Shrink.lean | equivShrink_symm_bot | null |
@[simp]
equivShrink_top [Top α] : equivShrink.{u} α ⊤ = ⊤ := rfl
@[simp] | lemma | Order | [
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Logic.Small.Defs"
] | Mathlib/Order/Shrink.lean | equivShrink_top | null |
equivShrink_symm_top [Top α] : (equivShrink.{u} α).symm ⊤ = ⊤ :=
(equivShrink.{u} α).injective (by simp) | lemma | Order | [
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Logic.Small.Defs"
] | Mathlib/Order/Shrink.lean | equivShrink_symm_top | null |
Sublattice where
/-- The underlying set of a sublattice. **Do not use directly**. Instead, use the coercion
`Sublattice α → Set α`, which Lean should automatically insert for you in most cases. -/
carrier : Set α
supClosed' : SupClosed carrier
infClosed' : InfClosed carrier
variable {α β γ} | structure | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | Sublattice | A sublattice of a lattice is a set containing the suprema and infima of any of its elements. |
instSetLike : SetLike (Sublattice α) α where
coe L := L.carrier
coe_injective' L M h := by cases L; congr | instance | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | instSetLike | null |
Simps.coe (L : Sublattice α) : Set α := L
initialize_simps_projections Sublattice (carrier → coe, as_prefix coe) | def | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | Simps.coe | See Note [custom simps projection]. |
ofIsSublattice (s : Set α) (hs : IsSublattice s) : Sublattice α := ⟨s, hs.1, hs.2⟩ | abbrev | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | ofIsSublattice | Turn a set closed under supremum and infimum into a sublattice. |
coe_inj : (L : Set α) = M ↔ L = M := SetLike.coe_set_eq
@[simp] lemma supClosed (L : Sublattice α) : SupClosed (L : Set α) := L.supClosed'
@[simp] lemma infClosed (L : Sublattice α) : InfClosed (L : Set α) := L.infClosed' | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | coe_inj | null |
sup_mem (ha : a ∈ L) (hb : b ∈ L) : a ⊔ b ∈ L := L.supClosed ha hb | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | sup_mem | null |
inf_mem (ha : a ∈ L) (hb : b ∈ L) : a ⊓ b ∈ L := L.infClosed ha hb
@[simp] lemma isSublattice (L : Sublattice α) : IsSublattice (L : Set α) :=
⟨L.supClosed, L.infClosed⟩
@[simp] lemma mem_carrier : a ∈ L.carrier ↔ a ∈ L := Iff.rfl
@[simp] lemma mem_mk (h_sup h_inf) : a ∈ mk s h_sup h_inf ↔ a ∈ s := Iff.rfl
@[simp, no... | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | inf_mem | null |
protected copy (L : Sublattice α) (s : Set α) (hs : s = L) : Sublattice α where
carrier := s
supClosed' := hs.symm ▸ L.supClosed'
infClosed' := hs.symm ▸ L.infClosed'
@[simp, norm_cast] lemma coe_copy (L : Sublattice α) (s : Set α) (hs) : L.copy s hs = s := rfl | def | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | copy | Copy of a sublattice with a new `carrier` equal to the old one. Useful to fix definitional
equalities. |
copy_eq (L : Sublattice α) (s : Set α) (hs) : L.copy s hs = L := SetLike.coe_injective hs | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | copy_eq | null |
ext : (∀ a, a ∈ L ↔ a ∈ M) → L = M := SetLike.ext | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | ext | Two sublattices are equal if they have the same elements. |
instSupCoe : Max L where
max a b := ⟨a ⊔ b, L.supClosed a.2 b.2⟩ | instance | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | instSupCoe | A sublattice of a lattice inherits a supremum. |
instInfCoe : Min L where
min a b := ⟨a ⊓ b, L.infClosed a.2 b.2⟩
@[simp, norm_cast] lemma coe_sup (a b : L) : a ⊔ b = (a : α) ⊔ b := rfl
@[simp, norm_cast] lemma coe_inf (a b : L) : a ⊓ b = (a : α) ⊓ b := rfl
@[simp] lemma mk_sup_mk (a b : α) (ha hb) : (⟨a, ha⟩ ⊔ ⟨b, hb⟩ : L) = ⟨a ⊔ b, L.supClosed ha hb⟩ :=
rfl
@[s... | instance | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | instInfCoe | A sublattice of a lattice inherits an infimum. |
instLatticeCoe (L : Sublattice α) : Lattice L :=
Subtype.coe_injective.lattice _ (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) | instance | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | instLatticeCoe | A sublattice of a lattice inherits a lattice structure. |
instDistribLatticeCoe {α : Type*} [DistribLattice α] (L : Sublattice α) :
DistribLattice L :=
Subtype.coe_injective.distribLattice _ (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) | instance | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | instDistribLatticeCoe | A sublattice of a distributive lattice inherits a distributive lattice structure. |
subtype (L : Sublattice α) : LatticeHom L α where
toFun := ((↑) : L → α)
map_sup' _ _ := rfl
map_inf' _ _ := rfl
@[simp, norm_cast] lemma coe_subtype (L : Sublattice α) : L.subtype = ((↑) : L → α) := rfl | def | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | subtype | The natural lattice hom from a sublattice to the original lattice. |
subtype_apply (L : Sublattice α) (a : L) : L.subtype a = a := rfl | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | subtype_apply | null |
subtype_injective (L : Sublattice α) : Injective <| subtype L := Subtype.coe_injective | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | subtype_injective | null |
inclusion (h : L ≤ M) : LatticeHom L M where
toFun := Set.inclusion h
map_sup' _ _ := rfl
map_inf' _ _ := rfl
@[simp] lemma coe_inclusion (h : L ≤ M) : inclusion h = Set.inclusion h := rfl | def | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | inclusion | The inclusion homomorphism from a sublattice `L` to a bigger sublattice `M`. |
inclusion_apply (h : L ≤ M) (a : L) : inclusion h a = Set.inclusion h a := rfl | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | inclusion_apply | null |
inclusion_injective (h : L ≤ M) : Injective <| inclusion h := Set.inclusion_injective h
@[simp] lemma inclusion_rfl (L : Sublattice α) : inclusion le_rfl = LatticeHom.id L := rfl
@[simp] lemma subtype_comp_inclusion (h : L ≤ M) : M.subtype.comp (inclusion h) = L.subtype := rfl | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | inclusion_injective | null |
instTop : Top (Sublattice α) where
top.carrier := univ
top.supClosed' := supClosed_univ
top.infClosed' := infClosed_univ | instance | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | instTop | The maximum sublattice of a lattice. |
instBot : Bot (Sublattice α) where
bot.carrier := ∅
bot.supClosed' := supClosed_empty
bot.infClosed' := infClosed_empty | instance | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | instBot | The empty sublattice of a lattice. |
instInf : Min (Sublattice α) where
min L M := { carrier := L ∩ M
supClosed' := L.supClosed.inter M.supClosed
infClosed' := L.infClosed.inter M.infClosed } | instance | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | instInf | The inf of two sublattices is their intersection. |
instInfSet : InfSet (Sublattice α) where
sInf S := { carrier := ⨅ L ∈ S, L
supClosed' := supClosed_sInter <| forall_mem_range.2 fun L ↦ supClosed_sInter <|
forall_mem_range.2 fun _ ↦ L.supClosed
infClosed' := infClosed_sInter <| forall_mem_range.2 fun L ↦ infClosed_sInter <... | instance | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | instInfSet | The inf of sublattices is their intersection. |
instInhabited : Inhabited (Sublattice α) := ⟨⊥⟩ | instance | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | instInhabited | null |
topEquiv : (⊤ : Sublattice α) ≃o α where
toEquiv := Equiv.Set.univ _
map_rel_iff' := Iff.rfl
@[simp, norm_cast] lemma coe_top : (⊤ : Sublattice α) = (univ : Set α) := rfl
@[simp, norm_cast] lemma coe_bot : (⊥ : Sublattice α) = (∅ : Set α) := rfl
@[simp, norm_cast] lemma coe_inf' (L M : Sublattice α) : L ⊓ M = (L : ... | def | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | topEquiv | The top sublattice is isomorphic to the original lattice.
This is the sublattice version of `Equiv.Set.univ α`. |
instCompleteLattice : CompleteLattice (Sublattice α) where
bot := ⊥
bot_le := fun _S _a ↦ False.elim
top := ⊤
le_top := fun _S a _ha ↦ mem_top a
inf := (· ⊓ ·)
le_inf := fun _L _M _N hM hN _a ha ↦ ⟨hM ha, hN ha⟩
inf_le_left := fun _L _M _a ↦ And.left
inf_le_right := fun _L _M _a ↦ And.right
__ := comp... | instance | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | instCompleteLattice | Sublattices of a lattice form a complete lattice. |
subsingleton_iff : Subsingleton (Sublattice α) ↔ IsEmpty α :=
⟨fun _ ↦ univ_eq_empty_iff.1 <| coe_inj.2 <| Subsingleton.elim ⊤ ⊥,
fun _ ↦ SetLike.coe_injective.subsingleton⟩ | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | subsingleton_iff | null |
comap (f : LatticeHom α β) (L : Sublattice β) : Sublattice α where
carrier := f ⁻¹' L
supClosed' := L.supClosed.preimage _
infClosed' := L.infClosed.preimage _
@[simp, norm_cast] lemma coe_comap (L : Sublattice β) (f : LatticeHom α β) : L.comap f = f ⁻¹' L :=
rfl
@[simp] lemma mem_comap {L : Sublattice β} : a ∈... | def | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | comap | The preimage of a sublattice along a lattice homomorphism. |
comap_mono : Monotone (comap f) := fun _ _ ↦ preimage_mono
@[simp] lemma comap_id (L : Sublattice α) : L.comap (LatticeHom.id _) = L := rfl
@[simp] lemma comap_comap (L : Sublattice γ) (g : LatticeHom β γ) (f : LatticeHom α β) :
(L.comap g).comap f = L.comap (g.comp f) := rfl | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | comap_mono | null |
map (f : LatticeHom α β) (L : Sublattice α) : Sublattice β where
carrier := f '' L
supClosed' := L.supClosed.image f
infClosed' := L.infClosed.image f
@[simp] lemma coe_map (f : LatticeHom α β) (L : Sublattice α) : (L.map f : Set β) = f '' L := rfl
@[simp] lemma mem_map {b : β} : b ∈ L.map f ↔ ∃ a ∈ L, f a = b :=... | def | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | map | The image of a sublattice along a monoid homomorphism is a sublattice. |
mem_map_of_mem (f : LatticeHom α β) {a : α} : a ∈ L → f a ∈ L.map f := mem_image_of_mem f | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | mem_map_of_mem | null |
apply_coe_mem_map (f : LatticeHom α β) (a : L) : f a ∈ L.map f := mem_map_of_mem f a.prop | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | apply_coe_mem_map | null |
map_mono : Monotone (map f) := fun _ _ ↦ image_mono
@[simp] lemma map_id : L.map (LatticeHom.id α) = L := SetLike.coe_injective <| image_id _
@[simp] lemma map_map (g : LatticeHom β γ) (f : LatticeHom α β) :
(L.map f).map g = L.map (g.comp f) := SetLike.coe_injective <| image_image _ _ _ | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | map_mono | null |
mem_map_equiv {f : α ≃o β} {a : β} : a ∈ L.map f ↔ f.symm a ∈ L := Set.mem_image_equiv | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | mem_map_equiv | null |
apply_mem_map_iff (hf : Injective f) : f a ∈ L.map f ↔ a ∈ L := hf.mem_set_image | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | apply_mem_map_iff | null |
map_equiv_eq_comap_symm (f : α ≃o β) (L : Sublattice α) :
L.map f = L.comap (f.symm : LatticeHom β α) :=
SetLike.coe_injective <| f.toEquiv.image_eq_preimage L | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | map_equiv_eq_comap_symm | null |
comap_equiv_eq_map_symm (f : β ≃o α) (L : Sublattice α) :
L.comap f = L.map (f.symm : LatticeHom α β) := (map_equiv_eq_comap_symm f.symm L).symm | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | comap_equiv_eq_map_symm | null |
map_symm_eq_iff_eq_map {M : Sublattice β} {e : β ≃o α} :
L.map ↑e.symm = M ↔ L = M.map ↑e := by
simp_rw [← coe_inj]; exact (Equiv.eq_image_iff_symm_image_eq _ _ _).symm | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | map_symm_eq_iff_eq_map | null |
map_le_iff_le_comap {f : LatticeHom α β} {M : Sublattice β} : L.map f ≤ M ↔ L ≤ M.comap f :=
image_subset_iff | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | map_le_iff_le_comap | null |
gc_map_comap (f : LatticeHom α β) : GaloisConnection (map f) (comap f) :=
fun _ _ ↦ map_le_iff_le_comap
@[simp] lemma map_bot (f : LatticeHom α β) : (⊥ : Sublattice α).map f = ⊥ := (gc_map_comap f).l_bot | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | gc_map_comap | null |
map_sup (f : LatticeHom α β) (L M : Sublattice α) : (L ⊔ M).map f = L.map f ⊔ M.map f :=
(gc_map_comap f).l_sup | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | map_sup | null |
map_iSup (f : LatticeHom α β) (L : ι → Sublattice α) : (⨆ i, L i).map f = ⨆ i, (L i).map f :=
(gc_map_comap f).l_iSup
@[simp] lemma comap_top (f : LatticeHom α β) : (⊤ : Sublattice β).comap f = ⊤ :=
(gc_map_comap f).u_top | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | map_iSup | null |
comap_inf (L M : Sublattice β) (f : LatticeHom α β) :
(L ⊓ M).comap f = L.comap f ⊓ M.comap f := (gc_map_comap f).u_inf | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | comap_inf | null |
comap_iInf (f : LatticeHom α β) (s : ι → Sublattice β) :
(iInf s).comap f = ⨅ i, (s i).comap f := (gc_map_comap f).u_iInf | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | comap_iInf | null |
map_inf_le (L M : Sublattice α) (f : LatticeHom α β) : map f (L ⊓ M) ≤ map f L ⊓ map f M :=
map_mono.map_inf_le _ _ | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | map_inf_le | null |
le_comap_sup (L M : Sublattice β) (f : LatticeHom α β) :
comap f L ⊔ comap f M ≤ comap f (L ⊔ M) := comap_mono.le_map_sup _ _ | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | le_comap_sup | null |
le_comap_iSup (f : LatticeHom α β) (L : ι → Sublattice β) :
⨆ i, (L i).comap f ≤ (⨆ i, L i).comap f := comap_mono.le_map_iSup | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | le_comap_iSup | null |
map_inf (L M : Sublattice α) (f : LatticeHom α β) (hf : Injective f) :
map f (L ⊓ M) = map f L ⊓ map f M := by
rw [← SetLike.coe_set_eq]
simp [Set.image_inter hf] | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | map_inf | null |
map_top (f : LatticeHom α β) (h : Surjective f) : Sublattice.map f ⊤ = ⊤ :=
SetLike.coe_injective <| by simp [h.range_eq] | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | map_top | null |
@[simps]
prod (L : Sublattice α) (M : Sublattice β) : Sublattice (α × β) where
carrier := L ×ˢ M
supClosed' := L.supClosed.prod M.supClosed
infClosed' := L.infClosed.prod M.infClosed
attribute [norm_cast] coe_prod
@[simp] lemma mem_prod {M : Sublattice β} {p : α × β} : p ∈ L.prod M ↔ p.1 ∈ L ∧ p.2 ∈ M := Iff.rfl
... | def | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | prod | Binary product of sublattices as a sublattice. |
prod_mono {L₁ L₂ : Sublattice α} {M₁ M₂ : Sublattice β} (hL : L₁ ≤ L₂) (hM : M₁ ≤ M₂) :
L₁.prod M₁ ≤ L₂.prod M₂ := Set.prod_mono hL hM | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | prod_mono | null |
prod_mono_left {L₁ L₂ : Sublattice α} {M : Sublattice β} (hL : L₁ ≤ L₂) :
L₁.prod M ≤ L₂.prod M := prod_mono hL le_rfl | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | prod_mono_left | null |
prod_mono_right {M₁ M₂ : Sublattice β} (hM : M₁ ≤ M₂) : L.prod M₁ ≤ L.prod M₂ :=
prod_mono le_rfl hM | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | prod_mono_right | null |
prod_left_mono : Monotone fun L : Sublattice α ↦ L.prod M := fun _ _ ↦ prod_mono_left | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | prod_left_mono | null |
prod_right_mono : Monotone fun M : Sublattice β ↦ L.prod M := fun _ _ ↦ prod_mono_right | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | prod_right_mono | null |
prod_top (L : Sublattice α) : L.prod (⊤ : Sublattice β) = L.comap LatticeHom.fst :=
ext fun a ↦ by simp [mem_prod, LatticeHom.coe_fst] | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | prod_top | null |
top_prod (L : Sublattice β) : (⊤ : Sublattice α).prod L = L.comap LatticeHom.snd :=
ext fun a ↦ by simp [mem_prod, LatticeHom.coe_snd]
@[simp] lemma top_prod_top : (⊤ : Sublattice α).prod (⊤ : Sublattice β) = ⊤ :=
(top_prod _).trans <| comap_top _
@[simp] lemma prod_bot (L : Sublattice α) : L.prod (⊥ : Sublattice β... | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | top_prod | null |
le_prod_iff {M : Sublattice β} {N : Sublattice (α × β)} :
N ≤ L.prod M ↔ N ≤ comap LatticeHom.fst L ∧ N ≤ comap LatticeHom.snd M := by
simp [SetLike.le_def, forall_and]
@[simp] lemma prod_eq_bot {M : Sublattice β} : L.prod M = ⊥ ↔ L = ⊥ ∨ M = ⊥ := by
simpa only [← coe_inj] using Set.prod_eq_empty_iff
@[simp] le... | lemma | Order | [
"Mathlib.Order.SupClosed"
] | Mathlib/Order/Sublattice.lean | le_prod_iff | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.