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 ⌀ |
|---|---|---|---|---|---|---|
cIoo (a b : α) : Set α :=
{ x | sbtw a x b }
@[simp] | def | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Tactic.Order"
] | Mathlib/Order/Circular.lean | cIoo | Open-open circular interval |
mem_cIcc {a b x : α} : x ∈ cIcc a b ↔ btw a x b :=
Iff.rfl
@[simp] | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Tactic.Order"
] | Mathlib/Order/Circular.lean | mem_cIcc | null |
mem_cIoo {a b x : α} : x ∈ cIoo a b ↔ sbtw a x b :=
Iff.rfl | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Tactic.Order"
] | Mathlib/Order/Circular.lean | mem_cIoo | null |
left_mem_cIcc (a b : α) : a ∈ cIcc a b :=
btw_rfl_left | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Tactic.Order"
] | Mathlib/Order/Circular.lean | left_mem_cIcc | null |
right_mem_cIcc (a b : α) : b ∈ cIcc a b :=
btw_rfl_right | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Tactic.Order"
] | Mathlib/Order/Circular.lean | right_mem_cIcc | null |
compl_cIcc {a b : α} : (cIcc a b)ᶜ = cIoo b a := by
ext
rw [Set.mem_cIoo, sbtw_iff_not_btw, cIcc, mem_compl_iff, mem_setOf] | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Tactic.Order"
] | Mathlib/Order/Circular.lean | compl_cIcc | null |
compl_cIoo {a b : α} : (cIoo a b)ᶜ = cIcc b a := by
ext
rw [Set.mem_cIcc, btw_iff_not_sbtw, cIoo, mem_compl_iff, mem_setOf] | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Tactic.Order"
] | Mathlib/Order/Circular.lean | compl_cIoo | null |
LE.toBtw (α : Type*) [LE α] : Btw α where
btw a b c := a ≤ b ∧ b ≤ c ∨ b ≤ c ∧ c ≤ a ∨ c ≤ a ∧ a ≤ b | abbrev | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Tactic.Order"
] | Mathlib/Order/Circular.lean | LE.toBtw | The betweenness relation obtained from "looping around" `≤`.
See note [reducible non-instances]. |
LT.toSBtw (α : Type*) [LT α] : SBtw α where
sbtw a b c := a < b ∧ b < c ∨ b < c ∧ c < a ∨ c < a ∧ a < b | abbrev | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Tactic.Order"
] | Mathlib/Order/Circular.lean | LT.toSBtw | The strict betweenness relation obtained from "looping around" `<`.
See note [reducible non-instances]. |
btw_iff [LE α] : btw a b c ↔ a ≤ b ∧ b ≤ c ∨ b ≤ c ∧ c ≤ a ∨ c ≤ a ∧ a ≤ b := .rfl | lemma | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Tactic.Order"
] | Mathlib/Order/Circular.lean | btw_iff | The following lemmas are about the non-instances `LE.toBtw`, `LT.toSBtw` and
`LinearOrder.toCircularOrder`. |
sbtw_iff [LT α] : sbtw a b c ↔ a < b ∧ b < c ∨ b < c ∧ c < a ∨ c < a ∧ a < b := .rfl | lemma | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Tactic.Order"
] | Mathlib/Order/Circular.lean | sbtw_iff | The following lemmas are about the non-instances `LE.toBtw`, `LT.toSBtw` and
`LinearOrder.toCircularOrder`. |
Preorder.toCircularPreorder (α : Type*) [Preorder α] : CircularPreorder α where
btw a b c := a ≤ b ∧ b ≤ c ∨ b ≤ c ∧ c ≤ a ∨ c ≤ a ∧ a ≤ b
sbtw a b c := a < b ∧ b < c ∨ b < c ∧ c < a ∨ c < a ∧ a < b
btw_refl _ := .inl ⟨le_rfl, le_rfl⟩
btw_cyclic_left {a b c} := .rotate
sbtw_trans_left {a b c d} := by
rint... | abbrev | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Tactic.Order"
] | Mathlib/Order/Circular.lean | Preorder.toCircularPreorder | The circular preorder obtained from "looping around" a preorder.
See note [reducible non-instances]. |
PartialOrder.toCircularPartialOrder (α : Type*) [PartialOrder α] : CircularPartialOrder α :=
{ Preorder.toCircularPreorder α with
btw_antisymm := fun {a b c} => by
rintro (⟨hab, hbc⟩ | ⟨hbc, hca⟩ | ⟨hca, hab⟩) (⟨hcb, hba⟩ | ⟨hba, hac⟩ | ⟨hac, hcb⟩)
· exact Or.inl (hab.antisymm hba)
· exact Or.in... | abbrev | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Tactic.Order"
] | Mathlib/Order/Circular.lean | PartialOrder.toCircularPartialOrder | The circular partial order obtained from "looping around" a partial order.
See note [reducible non-instances]. |
LinearOrder.toCircularOrder (α : Type*) [LinearOrder α] : CircularOrder α :=
{ PartialOrder.toCircularPartialOrder α with
btw_total := fun a b c => by
rcases le_total a b with hab | hba <;> rcases le_total b c with hbc | hcb <;>
rcases le_total c a with hca | hac
· exact Or.inl (Or.inl ⟨hab, h... | abbrev | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Tactic.Order"
] | Mathlib/Order/Circular.lean | LinearOrder.toCircularOrder | The circular order obtained from "looping around" a linear order.
See note [reducible non-instances]. |
btw (α : Type*) [Btw α] : Btw αᵒᵈ :=
⟨fun a b c : α => Btw.btw c b a⟩ | instance | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Tactic.Order"
] | Mathlib/Order/Circular.lean | btw | null |
sbtw (α : Type*) [SBtw α] : SBtw αᵒᵈ :=
⟨fun a b c : α => SBtw.sbtw c b a⟩ | instance | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Tactic.Order"
] | Mathlib/Order/Circular.lean | sbtw | null |
circularPreorder (α : Type*) [CircularPreorder α] : CircularPreorder αᵒᵈ :=
{ OrderDual.btw α,
OrderDual.sbtw α with
btw_refl := fun _ => @btw_refl α _ _
btw_cyclic_left := fun {_ _ _} => @btw_cyclic_right α _ _ _ _
sbtw_trans_left := fun {_ _ _ _} habc hbdc => hbdc.trans_right habc
sbtw_iff_btw_n... | instance | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Tactic.Order"
] | Mathlib/Order/Circular.lean | circularPreorder | null |
circularPartialOrder (α : Type*) [CircularPartialOrder α] : CircularPartialOrder αᵒᵈ :=
{ OrderDual.circularPreorder α with
btw_antisymm := fun {_ _ _} habc hcba => @btw_antisymm α _ _ _ _ hcba habc } | instance | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Tactic.Order"
] | Mathlib/Order/Circular.lean | circularPartialOrder | null |
ClosureOperator [Preorder α] extends α →o α where
/-- An element is less than or equal its closure -/
le_closure' : ∀ x, x ≤ toFun x
/-- Closures are idempotent -/
idempotent' : ∀ x, toFun (toFun x) = toFun x
/-- Predicate for an element to be closed.
By default, this is defined as `c.IsClosed x := (c x = x... | structure | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | ClosureOperator | A closure operator on the preorder `α` is a monotone function which is extensive (every `x`
is less than its closure) and idempotent. |
@[simps apply]
conjBy {α β} [Preorder α] [Preorder β] (c : ClosureOperator α)
(e : α ≃o β) : ClosureOperator β where
toFun := e.conj c
IsClosed b := c.IsClosed (e.symm b)
monotone' _ _ h :=
(map_le_map_iff e).mpr <| c.monotone <| (map_le_map_iff e.symm).mpr h
le_closure' _ := e.symm_apply_le.mp (c.le_cl... | def | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | conjBy | If `c` is a closure operator on `α` and `e` an order-isomorphism
between `α` and `β` then `e ∘ c ∘ e⁻¹` is a closure operator on `β`. |
conjBy_refl {α} [Preorder α] (c : ClosureOperator α) :
c.conjBy (OrderIso.refl α) = c := rfl | lemma | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | conjBy_refl | null |
conjBy_trans {α β γ} [Preorder α] [Preorder β] [Preorder γ]
(e₁ : α ≃o β) (e₂ : β ≃o γ) (c : ClosureOperator α) :
c.conjBy (e₁.trans e₂) = (c.conjBy e₁).conjBy e₂ := rfl | lemma | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | conjBy_trans | null |
@[simps!]
id : ClosureOperator α where
toOrderHom := OrderHom.id
le_closure' _ := le_rfl
idempotent' _ := rfl
IsClosed _ := True | def | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | id | The identity function as a closure operator. |
@[ext]
ext : ∀ c₁ c₂ : ClosureOperator α, (∀ x, c₁ x = c₂ x) → c₁ = c₂ :=
DFunLike.ext | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | ext | null |
@[simps]
mk' (f : α → α) (hf₁ : Monotone f) (hf₂ : ∀ x, x ≤ f x) (hf₃ : ∀ x, f (f x) ≤ f x) :
ClosureOperator α where
toFun := f
monotone' := hf₁
le_closure' := hf₂
idempotent' x := (hf₃ x).antisymm (hf₁ (hf₂ x)) | def | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | mk' | Constructor for a closure operator using the weaker idempotency axiom: `f (f x) ≤ f x`. |
@[simps]
mk₂ (f : α → α) (hf : ∀ x, x ≤ f x) (hmin : ∀ ⦃x y⦄, x ≤ f y → f x ≤ f y) :
ClosureOperator α where
toFun := f
monotone' _ y hxy := hmin (hxy.trans (hf y))
le_closure' := hf
idempotent' _ := (hmin le_rfl).antisymm (hf _) | def | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | mk₂ | Convenience constructor for a closure operator using the weaker minimality axiom:
`x ≤ f y → f x ≤ f y`, which is sometimes easier to prove in practice. |
@[simps!]
ofPred (f : α → α) (p : α → Prop) (hf : ∀ x, x ≤ f x) (hfp : ∀ x, p (f x))
(hmin : ∀ ⦃x y⦄, x ≤ y → p y → f x ≤ y) : ClosureOperator α where
__ := mk₂ f hf fun _ y hxy => hmin hxy (hfp y)
IsClosed := p
isClosed_iff := ⟨fun hx ↦ (hmin le_rfl hx).antisymm <| hf _, fun hx ↦ hx ▸ hfp _⟩
@[mono] | def | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | ofPred | Construct a closure operator from an inflationary function `f` and a "closedness" predicate `p`
witnessing minimality of `f x` among closed elements greater than `x`. |
monotone : Monotone c :=
c.monotone' | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | monotone | null |
le_closure (x : α) : x ≤ c x :=
c.le_closure' x
@[simp] | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | le_closure | Every element is less than its closure. This property is sometimes referred to as extensivity or
inflationarity. |
idempotent (x : α) : c (c x) = c x :=
c.idempotent' x
@[simp] lemma isClosed_closure (x : α) : c.IsClosed (c x) := c.isClosed_iff.2 <| c.idempotent x | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | idempotent | null |
Closeds := {x // c.IsClosed x} | abbrev | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | Closeds | The type of elements closed under a closure operator. |
toCloseds (x : α) : c.Closeds := ⟨c x, c.isClosed_closure x⟩
variable {c} {x y : α} | def | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | toCloseds | Send an element to a closed element (by taking the closure). |
IsClosed.closure_eq : c.IsClosed x → c x = x := c.isClosed_iff.1 | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | IsClosed.closure_eq | null |
isClosed_iff_closure_le : c.IsClosed x ↔ c x ≤ x :=
⟨fun h ↦ h.closure_eq.le, fun h ↦ c.isClosed_iff.2 <| h.antisymm <| c.le_closure x⟩ | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | isClosed_iff_closure_le | null |
setOf_isClosed_eq_range_closure : {x | c.IsClosed x} = Set.range c := by
ext x; exact ⟨fun hx ↦ ⟨x, hx.closure_eq⟩, by rintro ⟨y, rfl⟩; exact c.isClosed_closure _⟩ | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | setOf_isClosed_eq_range_closure | The set of closed elements for `c` is exactly its range. |
le_closure_iff : x ≤ c y ↔ c x ≤ c y :=
⟨fun h ↦ c.idempotent y ▸ c.monotone h, (c.le_closure x).trans⟩
@[simp] | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | le_closure_iff | null |
IsClosed.closure_le_iff (hy : c.IsClosed y) : c x ≤ y ↔ x ≤ y := by
rw [← hy.closure_eq, ← le_closure_iff] | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | IsClosed.closure_le_iff | null |
closure_min (hxy : x ≤ y) (hy : c.IsClosed y) : c x ≤ y := hy.closure_le_iff.2 hxy | lemma | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closure_min | null |
closure_isGLB (x : α) : IsGLB { y | x ≤ y ∧ c.IsClosed y } (c x) where
left _ := and_imp.mpr closure_min
right _ h := h ⟨c.le_closure x, c.isClosed_closure x⟩ | lemma | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closure_isGLB | null |
ext_isClosed (c₁ c₂ : ClosureOperator α)
(h : ∀ x, c₁.IsClosed x ↔ c₂.IsClosed x) : c₁ = c₂ :=
ext c₁ c₂ <| fun x => IsGLB.unique (c₁.closure_isGLB x) <|
(Set.ext (and_congr_right' <| h ·)).substr (c₂.closure_isGLB x) | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | ext_isClosed | null |
eq_ofPred_closed (c : ClosureOperator α) :
c = ofPred c c.IsClosed c.le_closure c.isClosed_closure fun _ _ ↦ closure_min := by
ext
rfl | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | eq_ofPred_closed | A closure operator is equal to the closure operator obtained by feeding `c.closed` into the
`ofPred` constructor. |
@[simp]
closure_top : c ⊤ = ⊤ :=
le_top.antisymm (c.le_closure _)
@[simp] lemma isClosed_top : c.IsClosed ⊤ := c.isClosed_iff.2 c.closure_top | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closure_top | null |
closure_inf_le [SemilatticeInf α] (c : ClosureOperator α) (x y : α) :
c (x ⊓ y) ≤ c x ⊓ c y :=
c.monotone.map_inf_le _ _ | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closure_inf_le | null |
closure_sup_closure_le (x y : α) : c x ⊔ c y ≤ c (x ⊔ y) :=
c.monotone.le_map_sup _ _ | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closure_sup_closure_le | null |
closure_sup_closure_left (x y : α) : c (c x ⊔ y) = c (x ⊔ y) :=
le_antisymm
(le_closure_iff.1 (sup_le (c.monotone le_sup_left) (le_sup_right.trans (c.le_closure _))))
(by grw [← c.le_closure x]) | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closure_sup_closure_left | null |
closure_sup_closure_right (x y : α) : c (x ⊔ c y) = c (x ⊔ y) := by
rw [sup_comm, closure_sup_closure_left, sup_comm (a := x)] | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closure_sup_closure_right | null |
closure_sup_closure (x y : α) : c (c x ⊔ c y) = c (x ⊔ y) := by
rw [closure_sup_closure_left, closure_sup_closure_right] | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closure_sup_closure | null |
@[simps!]
ofCompletePred (p : α → Prop) (hsinf : ∀ s, (∀ a ∈ s, p a) → p (sInf s)) : ClosureOperator α :=
ofPred (fun a ↦ ⨅ b : {b // a ≤ b ∧ p b}, b) p
(fun a ↦ by simp +contextual)
(fun _ ↦ hsinf _ <| forall_mem_range.2 fun b ↦ b.2.2)
(fun _ b hab hb ↦ iInf_le_of_le ⟨b, hab, hb⟩ le_rfl) | def | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | ofCompletePred | Define a closure operator from a predicate that's preserved under infima. |
sInf_isClosed {c : ClosureOperator α} {S : Set α}
(H : ∀ x ∈ S, c.IsClosed x) : c.IsClosed (sInf S) :=
isClosed_iff_closure_le.mpr <| le_of_le_of_eq c.monotone.map_sInf_le <|
Eq.trans (biInf_congr (c.isClosed_iff.mp <| H · ·)) sInf_eq_iInf.symm
@[simp] | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | sInf_isClosed | null |
closure_iSup_closure (f : ι → α) : c (⨆ i, c (f i)) = c (⨆ i, f i) :=
le_antisymm (le_closure_iff.1 <| iSup_le fun i => c.monotone <| le_iSup f i) <|
c.monotone <| iSup_mono fun _ => c.le_closure _
@[simp] | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closure_iSup_closure | null |
closure_iSup₂_closure (f : ∀ i, κ i → α) :
c (⨆ (i) (j), c (f i j)) = c (⨆ (i) (j), f i j) :=
le_antisymm (le_closure_iff.1 <| iSup₂_le fun i j => c.monotone <| le_iSup₂ i j) <|
c.monotone <| iSup₂_mono fun _ _ => c.le_closure _ | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closure_iSup₂_closure | null |
@[simps apply symm_apply]
OrderIso.equivClosureOperator {α β} [Preorder α] [Preorder β] (e : α ≃o β) :
ClosureOperator α ≃ ClosureOperator β where
toFun c := c.conjBy e
invFun c := c.conjBy e.symm
left_inv c := Eq.trans (c.conjBy_trans _ _).symm
<| Eq.trans (congrArg _ e.self_trans_sy... | def | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | OrderIso.equivClosureOperator | Conjugating `ClosureOperators` on `α` and on `β` by a fixed isomorphism
`e : α ≃o β` gives an equivalence `ClosureOperator α ≃ ClosureOperator β`. |
LowerAdjoint [Preorder α] [Preorder β] (u : β → α) where
/-- The underlying function -/
toFun : α → β
/-- The underlying function is a lower adjoint. -/
gc' : GaloisConnection toFun u | structure | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | LowerAdjoint | A lower adjoint of `u` on the preorder `α` is a function `l` such that `l` and `u` form a Galois
connection. It allows us to define closure operators whose output does not match the input. In
practice, `u` is often `(↑) : β → α`. |
@[simps]
protected id [Preorder α] : LowerAdjoint (id : α → α) where
toFun x := x
gc' := GaloisConnection.id
variable {α} | def | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | id | The identity function as a lower adjoint to itself. |
gc : GaloisConnection l u :=
l.gc'
@[ext] | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | gc | null |
ext : ∀ l₁ l₂ : LowerAdjoint u, (l₁ : α → β) = (l₂ : α → β) → l₁ = l₂
| ⟨l₁, _⟩, ⟨l₂, _⟩, h => by
congr
@[mono] | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | ext | null |
monotone : Monotone (u ∘ l) :=
l.gc.monotone_u.comp l.gc.monotone_l | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | monotone | null |
le_closure (x : α) : x ≤ u (l x) :=
l.gc.le_u_l _ | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | le_closure | Every element is less than its closure. This property is sometimes referred to as extensivity or
inflationarity. |
@[simps]
closureOperator : ClosureOperator α where
toFun x := u (l x)
monotone' := l.monotone
le_closure' := l.le_closure
idempotent' x := l.gc.u_l_u_eq_u (l x) | def | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closureOperator | Every lower adjoint induces a closure operator given by the composition. This is the partial
order version of the statement that every adjunction induces a monad. |
idempotent (x : α) : u (l (u (l x))) = u (l x) :=
l.closureOperator.idempotent _ | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | idempotent | null |
le_closure_iff (x y : α) : x ≤ u (l y) ↔ u (l x) ≤ u (l y) :=
l.closureOperator.le_closure_iff | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | le_closure_iff | null |
closed : Set α := {x | u (l x) = x} | def | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closed | An element `x` is closed for `l : LowerAdjoint u` if it is a fixed point: `u (l x) = x` |
mem_closed_iff (x : α) : x ∈ l.closed ↔ u (l x) = x :=
Iff.rfl | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | mem_closed_iff | null |
closure_eq_self_of_mem_closed {x : α} (h : x ∈ l.closed) : u (l x) = x :=
h | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closure_eq_self_of_mem_closed | null |
mem_closed_iff_closure_le (x : α) : x ∈ l.closed ↔ u (l x) ≤ x :=
l.closureOperator.isClosed_iff_closure_le
@[simp] | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | mem_closed_iff_closure_le | null |
closure_is_closed (x : α) : u (l x) ∈ l.closed :=
l.idempotent x | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closure_is_closed | null |
closed_eq_range_close : l.closed = Set.range (u ∘ l) :=
l.closureOperator.setOf_isClosed_eq_range_closure | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closed_eq_range_close | The set of closed elements for `l` is the range of `u ∘ l`. |
toClosed (x : α) : l.closed :=
⟨u (l x), l.closure_is_closed x⟩
@[simp] | def | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | toClosed | Send an `x` to an element of the set of closed elements (by taking the closure). |
closure_le_closed_iff_le (x : α) {y : α} (hy : l.closed y) : u (l x) ≤ y ↔ x ≤ y :=
(show l.closureOperator.IsClosed y from hy).closure_le_iff | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closure_le_closed_iff_le | null |
closure_top [PartialOrder α] [OrderTop α] [Preorder β] {u : β → α} (l : LowerAdjoint u) :
u (l ⊤) = ⊤ :=
l.closureOperator.closure_top | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closure_top | null |
closure_inf_le [SemilatticeInf α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (x y : α) :
u (l (x ⊓ y)) ≤ u (l x) ⊓ u (l y) :=
l.closureOperator.closure_inf_le x y | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closure_inf_le | null |
closure_sup_closure_le (x y : α) : u (l x) ⊔ u (l y) ≤ u (l (x ⊔ y)) :=
l.closureOperator.closure_sup_closure_le x y | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closure_sup_closure_le | null |
closure_sup_closure_left (x y : α) : u (l (u (l x) ⊔ y)) = u (l (x ⊔ y)) :=
l.closureOperator.closure_sup_closure_left x y | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closure_sup_closure_left | null |
closure_sup_closure_right (x y : α) : u (l (x ⊔ u (l y))) = u (l (x ⊔ y)) :=
l.closureOperator.closure_sup_closure_right x y | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closure_sup_closure_right | null |
closure_sup_closure (x y : α) : u (l (u (l x) ⊔ u (l y))) = u (l (x ⊔ y)) :=
l.closureOperator.closure_sup_closure x y | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closure_sup_closure | null |
closure_iSup_closure (f : ι → α) : u (l (⨆ i, u (l (f i)))) = u (l (⨆ i, f i)) :=
l.closureOperator.closure_iSup_closure _ | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closure_iSup_closure | null |
closure_iSup₂_closure (f : ∀ i, κ i → α) :
u (l <| ⨆ (i) (j), u (l <| f i j)) = u (l <| ⨆ (i) (j), f i j) :=
l.closureOperator.closure_iSup₂_closure _ | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closure_iSup₂_closure | null |
subset_closure (s : Set β) : s ⊆ l s :=
l.le_closure s | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | subset_closure | null |
notMem_of_notMem_closure {s : Set β} {P : β} (hP : P ∉ l s) : P ∉ s := fun h =>
hP (subset_closure _ s h)
@[deprecated (since := "2025-05-23")] alias not_mem_of_not_mem_closure := notMem_of_notMem_closure | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | notMem_of_notMem_closure | null |
le_iff_subset (s : Set β) (S : α) : l s ≤ S ↔ s ⊆ S :=
l.gc s S | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | le_iff_subset | null |
mem_iff (s : Set β) (x : β) : x ∈ l s ↔ ∀ S : α, s ⊆ S → x ∈ S := by
simp_rw [← SetLike.mem_coe, ← Set.singleton_subset_iff, ← l.le_iff_subset]
exact ⟨fun h S => h.trans, fun h => h _ le_rfl⟩ | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | mem_iff | null |
eq_of_le {s : Set β} {S : α} (h₁ : s ⊆ S) (h₂ : S ≤ l s) : l s = S :=
((l.le_iff_subset _ _).2 h₁).antisymm h₂ | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | eq_of_le | null |
closure_union_closure_subset (x y : α) : (l x : Set β) ∪ l y ⊆ l (x ∪ y) :=
l.closure_sup_closure_le x y
@[simp] | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closure_union_closure_subset | null |
closure_union_closure_left (x y : α) : l (l x ∪ y) = l (x ∪ y) :=
SetLike.coe_injective (l.closure_sup_closure_left x y)
@[simp] | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closure_union_closure_left | null |
closure_union_closure_right (x y : α) : l (x ∪ l y) = l (x ∪ y) :=
SetLike.coe_injective (l.closure_sup_closure_right x y) | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closure_union_closure_right | null |
closure_union_closure (x y : α) : l (l x ∪ l y) = l (x ∪ y) := by
rw [closure_union_closure_right, closure_union_closure_left]
@[simp] | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closure_union_closure | null |
closure_iUnion_closure (f : ι → α) : l (⋃ i, l (f i)) = l (⋃ i, f i) :=
SetLike.coe_injective <| l.closure_iSup_closure _
@[simp] | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closure_iUnion_closure | null |
closure_iUnion₂_closure (f : ∀ i, κ i → α) :
l (⋃ (i) (j), l (f i j)) = l (⋃ (i) (j), f i j) :=
SetLike.coe_injective <| l.closure_iSup₂_closure _ | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closure_iUnion₂_closure | null |
@[simps]
GaloisConnection.lowerAdjoint [Preorder α] [Preorder β] {l : α → β} {u : β → α}
(gc : GaloisConnection l u) : LowerAdjoint u where
toFun := l
gc' := gc | def | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | GaloisConnection.lowerAdjoint | Every Galois connection induces a lower adjoint. |
@[simps!]
GaloisConnection.closureOperator [PartialOrder α] [Preorder β] {l : α → β} {u : β → α}
(gc : GaloisConnection l u) : ClosureOperator α :=
gc.lowerAdjoint.closureOperator | def | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | GaloisConnection.closureOperator | Every Galois connection induces a closure operator given by the composition. This is the partial
order version of the statement that every adjunction induces a monad. |
ClosureOperator.gi [PartialOrder α] (c : ClosureOperator α) :
GaloisInsertion c.toCloseds (↑) where
choice x hx := ⟨x, isClosed_iff_closure_le.2 hx⟩
gc _ y := y.2.closure_le_iff
le_l_u _ := c.le_closure _
choice_eq x hx := le_antisymm (c.le_closure x) hx | def | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | ClosureOperator.gi | The set of closed elements has a Galois insertion to the underlying type. |
@[simp]
closureOperator_gi_self [PartialOrder α] (c : ClosureOperator α) :
c.gi.gc.closureOperator = c := by
ext x
rfl | theorem | Order | [
"Mathlib.Data.Set.BooleanAlgebra",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.Hom.Basic"
] | Mathlib/Order/Closure.lean | closureOperator_gi_self | The Galois insertion associated to a closure operator can be used to reconstruct the closure
operator.
Note that the inverse in the opposite direction does not hold in general. |
IsCofinal.of_isEmpty [IsEmpty α] (s : Set α) : IsCofinal s :=
fun a ↦ isEmptyElim a | theorem | Order | [
"Mathlib.Order.GaloisConnection.Basic",
"Mathlib.Order.Interval.Set.Basic",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Cofinal.lean | IsCofinal.of_isEmpty | null |
isCofinal_empty_iff : IsCofinal (∅ : Set α) ↔ IsEmpty α := by
refine ⟨fun h ↦ ⟨fun a ↦ ?_⟩, fun h ↦ .of_isEmpty _⟩
simpa using h a | theorem | Order | [
"Mathlib.Order.GaloisConnection.Basic",
"Mathlib.Order.Interval.Set.Basic",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Cofinal.lean | isCofinal_empty_iff | null |
IsCofinal.singleton_top [OrderTop α] : IsCofinal {(⊤ : α)} :=
fun _ ↦ ⟨⊤, Set.mem_singleton _, le_top⟩ | theorem | Order | [
"Mathlib.Order.GaloisConnection.Basic",
"Mathlib.Order.Interval.Set.Basic",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Cofinal.lean | IsCofinal.singleton_top | null |
IsCofinal.mono {s t : Set α} (h : s ⊆ t) (hs : IsCofinal s) : IsCofinal t := by
intro a
obtain ⟨b, hb, hb'⟩ := hs a
exact ⟨b, h hb, hb'⟩ | theorem | Order | [
"Mathlib.Order.GaloisConnection.Basic",
"Mathlib.Order.Interval.Set.Basic",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Cofinal.lean | IsCofinal.mono | null |
IsCofinal.univ : IsCofinal (@Set.univ α) :=
fun a ↦ ⟨a, ⟨⟩, le_rfl⟩ | theorem | Order | [
"Mathlib.Order.GaloisConnection.Basic",
"Mathlib.Order.Interval.Set.Basic",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Cofinal.lean | IsCofinal.univ | null |
IsCofinal.trans {s : Set α} {t : Set s} (hs : IsCofinal s) (ht : IsCofinal t) :
IsCofinal (Subtype.val '' t) := by
intro a
obtain ⟨b, hb, hb'⟩ := hs a
obtain ⟨c, hc, hc'⟩ := ht ⟨b, hb⟩
exact ⟨c, Set.mem_image_of_mem _ hc, hb'.trans hc'⟩ | theorem | Order | [
"Mathlib.Order.GaloisConnection.Basic",
"Mathlib.Order.Interval.Set.Basic",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Cofinal.lean | IsCofinal.trans | A cofinal subset of a cofinal subset is cofinal. |
GaloisConnection.map_cofinal [Preorder β] {f : β → α} {g : α → β}
(h : GaloisConnection f g) {s : Set α} (hs : IsCofinal s) : IsCofinal (g '' s) := by
intro a
obtain ⟨b, hb, hb'⟩ := hs (f a)
exact ⟨g b, Set.mem_image_of_mem _ hb, h.le_iff_le.1 hb'⟩ | theorem | Order | [
"Mathlib.Order.GaloisConnection.Basic",
"Mathlib.Order.Interval.Set.Basic",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Cofinal.lean | GaloisConnection.map_cofinal | null |
OrderIso.map_cofinal [Preorder β] (e : α ≃o β) {s : Set α} (hs : IsCofinal s) :
IsCofinal (e '' s) :=
e.symm.to_galoisConnection.map_cofinal hs | theorem | Order | [
"Mathlib.Order.GaloisConnection.Basic",
"Mathlib.Order.Interval.Set.Basic",
"Mathlib.Order.WellFounded"
] | Mathlib/Order/Cofinal.lean | OrderIso.map_cofinal | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.