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 ⌀ |
|---|---|---|---|---|---|---|
instSup : Max (Booleanisation α) where
max
| lift a, lift b => lift (a ⊔ b)
| lift a, comp b => comp (b \ a)
| comp a, lift b => comp (a \ b)
| comp a, comp b => comp (a ⊓ b) | instance | Order | [
"Mathlib.Order.BooleanAlgebra.Basic",
"Mathlib.Order.Hom.Lattice"
] | Mathlib/Order/Booleanisation.lean | instSup | The supremum on `Booleanisation α` is as follows: For `a b : α`,
* `a ⊔ b` is `a ⊔ b`
* `a ⊔ bᶜ` is `(b \ a)ᶜ`
* `aᶜ ⊔ b` is `(a \ b)ᶜ`
* `aᶜ ⊔ bᶜ` is `(a ⊓ b)ᶜ` |
instInf : Min (Booleanisation α) where
min
| lift a, lift b => lift (a ⊓ b)
| lift a, comp b => lift (a \ b)
| comp a, lift b => lift (b \ a)
| comp a, comp b => comp (a ⊔ b) | instance | Order | [
"Mathlib.Order.BooleanAlgebra.Basic",
"Mathlib.Order.Hom.Lattice"
] | Mathlib/Order/Booleanisation.lean | instInf | The infimum on `Booleanisation α` is as follows: For `a b : α`,
* `a ⊓ b` is `a ⊓ b`
* `a ⊓ bᶜ` is `a \ b`
* `aᶜ ⊓ b` is `b \ a`
* `aᶜ ⊓ bᶜ` is `(a ⊔ b)ᶜ` |
instBot : Bot (Booleanisation α) where
bot := lift ⊥ | instance | Order | [
"Mathlib.Order.BooleanAlgebra.Basic",
"Mathlib.Order.Hom.Lattice"
] | Mathlib/Order/Booleanisation.lean | instBot | The bottom element of `Booleanisation α` is the bottom element of `α`. |
instTop : Top (Booleanisation α) where
top := comp ⊥ | instance | Order | [
"Mathlib.Order.BooleanAlgebra.Basic",
"Mathlib.Order.Hom.Lattice"
] | Mathlib/Order/Booleanisation.lean | instTop | The top element of `Booleanisation α` is the complement of the bottom element of `α`. |
instSDiff : SDiff (Booleanisation α) where
sdiff
| lift a, lift b => lift (a \ b)
| lift a, comp b => lift (a ⊓ b)
| comp a, lift b => comp (a ⊔ b)
| comp a, comp b => lift (b \ a)
@[simp] lemma lift_le_lift : lift a ≤ lift b ↔ a ≤ b := ⟨by rintro ⟨_⟩; assumption, LE.lift⟩
@[simp] lemma comp_le_comp :... | instance | Order | [
"Mathlib.Order.BooleanAlgebra.Basic",
"Mathlib.Order.Hom.Lattice"
] | Mathlib/Order/Booleanisation.lean | instSDiff | The difference operator on `Booleanisation α` is as follows: For `a b : α`,
* `a \ b` is `a \ b`
* `a \ bᶜ` is `a ⊓ b`
* `aᶜ \ b` is `(a ⊔ b)ᶜ`
* `aᶜ \ bᶜ` is `b \ a` |
instPreorder : Preorder (Booleanisation α) where
lt := (· < ·)
lt_iff_le_not_ge
| lift a, lift b => by simp [lt_iff_le_not_ge]
| lift a, comp b => by simp
| comp a, lift b => by simp
| comp a, comp b => by simp [lt_iff_le_not_ge]
le_refl
| lift _ => LE.lift le_rfl
| comp _ => LE.comp le_rf... | instance | Order | [
"Mathlib.Order.BooleanAlgebra.Basic",
"Mathlib.Order.Hom.Lattice"
] | Mathlib/Order/Booleanisation.lean | instPreorder | null |
instPartialOrder : PartialOrder (Booleanisation α) where
le_antisymm
| lift a, lift b, LE.lift hab, LE.lift hba => by rw [hab.antisymm hba]
| comp a, comp b, LE.comp hab, LE.comp hba => by rw [hab.antisymm hba]
set_option linter.unusedVariables false in | instance | Order | [
"Mathlib.Order.BooleanAlgebra.Basic",
"Mathlib.Order.Hom.Lattice"
] | Mathlib/Order/Booleanisation.lean | instPartialOrder | null |
instSemilatticeSup : SemilatticeSup (Booleanisation α) where
sup x y := max x y
le_sup_left
| lift a, lift b => LE.lift le_sup_left
| lift a, comp b => LE.sep disjoint_sdiff_self_right
| comp a, lift b => LE.comp sdiff_le
| comp a, comp b => LE.comp inf_le_left
le_sup_right
| lift a, lift b =>... | instance | Order | [
"Mathlib.Order.BooleanAlgebra.Basic",
"Mathlib.Order.Hom.Lattice"
] | Mathlib/Order/Booleanisation.lean | instSemilatticeSup | null |
instSemilatticeInf : SemilatticeInf (Booleanisation α) where
inf x y := min x y
inf_le_left
| lift a, lift b => LE.lift inf_le_left
| lift a, comp b => LE.lift sdiff_le
| comp a, lift b => LE.sep disjoint_sdiff_self_left
| comp a, comp b => LE.comp le_sup_left
inf_le_right
| lift a, lift b => ... | instance | Order | [
"Mathlib.Order.BooleanAlgebra.Basic",
"Mathlib.Order.Hom.Lattice"
] | Mathlib/Order/Booleanisation.lean | instSemilatticeInf | null |
instDistribLattice : DistribLattice (Booleanisation α) where
inf x y := x ⊓ y
inf_le_left _ _ := inf_le_left
inf_le_right _ _ := inf_le_right
le_inf _ _ _ := le_inf
le_sup_inf
| lift _, lift _, lift _ => LE.lift le_sup_inf
| lift a, lift b, comp c => LE.lift <| by simp [sup_comm, sup_assoc]
| lift... | instance | Order | [
"Mathlib.Order.BooleanAlgebra.Basic",
"Mathlib.Order.Hom.Lattice"
] | Mathlib/Order/Booleanisation.lean | instDistribLattice | null |
instBoundedOrder : BoundedOrder (Booleanisation α) where
le_top
| lift a => LE.sep disjoint_bot_right
| comp a => LE.comp bot_le
bot_le
| lift a => LE.lift bot_le
| comp a => LE.sep disjoint_bot_left | instance | Order | [
"Mathlib.Order.BooleanAlgebra.Basic",
"Mathlib.Order.Hom.Lattice"
] | Mathlib/Order/Booleanisation.lean | instBoundedOrder | null |
instBooleanAlgebra : BooleanAlgebra (Booleanisation α) where
le_top _ := le_top
bot_le _ := bot_le
inf_compl_le_bot
| lift a => by simp
| comp a => by simp
top_le_sup_compl
| lift a => by simp
| comp a => by simp
sdiff_eq
| lift a, lift b => by simp
| lift a, comp b => by simp
| co... | instance | Order | [
"Mathlib.Order.BooleanAlgebra.Basic",
"Mathlib.Order.Hom.Lattice"
] | Mathlib/Order/Booleanisation.lean | instBooleanAlgebra | null |
liftLatticeHom : LatticeHom α (Booleanisation α) where
toFun := lift
map_sup' _ _ := rfl
map_inf' _ _ := rfl | def | Order | [
"Mathlib.Order.BooleanAlgebra.Basic",
"Mathlib.Order.Hom.Lattice"
] | Mathlib/Order/Booleanisation.lean | liftLatticeHom | The embedding from a generalised Boolean algebra to its generated Boolean algebra. |
liftLatticeHom_injective : Injective (liftLatticeHom (α := α)) := Sum.inl_injective | lemma | Order | [
"Mathlib.Order.BooleanAlgebra.Basic",
"Mathlib.Order.Hom.Lattice"
] | Mathlib/Order/Booleanisation.lean | liftLatticeHom_injective | null |
BooleanSubalgebra [BooleanAlgebra α] extends Sublattice α where
compl_mem' {a} : a ∈ carrier → aᶜ ∈ carrier
bot_mem' : ⊥ ∈ carrier | structure | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | BooleanSubalgebra | A Boolean subalgebra of a Boolean algebra is a set containing the bottom and top elements, and
closed under suprema, infima and complements. |
instSetLike : SetLike (BooleanSubalgebra α) α where
coe L := L.carrier
coe_injective' L M h := by obtain ⟨⟨_, _⟩, _⟩ := L; congr | instance | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | instSetLike | null |
coe_inj : (L : Set α) = M ↔ L = M := SetLike.coe_set_eq
@[simp] lemma supClosed (L : BooleanSubalgebra α) : SupClosed (L : Set α) := L.supClosed'
@[simp] lemma infClosed (L : BooleanSubalgebra α) : InfClosed (L : Set α) := L.infClosed' | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | coe_inj | null |
compl_mem (ha : a ∈ L) : aᶜ ∈ L := L.compl_mem' ha
@[simp] lemma compl_mem_iff : aᶜ ∈ L ↔ a ∈ L := ⟨fun ha ↦ by simpa using compl_mem ha, compl_mem⟩
@[simp] lemma bot_mem : ⊥ ∈ L := L.bot_mem'
@[simp] lemma top_mem : ⊤ ∈ L := by simpa using compl_mem L.bot_mem | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | compl_mem | null |
sup_mem (ha : a ∈ L) (hb : b ∈ L) : a ⊔ b ∈ L := L.supClosed ha hb | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | sup_mem | null |
inf_mem (ha : a ∈ L) (hb : b ∈ L) : a ⊓ b ∈ L := L.infClosed ha hb | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | inf_mem | null |
sdiff_mem (ha : a ∈ L) (hb : b ∈ L) : a \ b ∈ L := by
simpa [sdiff_eq] using L.infClosed ha (compl_mem hb) | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | sdiff_mem | null |
himp_mem (ha : a ∈ L) (hb : b ∈ L) : a ⇨ b ∈ L := by
simpa [himp_eq] using L.supClosed hb (compl_mem ha) | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | himp_mem | null |
mem_carrier : a ∈ L.carrier ↔ a ∈ L := .rfl
@[simp] lemma mem_toSublattice : a ∈ L.toSublattice ↔ a ∈ L := .rfl
@[simp] lemma mem_mk {L : Sublattice α} (h_compl h_bot) : a ∈ mk L h_compl h_bot ↔ a ∈ L := .rfl
@[simp] lemma coe_mk (L : Sublattice α) (h_compl h_bot) : (mk L h_compl h_bot : Set α) = L := rfl
@[simp] lemma... | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | mem_carrier | null |
protected copy (L : BooleanSubalgebra α) (s : Set α) (hs : s = L) : BooleanSubalgebra α where
toSublattice := L.toSublattice.copy s <| by subst hs; rfl
compl_mem' := by subst hs; exact L.compl_mem'
bot_mem' := by subst hs; exact L.bot_mem'
@[simp, norm_cast] | def | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | copy | Copy of a Boolean subalgebra with a new `carrier` equal to the old one. Useful to fix
definitional equalities. |
coe_copy (L : BooleanSubalgebra α) (s : Set α) (hs) : L.copy s hs = s := rfl | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | coe_copy | null |
copy_eq (L : BooleanSubalgebra α) (s : Set α) (hs) : L.copy s hs = L :=
SetLike.coe_injective hs | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | copy_eq | null |
ext : (∀ a, a ∈ L ↔ a ∈ M) → L = M := SetLike.ext | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | ext | Two Boolean subalgebras are equal if they have the same elements. |
instBotCoe : Bot L where bot := ⟨⊥, bot_mem⟩ | instance | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | instBotCoe | A Boolean subalgebra of a lattice inherits a bottom element. |
instTopCoe : Top L where top := ⟨⊤, top_mem⟩ | instance | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | instTopCoe | A Boolean subalgebra of a lattice inherits a top element. |
instSupCoe : Max L where max a b := ⟨a ⊔ b, L.supClosed a.2 b.2⟩ | instance | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | instSupCoe | A Boolean subalgebra of a lattice inherits a supremum. |
instInfCoe : Min L where min a b := ⟨a ⊓ b, L.infClosed a.2 b.2⟩ | instance | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | instInfCoe | A Boolean subalgebra of a lattice inherits an infimum. |
instHasComplCoe : HasCompl L where compl a := ⟨aᶜ, compl_mem a.2⟩ | instance | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | instHasComplCoe | A Boolean subalgebra of a lattice inherits a complement. |
instSDiffCoe : SDiff L where sdiff a b := ⟨a \ b, sdiff_mem a.2 b.2⟩ | instance | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | instSDiffCoe | A Boolean subalgebra of a lattice inherits a difference. |
instHImpCoe : HImp L where himp a b := ⟨a ⇨ b, himp_mem a.2 b.2⟩
@[simp, norm_cast] lemma val_bot : (⊥ : L) = (⊥ : α) := rfl
@[simp, norm_cast] lemma val_top : (⊤ : L) = (⊤ : α) := rfl
@[simp, norm_cast] lemma val_sup (a b : L) : a ⊔ b = (a : α) ⊔ b := rfl
@[simp, norm_cast] lemma val_inf (a b : L) : a ⊓ b = (a : α) ⊓ ... | instance | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | instHImpCoe | A Boolean subalgebra of a lattice inherits a Heyting implication. |
instBooleanAlgebraCoe (L : BooleanSubalgebra α) : BooleanAlgebra L :=
Subtype.coe_injective.booleanAlgebra _ val_sup val_inf val_top val_bot val_compl val_sdiff
val_himp | instance | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | instBooleanAlgebraCoe | A Boolean subalgebra of a lattice inherits a Boolean algebra structure. |
subtype (L : BooleanSubalgebra α) : BoundedLatticeHom L α where
toFun := ((↑) : L → α)
map_bot' := L.val_bot
map_top' := L.val_top
map_sup' := val_sup
map_inf' := val_inf
@[simp, norm_cast] lemma coe_subtype (L : BooleanSubalgebra α) : L.subtype = ((↑) : L → α) := rfl | def | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | subtype | The natural lattice hom from a Boolean subalgebra to the original lattice. |
subtype_apply (L : BooleanSubalgebra α) (a : L) : L.subtype a = a := rfl | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | subtype_apply | null |
subtype_injective (L : BooleanSubalgebra α) : Injective <| subtype L := Subtype.coe_injective | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | subtype_injective | null |
inclusion (h : L ≤ M) : BoundedLatticeHom L M where
toFun := Set.inclusion h
map_bot' := rfl
map_top' := rfl
map_sup' _ _ := rfl
map_inf' _ _ := rfl
@[simp] lemma coe_inclusion (h : L ≤ M) : inclusion h = Set.inclusion h := rfl | def | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | inclusion | The inclusion homomorphism from a Boolean subalgebra `L` to a bigger Boolean subalgebra `M`. |
inclusion_apply (h : L ≤ M) (a : L) : inclusion h a = Set.inclusion h a := rfl | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | inclusion_apply | null |
inclusion_injective (h : L ≤ M) : Injective <| inclusion h := Set.inclusion_injective h
@[simp] lemma inclusion_rfl (L : BooleanSubalgebra α) : inclusion le_rfl = .id L := rfl
@[simp] lemma subtype_comp_inclusion (h : L ≤ M) : M.subtype.comp (inclusion h) = L.subtype := rfl | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | inclusion_injective | null |
instTop : Top (BooleanSubalgebra α) where
top.carrier := univ
top.bot_mem' := mem_univ _
top.compl_mem' _ := mem_univ _
top.supClosed' := supClosed_univ
top.infClosed' := infClosed_univ | instance | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | instTop | The maximum Boolean subalgebra of a lattice. |
instBot : Bot (BooleanSubalgebra α) where
bot.carrier := {⊥, ⊤}
bot.bot_mem' := by simp
bot.compl_mem' := by simp
bot.supClosed' _ := by simp
bot.infClosed' _ := by simp | instance | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | instBot | The trivial Boolean subalgebra of a lattice. |
instInf : Min (BooleanSubalgebra α) where
min L M := { carrier := L ∩ M
bot_mem' := ⟨bot_mem, bot_mem⟩
compl_mem' := fun ha ↦ ⟨compl_mem ha.1, compl_mem ha.2⟩
supClosed' := L.supClosed.inter M.supClosed
infClosed' := L.infClosed.inter M.infClosed } | instance | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | instInf | The inf of two Boolean subalgebras is their intersection. |
instInfSet : InfSet (BooleanSubalgebra α) where
sInf S := { carrier := ⋂ L ∈ S, L
bot_mem' := mem_iInter₂.2 fun _ _ ↦ bot_mem
compl_mem' := fun ha ↦ mem_iInter₂.2 fun L hL ↦ compl_mem <| mem_iInter₂.1 ha L hL
supClosed' := supClosed_sInter <| forall_mem_range.2 fun L ↦ supClo... | instance | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | instInfSet | The inf of Boolean subalgebras is their intersection. |
instInhabited : Inhabited (BooleanSubalgebra α) := ⟨⊥⟩ | instance | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | instInhabited | null |
topEquiv : (⊤ : BooleanSubalgebra α) ≃o α where
toEquiv := Equiv.Set.univ _
map_rel_iff' := .rfl
@[simp, norm_cast] lemma coe_top : (⊤ : BooleanSubalgebra α) = (univ : Set α) := rfl
@[simp, norm_cast] lemma coe_bot : (⊥ : BooleanSubalgebra α) = ({⊥, ⊤} : Set α) := rfl
@[simp, norm_cast] lemma coe_inf (L M : Boolean... | def | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | topEquiv | The top Boolean subalgebra is isomorphic to the original Boolean algebra.
This is the Boolean subalgebra version of `Equiv.Set.univ α`. |
coe_sInf (S : Set (BooleanSubalgebra α)) : sInf S = ⋂ L ∈ S, (L : Set α) := rfl
@[simp, norm_cast] | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | coe_sInf | null |
coe_iInf (f : ι → BooleanSubalgebra α) : ⨅ i, f i = ⋂ i, (f i : Set α) := by simp [iInf]
@[simp, norm_cast] lemma coe_eq_univ : L = (univ : Set α) ↔ L = ⊤ := by rw [← coe_top, coe_inj]
@[simp] lemma mem_bot : a ∈ (⊥ : BooleanSubalgebra α) ↔ a = ⊥ ∨ a = ⊤ := .rfl
@[simp] lemma mem_top : a ∈ (⊤ : BooleanSubalgebra α) := ... | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | coe_iInf | null |
instCompleteLattice : CompleteLattice (BooleanSubalgebra α) where
bot := ⊥
bot_le _S _a := by aesop
top := ⊤
le_top _S a _ha := mem_top
inf := (· ⊓ ·)
le_inf _L _M _N hM hN _a ha := ⟨hM ha, hN ha⟩
inf_le_left _L _M _a := And.left
inf_le_right _L _M _a := And.right
__ := completeLatticeOfInf (BooleanSu... | instance | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | instCompleteLattice | BooleanSubalgebras of a lattice form a complete lattice. |
comap (f : BoundedLatticeHom α β) (L : BooleanSubalgebra β) : BooleanSubalgebra α where
carrier := f ⁻¹' L
bot_mem' := by simp
compl_mem' := by simp [map_compl']
supClosed' := L.supClosed.preimage _
infClosed' := L.infClosed.preimage _
@[simp, norm_cast] | def | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | comap | The preimage of a Boolean subalgebra along a bounded lattice homomorphism. |
coe_comap (L : BooleanSubalgebra β) (f : BoundedLatticeHom α β) : L.comap f = f ⁻¹' L := rfl
@[simp] lemma mem_comap {L : BooleanSubalgebra β} : a ∈ L.comap f ↔ f a ∈ L := .rfl | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | coe_comap | null |
comap_mono : Monotone (comap f) := fun _ _ ↦ preimage_mono
@[simp] lemma comap_id (L : BooleanSubalgebra α) : L.comap (BoundedLatticeHom.id _) = L := rfl
@[simp] lemma comap_comap (L : BooleanSubalgebra γ) (g : BoundedLatticeHom β γ)
(f : BoundedLatticeHom α β) : (L.comap g).comap f = L.comap (g.comp f) := rfl | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | comap_mono | null |
map (f : BoundedLatticeHom α β) (L : BooleanSubalgebra α) : BooleanSubalgebra β where
carrier := f '' L
bot_mem' := ⟨⊥, by simp⟩
compl_mem' := by rintro _ ⟨a, ha, rfl⟩; exact ⟨aᶜ, by simpa [map_compl']⟩
supClosed' := L.supClosed.image f
infClosed' := L.infClosed.image f
@[simp] lemma coe_map (f : BoundedLatti... | def | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | map | The image of a Boolean subalgebra along a monoid homomorphism is a Boolean subalgebra. |
mem_map_of_mem (f : BoundedLatticeHom α β) {a : α} : a ∈ L → f a ∈ L.map f :=
mem_image_of_mem f | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | mem_map_of_mem | null |
apply_coe_mem_map (f : BoundedLatticeHom α β) (a : L) : f a ∈ L.map f :=
mem_map_of_mem f a.prop | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | apply_coe_mem_map | null |
map_mono : Monotone (map f) := fun _ _ ↦ image_mono
@[simp] lemma map_id : L.map (.id α) = L := SetLike.coe_injective <| image_id _
@[simp] lemma map_map (g : BoundedLatticeHom β γ) (f : BoundedLatticeHom α β) :
(L.map f).map g = L.map (g.comp f) := SetLike.coe_injective <| image_image _ _ _ | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.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.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.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.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | apply_mem_map_iff | null |
map_equiv_eq_comap_symm (f : α ≃o β) (L : BooleanSubalgebra α) :
L.map f = L.comap (f.symm : BoundedLatticeHom β α) :=
SetLike.coe_injective <| f.toEquiv.image_eq_preimage L | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | map_equiv_eq_comap_symm | null |
comap_equiv_eq_map_symm (f : β ≃o α) (L : BooleanSubalgebra α) :
L.comap f = L.map (f.symm : BoundedLatticeHom α β) := (map_equiv_eq_comap_symm f.symm L).symm | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | comap_equiv_eq_map_symm | null |
map_symm_eq_iff_eq_map {M : BooleanSubalgebra β} {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.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | map_symm_eq_iff_eq_map | null |
map_le_iff_le_comap {f : BoundedLatticeHom α β} {M : BooleanSubalgebra β} :
L.map f ≤ M ↔ L ≤ M.comap f := image_subset_iff | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | map_le_iff_le_comap | null |
gc_map_comap (f : BoundedLatticeHom α β) : GaloisConnection (map f) (comap f) :=
fun _ _ ↦ map_le_iff_le_comap
@[simp] lemma map_bot (f : BoundedLatticeHom α β) : (⊥ : BooleanSubalgebra α).map f = ⊥ :=
(gc_map_comap f).l_bot | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | gc_map_comap | null |
map_sup (f : BoundedLatticeHom α β) (L M : BooleanSubalgebra α) :
(L ⊔ M).map f = L.map f ⊔ M.map f := (gc_map_comap f).l_sup | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | map_sup | null |
map_iSup (f : BoundedLatticeHom α β) (L : ι → BooleanSubalgebra α) :
(⨆ i, L i).map f = ⨆ i, (L i).map f := (gc_map_comap f).l_iSup
@[simp] lemma comap_top (f : BoundedLatticeHom α β) : (⊤ : BooleanSubalgebra β).comap f = ⊤ :=
(gc_map_comap f).u_top | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | map_iSup | null |
comap_inf (L M : BooleanSubalgebra β) (f : BoundedLatticeHom α β) :
(L ⊓ M).comap f = L.comap f ⊓ M.comap f := (gc_map_comap f).u_inf | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | comap_inf | null |
comap_iInf (f : BoundedLatticeHom α β) (L : ι → BooleanSubalgebra β) :
(⨅ i, L i).comap f = ⨅ i, (L i).comap f := (gc_map_comap f).u_iInf | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | comap_iInf | null |
map_inf_le (L M : BooleanSubalgebra α) (f : BoundedLatticeHom α β) :
map f (L ⊓ M) ≤ map f L ⊓ map f M := map_mono.map_inf_le _ _ | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | map_inf_le | null |
le_comap_sup (L M : BooleanSubalgebra β) (f : BoundedLatticeHom α β) :
comap f L ⊔ comap f M ≤ comap f (L ⊔ M) := comap_mono.le_map_sup _ _ | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | le_comap_sup | null |
le_comap_iSup (f : BoundedLatticeHom α β) (L : ι → BooleanSubalgebra β) :
⨆ i, (L i).comap f ≤ (⨆ i, L i).comap f := comap_mono.le_map_iSup | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | le_comap_iSup | null |
map_inf (L M : BooleanSubalgebra α) (f : BoundedLatticeHom α β) (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.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | map_inf | null |
map_top (f : BoundedLatticeHom α β) (h : Surjective f) : BooleanSubalgebra.map f ⊤ = ⊤ :=
SetLike.coe_injective <| by simp [h.range_eq] | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | map_top | null |
closure (s : Set α) : BooleanSubalgebra α := sInf {L | s ⊆ L}
variable {s : Set α} | def | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | closure | The minimum Boolean subalgebra containing a given set. |
mem_closure {x : α} : x ∈ closure s ↔ ∀ ⦃L : BooleanSubalgebra α⦄, s ⊆ L → x ∈ L := mem_sInf
@[simp, aesop safe 20 (rule_sets := [SetLike])] | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | mem_closure | null |
subset_closure : s ⊆ closure s := fun _ hx ↦ mem_closure.2 fun _ hK ↦ hK hx
@[aesop 80% (rule_sets := [SetLike])] | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | subset_closure | null |
mem_closure_of_mem {s : Set α} {x : α} (hx : x ∈ s) : x ∈ closure s := subset_closure hx
@[simp] lemma closure_le : closure s ≤ L ↔ s ⊆ L := ⟨subset_closure.trans, fun h ↦ sInf_le h⟩ | theorem | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | mem_closure_of_mem | null |
closure_mono (hst : s ⊆ t) : closure s ≤ closure t := sInf_le_sInf fun _L ↦ hst.trans | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | closure_mono | null |
latticeClosure_subset_closure : latticeClosure s ⊆ closure s :=
latticeClosure_min subset_closure (closure s).isSublattice
@[simp] lemma closure_latticeClosure (s : Set α) : closure (latticeClosure s) = closure s :=
le_antisymm (closure_le.2 latticeClosure_subset_closure) (closure_mono subset_latticeClosure) | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | latticeClosure_subset_closure | null |
@[elab_as_elim]
closure_bot_sup_induction {p : ∀ g ∈ closure s, Prop} (mem : ∀ x hx, p x (subset_closure hx))
(bot : p ⊥ bot_mem)
(sup : ∀ x hx y hy, p x hx → p y hy → p (x ⊔ y) (supClosed _ hx hy))
(compl : ∀ x hx, p x hx → p xᶜ (compl_mem hx)) {x} (hx : x ∈ closure s) : p x hx :=
have inf ⦃x hx y hy⦄ (h... | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | closure_bot_sup_induction | An induction principle for closure membership. If `p` holds for `⊥` and all elements of `s`, and
is preserved under suprema and complement, then `p` holds for all elements of the closure of `s`. |
mem_closure_iff_sup_sdiff {a : α} :
a ∈ closure s ↔ ∃ t : Finset (s × s), a = t.sup fun x ↦ x.1.1 \ x.2.1 := by
classical
refine ⟨closure_bot_sup_induction
(fun x h ↦ ⟨{(⟨x, h⟩, ⟨⊥, bot_mem⟩)}, by simp⟩) ⟨∅, by simp⟩ ?_ ?_, ?_⟩
· rintro ⟨t, rfl⟩
exact t.sup_mem _ (subset_closure bot_mem) (fun _ h _ ↦ ... | theorem | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | mem_closure_iff_sup_sdiff | null |
iSup_mem [Finite ι] (hf : ∀ i, f i ∈ L) : ⨆ i, f i ∈ L := L.supClosed.iSup_mem bot_mem hf | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | iSup_mem | null |
iInf_mem [Finite ι] (hf : ∀ i, f i ∈ L) : ⨅ i, f i ∈ L := L.infClosed.iInf_mem top_mem hf | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | iInf_mem | null |
sSup_mem (hs : s.Finite) (hsL : s ⊆ L) : sSup s ∈ L := L.supClosed.sSup_mem hs bot_mem hsL | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | sSup_mem | null |
sInf_mem (hs : s.Finite) (hsL : s ⊆ L) : sInf s ∈ L := L.infClosed.sInf_mem hs top_mem hsL | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | sInf_mem | null |
biSup_mem {ι : Type*} {t : Set ι} {f : ι → α} (ht : t.Finite) (hf : ∀ i ∈ t, f i ∈ L) :
⨆ i ∈ t, f i ∈ L := L.supClosed.biSup_mem ht bot_mem hf | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | biSup_mem | null |
biInf_mem {ι : Type*} {t : Set ι} {f : ι → α} (ht : t.Finite) (hf : ∀ i ∈ t, f i ∈ L) :
⨅ i ∈ t, f i ∈ L := L.infClosed.biInf_mem ht top_mem hf | lemma | Order | [
"Mathlib.Order.Sublattice"
] | Mathlib/Order/BooleanSubalgebra.lean | biInf_mem | null |
Bounded.mono (hst : s ⊆ t) (hs : Bounded r t) : Bounded r s :=
hs.imp fun _ ha b hb => ha b (hst hb) | theorem | Order | [
"Mathlib.Order.RelClasses",
"Mathlib.Order.Interval.Set.Basic"
] | Mathlib/Order/Bounded.lean | Bounded.mono | null |
Unbounded.mono (hst : s ⊆ t) (hs : Unbounded r s) : Unbounded r t := fun a =>
let ⟨b, hb, hb'⟩ := hs a
⟨b, hst hb, hb'⟩
/-! ### Alternate characterizations of unboundedness on orders -/ | theorem | Order | [
"Mathlib.Order.RelClasses",
"Mathlib.Order.Interval.Set.Basic"
] | Mathlib/Order/Bounded.lean | Unbounded.mono | null |
unbounded_le_of_forall_exists_lt [Preorder α] (h : ∀ a, ∃ b ∈ s, a < b) :
Unbounded (· ≤ ·) s := fun a =>
let ⟨b, hb, hb'⟩ := h a
⟨b, hb, fun hba => hba.not_gt hb'⟩ | theorem | Order | [
"Mathlib.Order.RelClasses",
"Mathlib.Order.Interval.Set.Basic"
] | Mathlib/Order/Bounded.lean | unbounded_le_of_forall_exists_lt | null |
unbounded_le_iff [LinearOrder α] : Unbounded (· ≤ ·) s ↔ ∀ a, ∃ b ∈ s, a < b := by
simp only [Unbounded, not_le] | theorem | Order | [
"Mathlib.Order.RelClasses",
"Mathlib.Order.Interval.Set.Basic"
] | Mathlib/Order/Bounded.lean | unbounded_le_iff | null |
unbounded_lt_of_forall_exists_le [Preorder α] (h : ∀ a, ∃ b ∈ s, a ≤ b) :
Unbounded (· < ·) s := fun a =>
let ⟨b, hb, hb'⟩ := h a
⟨b, hb, fun hba => hba.not_ge hb'⟩ | theorem | Order | [
"Mathlib.Order.RelClasses",
"Mathlib.Order.Interval.Set.Basic"
] | Mathlib/Order/Bounded.lean | unbounded_lt_of_forall_exists_le | null |
unbounded_lt_iff [LinearOrder α] : Unbounded (· < ·) s ↔ ∀ a, ∃ b ∈ s, a ≤ b := by
simp only [Unbounded, not_lt] | theorem | Order | [
"Mathlib.Order.RelClasses",
"Mathlib.Order.Interval.Set.Basic"
] | Mathlib/Order/Bounded.lean | unbounded_lt_iff | null |
unbounded_ge_of_forall_exists_gt [Preorder α] (h : ∀ a, ∃ b ∈ s, b < a) :
Unbounded (· ≥ ·) s :=
@unbounded_le_of_forall_exists_lt αᵒᵈ _ _ h | theorem | Order | [
"Mathlib.Order.RelClasses",
"Mathlib.Order.Interval.Set.Basic"
] | Mathlib/Order/Bounded.lean | unbounded_ge_of_forall_exists_gt | null |
unbounded_ge_iff [LinearOrder α] : Unbounded (· ≥ ·) s ↔ ∀ a, ∃ b ∈ s, b < a :=
⟨fun h a =>
let ⟨b, hb, hba⟩ := h a
⟨b, hb, lt_of_not_ge hba⟩,
unbounded_ge_of_forall_exists_gt⟩ | theorem | Order | [
"Mathlib.Order.RelClasses",
"Mathlib.Order.Interval.Set.Basic"
] | Mathlib/Order/Bounded.lean | unbounded_ge_iff | null |
unbounded_gt_of_forall_exists_ge [Preorder α] (h : ∀ a, ∃ b ∈ s, b ≤ a) :
Unbounded (· > ·) s := fun a =>
let ⟨b, hb, hb'⟩ := h a
⟨b, hb, fun hba => not_le_of_gt hba hb'⟩ | theorem | Order | [
"Mathlib.Order.RelClasses",
"Mathlib.Order.Interval.Set.Basic"
] | Mathlib/Order/Bounded.lean | unbounded_gt_of_forall_exists_ge | null |
unbounded_gt_iff [LinearOrder α] : Unbounded (· > ·) s ↔ ∀ a, ∃ b ∈ s, b ≤ a :=
⟨fun h a =>
let ⟨b, hb, hba⟩ := h a
⟨b, hb, le_of_not_gt hba⟩,
unbounded_gt_of_forall_exists_ge⟩
/-! ### Relation between boundedness by strict and nonstrict orders. -/
/-! #### Less and less or equal -/ | theorem | Order | [
"Mathlib.Order.RelClasses",
"Mathlib.Order.Interval.Set.Basic"
] | Mathlib/Order/Bounded.lean | unbounded_gt_iff | null |
Bounded.rel_mono {r' : α → α → Prop} (h : Bounded r s) (hrr' : r ≤ r') : Bounded r' s :=
let ⟨a, ha⟩ := h
⟨a, fun b hb => hrr' b a (ha b hb)⟩ | theorem | Order | [
"Mathlib.Order.RelClasses",
"Mathlib.Order.Interval.Set.Basic"
] | Mathlib/Order/Bounded.lean | Bounded.rel_mono | null |
bounded_le_of_bounded_lt [Preorder α] (h : Bounded (· < ·) s) : Bounded (· ≤ ·) s :=
h.rel_mono fun _ _ => le_of_lt | theorem | Order | [
"Mathlib.Order.RelClasses",
"Mathlib.Order.Interval.Set.Basic"
] | Mathlib/Order/Bounded.lean | bounded_le_of_bounded_lt | null |
Unbounded.rel_mono {r' : α → α → Prop} (hr : r' ≤ r) (h : Unbounded r s) : Unbounded r' s :=
fun a =>
let ⟨b, hb, hba⟩ := h a
⟨b, hb, fun hba' => hba (hr b a hba')⟩ | theorem | Order | [
"Mathlib.Order.RelClasses",
"Mathlib.Order.Interval.Set.Basic"
] | Mathlib/Order/Bounded.lean | Unbounded.rel_mono | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.