File: Mathlib/Order/Sublattice.lean

full_name: Sublattice.infClosed'
code: /-- A sublattice of a lattice is a set containing the suprema and infima of any of its elements. -/
structure 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
goal: InfClosed self.carrier

full_name: Sublattice.supClosed'
code: /-- A sublattice of a lattice is a set containing the suprema and infima of any of its elements. -/
structure 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
goal: SupClosed self.carrier

full_name: Sublattice
code: /-- A sublattice of a lattice is a set containing the suprema and infima of any of its elements. -/
structure 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
goal: Type u_2

full_name: Sublattice.carrier
code: /-- A sublattice of a lattice is a set containing the suprema and infima of any of its elements. -/
structure 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
goal: Set α

full_name: Sublattice.instSetLike
code: instance instSetLike : SetLike (Sublattice α) α 
goal: SetLike (Sublattice α) α

full_name: Sublattice.ofIsSublattice
code: /-- Turn a set closed under supremum and infimum into a sublattice. -/
abbrev ofIsSublattice (s : Set α) (hs : IsSublattice s) : Sublattice α 
goal: Sublattice α

full_name: Sublattice.coe_inj
code: lemma coe_inj : (L : Set α) = M ↔ L = M 
goal: ↑L = ↑M ↔ L = M

full_name: Sublattice.supClosed
code: @[simp] lemma supClosed (L : Sublattice α) : SupClosed (L : Set α) 
goal: SupClosed ↑L

full_name: Sublattice.infClosed
code: @[simp] lemma infClosed (L : Sublattice α) : InfClosed (L : Set α) 
goal: InfClosed ↑L

full_name: Sublattice.isSublattice
code: @[simp] lemma isSublattice (L : Sublattice α) : IsSublattice (L : Set α) 
goal: IsSublattice ↑L

full_name: Sublattice.mem_carrier
code: @[simp] lemma mem_carrier : a ∈ L.carrier ↔ a ∈ L 
goal: a ∈ L.carrier ↔ a ∈ L

full_name: Sublattice.mem_mk
code: @[simp] lemma mem_mk (h_sup h_inf) : a ∈ mk s h_sup h_inf ↔ a ∈ s 
goal: a ∈ { carrier := s, supClosed' := h_sup, infClosed' := h_inf } ↔ a ∈ s

full_name: Sublattice.coe_mk
code: @[simp, norm_cast] lemma coe_mk (h_sup h_inf) : mk s h_sup h_inf = s 
goal: ↑{ carrier := s, supClosed' := h_sup, infClosed' := h_inf } = s

full_name: Sublattice.mk_le_mk
code: @[simp] lemma mk_le_mk (hs_sup hs_inf ht_sup ht_inf) :
    mk s hs_sup hs_inf ≤ mk t ht_sup ht_inf ↔ s ⊆ t 
goal: { carrier := s, supClosed' := hs_sup, infClosed' := hs_inf } ≤
    { carrier := t, supClosed' := ht_sup, infClosed' := ht_inf } ↔
  s ⊆ t

full_name: Sublattice.mk_lt_mk
code: @[simp] lemma mk_lt_mk (hs_sup hs_inf ht_sup ht_inf) :
    mk s hs_sup hs_inf < mk t ht_sup ht_inf ↔ s ⊂ t 
goal: { carrier := s, supClosed' := hs_sup, infClosed' := hs_inf } <
    { carrier := t, supClosed' := ht_sup, infClosed' := ht_inf } ↔
  s ⊂ t

full_name: Sublattice.copy
code: /-- Copy of a sublattice with a new `carrier` equal to the old one. Useful to fix definitional
equalities. -/
protected def copy (L : Sublattice α) (s : Set α) (hs : s = L) : Sublattice α 
goal: Sublattice α

full_name: Sublattice.coe_copy
code: @[simp, norm_cast] lemma coe_copy (L : Sublattice α) (s : Set α) (hs) : L.copy s hs = s 
goal: ↑(L.copy s hs) = s

full_name: Sublattice.copy_eq
code: lemma copy_eq (L : Sublattice α) (s : Set α) (hs) : L.copy s hs = L 
goal: L.copy s hs = L

full_name: Sublattice.ext
code: /-- Two sublattices are equal if they have the same elements. -/
lemma ext : (∀ a, a ∈ L ↔ a ∈ M) → L = M 
goal: (∀ (a : α), a ∈ L ↔ a ∈ M) → L = M

full_name: Sublattice.instSupCoe
code: /-- A sublattice of a lattice inherits a supremum. -/
instance instSupCoe : Sup L 
goal: Sup ↥L

full_name: Sublattice.instInfCoe
code: /-- A sublattice of a lattice inherits an infimum. -/
instance instInfCoe : Inf L 
goal: Inf ↥L

full_name: Sublattice.coe_sup
code: @[simp, norm_cast] lemma coe_sup (a b : L) : a ⊔ b = (a : α) ⊔ b 
goal: ↑(a ⊔ b) = ↑a ⊔ ↑b

full_name: Sublattice.coe_inf
code: @[simp, norm_cast] lemma coe_inf (a b : L) : a ⊓ b = (a : α) ⊓ b 
goal: ↑(a ⊓ b) = ↑a ⊓ ↑b

full_name: Sublattice.mk_sup_mk
code: @[simp] lemma mk_sup_mk (a b : α) (ha hb) : (⟨a, ha⟩ ⊔ ⟨b, hb⟩ : L) = ⟨a ⊔ b, L.supClosed ha hb⟩ 
goal: ⟨a, ha⟩ ⊔ ⟨b, hb⟩ = ⟨a ⊔ b, ⋯⟩

full_name: Sublattice.mk_inf_mk
code: @[simp] lemma mk_inf_mk (a b : α) (ha hb) : (⟨a, ha⟩ ⊓ ⟨b, hb⟩ : L) = ⟨a ⊓ b, L.infClosed ha hb⟩ 
goal: ⟨a, ha⟩ ⊓ ⟨b, hb⟩ = ⟨a ⊓ b, ⋯⟩

full_name: Sublattice.instLatticeCoe
code: /-- A sublattice of a lattice inherits a lattice structure. -/
instance instLatticeCoe (L : Sublattice α) : Lattice L 
goal: Lattice ↥L

full_name: Sublattice.instDistribLatticeCoe
code: /-- A sublattice of a distributive lattice inherits a distributive lattice structure. -/
instance instDistribLatticeCoe {α : Type*} [DistribLattice α] (L : Sublattice α) :
    DistribLattice L 
goal: DistribLattice ↥L

full_name: Sublattice.subtype
code: /-- The natural lattice hom from a sublattice to the original lattice. -/
def subtype (L : Sublattice α) : LatticeHom L α 
goal: LatticeHom (↥L) α

full_name: Sublattice.coe_subtype
code: @[simp, norm_cast] lemma coe_subtype (L : Sublattice α) : L.subtype = ((↑) : L → α) 
goal: ⇑L.subtype = Subtype.val

full_name: Sublattice.subtype_apply
code: lemma subtype_apply (L : Sublattice α) (a : L) : L.subtype a = a 
goal: L.subtype a = ↑a

full_name: Sublattice.subtype_injective
code: lemma subtype_injective (L : Sublattice α) : Injective <| subtype L 
goal: Function.Injective ⇑L.subtype

full_name: Sublattice.inclusion
code: /-- The inclusion homomorphism from a sublattice `L` to a bigger sublattice `M`. -/
def inclusion (h : L ≤ M) : LatticeHom L M 
goal: LatticeHom ↥L ↥M

full_name: Sublattice.coe_inclusion
code: @[simp] lemma coe_inclusion (h : L ≤ M) : inclusion h = Set.inclusion h 
goal: ⇑(Sublattice.inclusion h) = Set.inclusion h

full_name: Sublattice.inclusion_apply
code: lemma inclusion_apply (h : L ≤ M) (a : L) : inclusion h a = Set.inclusion h a 
goal: (Sublattice.inclusion h) a = Set.inclusion h a

full_name: Sublattice.inclusion_injective
code: lemma inclusion_injective (h : L ≤ M) : Injective <| inclusion h 
goal: Function.Injective ⇑(Sublattice.inclusion h)

full_name: Sublattice.inclusion_rfl
code: @[simp] lemma inclusion_rfl (L : Sublattice α) : inclusion le_rfl = LatticeHom.id L 
goal: Sublattice.inclusion ⋯ = LatticeHom.id ↥L

full_name: Sublattice.subtype_comp_inclusion
code: @[simp] lemma subtype_comp_inclusion (h : L ≤ M) : M.subtype.comp (inclusion h) = L.subtype 
goal: M.subtype.comp (Sublattice.inclusion h) = L.subtype

full_name: Sublattice.instTop
code: /-- The maximum sublattice of a lattice. -/
instance instTop : Top (Sublattice α) 
goal: Top (Sublattice α)

full_name: Sublattice.instBot
code: /-- The empty sublattice of a lattice. -/
instance instBot : Bot (Sublattice α) 
goal: Bot (Sublattice α)

full_name: Sublattice.instInf
code: /-- The inf of two sublattices is their intersection. -/
instance instInf : Inf (Sublattice α) 
goal: Inf (Sublattice α)

full_name: Sublattice.instInfSet
code: /-- The inf of sublattices is their intersection. -/
instance instInfSet : InfSet (Sublattice α) 
goal: InfSet (Sublattice α)

full_name: Sublattice.instInhabited
code: instance instInhabited : Inhabited (Sublattice α) 
goal: Inhabited (Sublattice α)

full_name: Sublattice.topEquiv
code: /-- The top sublattice is isomorphic to the lattice.

This is the sublattice version of `Equiv.Set.univ α`. -/
def topEquiv : (⊤ : Sublattice α) ≃o α 
goal: ↥⊤ ≃o α

full_name: Sublattice.coe_top
code: @[simp, norm_cast] lemma coe_top : (⊤ : Sublattice α) = (univ : Set α) 
goal: ↑⊤ = Set.univ

full_name: Sublattice.coe_bot
code: @[simp, norm_cast] lemma coe_bot : (⊥ : Sublattice α) = (∅ : Set α) 
goal: ↑⊥ = ∅

full_name: Sublattice.coe_inf'
code: @[simp, norm_cast] lemma coe_inf' (L M : Sublattice α) : L ⊓ M = (L : Set α) ∩ M 
goal: ↑(L ⊓ M) = ↑L ∩ ↑M

full_name: Sublattice.coe_sInf
code: @[simp, norm_cast] lemma coe_sInf (S : Set (Sublattice α)) : sInf S = ⋂ L ∈ S, (L : Set α) 
goal: ↑(sInf S) = ⋂ L ∈ S, ↑L

full_name: Sublattice.coe_iInf
code: @[simp, norm_cast] lemma coe_iInf (f : ι → Sublattice α) : ⨅ i, f i = ⋂ i, (f i : Set α) 
goal: ↑(⨅ i, f i) = ⋂ i, ↑(f i)

full_name: Sublattice.coe_eq_univ
code: @[simp, norm_cast] lemma coe_eq_univ : L = (univ : Set α) ↔ L = ⊤ 
goal: ↑L = Set.univ ↔ L = ⊤

full_name: Sublattice.coe_eq_empty
code: @[simp, norm_cast] lemma coe_eq_empty : L = (∅ : Set α) ↔ L = ⊥ 
goal: ↑L = ∅ ↔ L = ⊥

full_name: Sublattice.not_mem_bot
code: @[simp] lemma not_mem_bot (a : α) : a ∉ (⊥ : Sublattice α) 
goal: a ∉ ⊥

full_name: Sublattice.mem_top
code: @[simp] lemma mem_top (a : α) : a ∈ (⊤ : Sublattice α) 
goal: a ∈ ⊤

full_name: Sublattice.mem_inf
code: @[simp] lemma mem_inf : a ∈ L ⊓ M ↔ a ∈ L ∧ a ∈ M 
goal: a ∈ L ⊓ M ↔ a ∈ L ∧ a ∈ M

full_name: Sublattice.mem_sInf
code: @[simp] lemma mem_sInf {S : Set (Sublattice α)} : a ∈ sInf S ↔ ∀ L ∈ S, a ∈ L 
goal: a ∈ sInf S ↔ ∀ L ∈ S, a ∈ L

full_name: Sublattice.mem_iInf
code: @[simp] lemma mem_iInf {f : ι → Sublattice α} : a ∈ ⨅ i, f i ↔ ∀ i, a ∈ f i 
goal: a ∈ ⨅ i, f i ↔ ∀ (i : ι), a ∈ f i

full_name: Sublattice.instCompleteLattice
code: /-- Sublattices of a lattice form a complete lattice. -/
instance instCompleteLattice : CompleteLattice (Sublattice α) 
goal: CompleteLattice (Sublattice α)

full_name: Sublattice.subsingleton_iff
code: lemma subsingleton_iff : Subsingleton (Sublattice α) ↔ IsEmpty α 
goal: Subsingleton (Sublattice α) ↔ IsEmpty α

full_name: Sublattice.instUniqueOfIsEmpty
code: instance [IsEmpty α] : Unique (Sublattice α) 
goal: Unique (Sublattice α)

full_name: Sublattice.comap
code: /-- The preimage of a sublattice along a lattice homomorphism. -/
def comap (f : LatticeHom α β) (L : Sublattice β) : Sublattice α 
goal: Sublattice α

full_name: Sublattice.coe_comap
code: @[simp, norm_cast] lemma coe_comap (L : Sublattice β) (f : LatticeHom α β) : L.comap f = f ⁻¹' L 
goal: ↑(Sublattice.comap f L) = ⇑f ⁻¹' ↑L

full_name: Sublattice.mem_comap
code: @[simp] lemma mem_comap {L : Sublattice β} : a ∈ L.comap f ↔ f a ∈ L 
goal: a ∈ Sublattice.comap f L ↔ f a ∈ L

full_name: Sublattice.comap_mono
code: lemma comap_mono : Monotone (comap f) 
goal: Monotone (Sublattice.comap f)

full_name: Sublattice.comap_id
code: @[simp] lemma comap_id (L : Sublattice α) : L.comap (LatticeHom.id _) = L 
goal: Sublattice.comap (LatticeHom.id α) L = L

full_name: Sublattice.comap_comap
code: @[simp] lemma comap_comap (L : Sublattice γ) (g : LatticeHom β γ) (f : LatticeHom α β) :
    (L.comap g).comap f = L.comap (g.comp f) 
goal: Sublattice.comap f (Sublattice.comap g L) = Sublattice.comap (g.comp f) L

full_name: Sublattice.map
code: /-- The image of a sublattice along a monoid homomorphism is a sublattice. -/
def map (f : LatticeHom α β) (L : Sublattice α) : Sublattice β 
goal: Sublattice β

full_name: Sublattice.coe_map
code: @[simp] lemma coe_map (f : LatticeHom α β) (L : Sublattice α) : (L.map f : Set β) = f '' L 
goal: ↑(Sublattice.map f L) = ⇑f '' ↑L

full_name: Sublattice.mem_map
code: @[simp] lemma mem_map {b : β} : b ∈ L.map f ↔ ∃ a ∈ L, f a = b 
goal: b ∈ Sublattice.map f L ↔ ∃ a ∈ L, f a = b

full_name: Sublattice.mem_map_of_mem
code: lemma mem_map_of_mem (f : LatticeHom α β) {a : α} : a ∈ L → f a ∈ L.map f 
goal: a ∈ L → f a ∈ Sublattice.map f L

full_name: Sublattice.apply_coe_mem_map
code: lemma apply_coe_mem_map (f : LatticeHom α β) (a : L) : f a ∈ L.map f 
goal: f ↑a ∈ Sublattice.map f L

full_name: Sublattice.map_mono
code: lemma map_mono : Monotone (map f) 
goal: Monotone (Sublattice.map f)

full_name: Sublattice.map_id
code: @[simp] lemma map_id : L.map (LatticeHom.id α) = L 
goal: Sublattice.map (LatticeHom.id α) L = L

full_name: Sublattice.map_map
code: @[simp] lemma map_map (g : LatticeHom β γ) (f : LatticeHom α β) :
    (L.map f).map g = L.map (g.comp f) 
goal: Sublattice.map g (Sublattice.map f L) = Sublattice.map (g.comp f) L

full_name: Sublattice.mem_map_equiv
code: lemma mem_map_equiv {f : α ≃o β} {a : β} : a ∈ L.map f ↔ f.symm a ∈ L 
goal: a ∈ Sublattice.map { toFun := ⇑f, map_sup' := ⋯, map_inf' := ⋯ } L ↔ f.symm a ∈ L

full_name: Sublattice.apply_mem_map_iff
code: lemma apply_mem_map_iff (hf : Injective f) : f a ∈ L.map f ↔ a ∈ L 
goal: f a ∈ Sublattice.map f L ↔ a ∈ L

full_name: Sublattice.map_equiv_eq_comap_symm
code: lemma map_equiv_eq_comap_symm (f : α ≃o β) (L : Sublattice α) :
    L.map f = L.comap (f.symm : LatticeHom β α) 
goal: Sublattice.map { toFun := ⇑f, map_sup' := ⋯, map_inf' := ⋯ } L =
  Sublattice.comap { toFun := ⇑f.symm, map_sup' := ⋯, map_inf' := ⋯ } L

full_name: Sublattice.comap_equiv_eq_map_symm
code: lemma comap_equiv_eq_map_symm (f : β ≃o α) (L : Sublattice α) :
    L.comap f = L.map (f.symm : LatticeHom α β) 
goal: Sublattice.comap { toFun := ⇑f, map_sup' := ⋯, map_inf' := ⋯ } L =
  Sublattice.map { toFun := ⇑f.symm, map_sup' := ⋯, map_inf' := ⋯ } L

full_name: Sublattice.map_symm_eq_iff_eq_map
code: lemma map_symm_eq_iff_eq_map {M : Sublattice β} {e : β ≃o α} :
    L.map ↑e.symm = M ↔ L = M.map ↑e 
goal: Sublattice.map { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ } L = M ↔
  L = Sublattice.map { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ } M

full_name: Sublattice.map_le_iff_le_comap
code: lemma map_le_iff_le_comap {f : LatticeHom α β} {M : Sublattice β} : L.map f ≤ M ↔ L ≤ M.comap f 
goal: Sublattice.map f L ≤ M ↔ L ≤ Sublattice.comap f M

full_name: Sublattice.gc_map_comap
code: lemma gc_map_comap (f : LatticeHom α β) : GaloisConnection (map f) (comap f) 
goal: GaloisConnection (Sublattice.map f) (Sublattice.comap f)

full_name: Sublattice.map_bot
code: @[simp] lemma map_bot (f : LatticeHom α β) : (⊥ : Sublattice α).map f = ⊥ 
goal: Sublattice.map f ⊥ = ⊥

full_name: Sublattice.map_sup
code: lemma map_sup (f : LatticeHom α β) (L M : Sublattice α) : (L ⊔ M).map f = L.map f ⊔ M.map f 
goal: Sublattice.map f (L ⊔ M) = Sublattice.map f L ⊔ Sublattice.map f M

full_name: Sublattice.map_iSup
code: lemma map_iSup (f : LatticeHom α β) (L : ι → Sublattice α) : (⨆ i, L i).map f = ⨆ i, (L i).map f 
goal: Sublattice.map f (⨆ i, L i) = ⨆ i, Sublattice.map f (L i)

full_name: Sublattice.comap_top
code: @[simp] lemma comap_top (f : LatticeHom α β) : (⊤ : Sublattice β).comap f = ⊤ 
goal: Sublattice.comap f ⊤ = ⊤

full_name: Sublattice.comap_inf
code: lemma comap_inf (L M : Sublattice β) (f : LatticeHom α β) :
    (L ⊓ M).comap f = L.comap f ⊓ M.comap f 
goal: Sublattice.comap f (L ⊓ M) = Sublattice.comap f L ⊓ Sublattice.comap f M

full_name: Sublattice.comap_iInf
code: lemma comap_iInf (f : LatticeHom α β) (s : ι → Sublattice β) :
    (iInf s).comap f = ⨅ i, (s i).comap f 
goal: Sublattice.comap f (iInf s) = ⨅ i, Sublattice.comap f (s i)

full_name: Sublattice.map_inf_le
code: lemma map_inf_le (L M : Sublattice α) (f : LatticeHom α β) : map f (L ⊓ M) ≤ map f L ⊓ map f M 
goal: Sublattice.map f (L ⊓ M) ≤ Sublattice.map f L ⊓ Sublattice.map f M

full_name: Sublattice.le_comap_sup
code: lemma le_comap_sup (L M : Sublattice β) (f : LatticeHom α β) :
    comap f L ⊔ comap f M ≤ comap f (L ⊔ M) 
goal: Sublattice.comap f L ⊔ Sublattice.comap f M ≤ Sublattice.comap f (L ⊔ M)

full_name: Sublattice.le_comap_iSup
code: lemma le_comap_iSup (f : LatticeHom α β) (L : ι → Sublattice β) :
    ⨆ i, (L i).comap f ≤ (⨆ i, L i).comap f 
goal: ⨆ i, Sublattice.comap f (L i) ≤ Sublattice.comap f (⨆ i, L i)

full_name: Sublattice.map_inf
code: lemma map_inf (L M : Sublattice α) (f : LatticeHom α β) (hf : Injective f) :
    map f (L ⊓ M) = map f L ⊓ map f M 
goal: Sublattice.map f (L ⊓ M) = Sublattice.map f L ⊓ Sublattice.map f M

full_name: Sublattice.map_top
code: lemma map_top (f : LatticeHom α β) (h : Surjective f) : Sublattice.map f ⊤ = ⊤ 
goal: Sublattice.map f ⊤ = ⊤