We define a **join semilattice** to be any poset that has a join/lub for every *non-empty finite* subset. For such orderings, and any pair of elements `a,b`

from their domain, `a ∨ b`

will be defined. Equivalently, you could state the definition as requiring that *any pair* of elements has a join/lub. Any single element will be its own join/lub; so this requirement ensures that any non-empty finite subset has a join/lub. We’ll discuss infinite and empty subsets later.

The notion of a **meet semilattice** is defined analogously, requiring every non-empty finite subset to have a meet/glb.

A **lattice** can be defined as a poset that is both a join and a meet semilattice.

Considering join and meet as operations on pairs of elements, they will be commutative, associative and idempotent operators. (As we saw in Homework 1 Problem 12, the last means that applying the operation to the same argument twice results in that same argument.) They also satisfy this property, for all `a,a′,b,b′`

in the ordering’s domain:

`(a ⊑ a′ and b ⊑ b′) ⊃ (a ∨ b) ⊑ (a′ ∨ b′)`

The same holds with `∧`

substituted for `∨`

.

If follows from our definitions that join and meet will interact with each other as follows (these are called “the absorption laws”):

```
a ∨ (a ∧ b) = a
a ∧ (a ∨ b) = a
```

(Compare Homework 1 Problems 6a and 6b.)

It follows also that they’ll interact with the order relation `⊑`

like this:

`a ⊑ b iff a ∨ b = b iff a = a ∧ b`

(Compare Homework 1 Problems 6c and 6d.) We’ll return to these equivalences below.

If a lattice has a non-empty finite domain, then by the definition we’ve already seen of “lattice,” the whole domain must have a join/lub, and this will be greatest element of the domain. It’s called **top**, also written as `⊤`

. Similarly, the whole domain must have a meet/glb, and this will be the least element of the domain. It’s called **bottom**, also written as `⊥`

. (As we said on the webnotes on orders, these terms are sometimes used for partial orders more generally, even if they’re not lattices. The symbols `⊤`

and `⊥`

also have other uses.)

If the lattice has an infinite domain, greatest and/or least elements are not required to exist, but they may. When they do exist, we say the lattice is **bounded**. (Sometimes this term is also used for partial orders more generally, even if they’re not lattices.)

When a lattice has a top/greatest element (the join of its whole domain), we say that meet `∅`

is also defined to be top. When a lattice has a bottom/least element (the meet of its whole domain), we say that join `∅`

is also defined to be bottom. These definitions follow from the fact that the notions of upper bound and lower bound are defined in such a way that every element of the domain is both an upper and a lower bound for the subset `∅`

. So any least element of the domain (the domain’s bottom) is a least upper bound for `∅`

, and similarly any greatest element of the domain (the domain’s top) is a greatest lower bound for `∅`

.

Here’s a way to think of the identifications:

`top = join(`

whole domain`) = meet ∅`

`bottom = meet(`

whole domain`) = join ∅`

that may help make them more memorable or natural. There’s an intuitive correspondence between the join operation and disjunction in propositional logic, and the meet operation and conjunction in propositional logic, and between top and true, and between bottom and false. (Indeed, this correspondence is more than merely intuitive, but we don’t need to make it more rigorous at present.) If you’re taking the disjunction of three propositions `p`

, `q`

, and `r`

, you could understand that as `(p or q) or r`

or as `p or (q or r)`

of as “some of `{p,q,r}`

are true.” Similarly, you could understand their conjunction as “all of `{p,q,r}`

are true.” Then it makes sense to think of the disjunction of no propositions as false, and the conjunction of no propositions as true. Correspondingly, the join ∨`∅`

is defined to be `bottom`

, and the meet ∧`∅`

is defined to be `top`

.

It follows from our definitions that when top and/or bottom elements exist, they will satisfy these laws:

```
a ∧ ⊤ = a
a ∨ ⊥ = a
```

The definitions of (semilattices and so) lattices only require the existence of joins and meets for non-empty *finite* subsets. We just saw that *when* a lattice has a top and/or bottom elements, meets and joins of empty subsets (and of the whole domain, which may be infinite) will also be defined. What about arbitrary infinite subsets? There are not required by the definition to have meets and joins, but depending on the ordering they may. When they always do, the lattice is called **complete**.

Being complete implies that joins and meets of the whole domain exist, and these will be a top and bottom for the lattice. So any complete lattice will be bounded.

Lattices are not required to satisfy these laws:

```
a ∨ (b ∧ c) = (a ∨ b) ∧ (a ∨ c)
a ∧ (b ∨ c) = (a ∧ b) ∨ (a ∧ c)
```

But some lattices do, and they are called **distributive**.

For a bounded lattice, where top and bottom elements exist, two elements `a,z`

of the domain count as **complements** when these two identities hold:

```
a ∨ z = ⊤
a ∧ z = ⊥
```

In general, an element of a bounded lattice may have no complements, or more than one. For a *distributive* lattice, the complement of `a`

when it exists is unique; and also “De Morgan”-like laws hold. (The complement of `a ∧ b`

will be the join of the complement of `a`

and the complement of `b`

; and so on.)

When a bounded lattice is such that every element *does* have a complement, and the lattice is also distributive, it’s called a **Boolean algebra**.

When the poset `(Α, ⊑)`

is any kind of lattice, a **sublattice** is defined to be a subset `Μ`

of `Α`

such that for all `a,b ∈ Μ`

, `a ∨ b ∈ Μ`

and `a ∧ b ∈ Μ`

. What’s required here is not just that `a`

and `b`

have *a join and meet* findable in `Μ`

, but that they have the same join and meet in `Μ`

that they do in `(Α, ⊑)`

.

We’ve been approaching lattices from the perspective of their order relations. We defined a join as the least element (wrt the order in question) of a subset’s upper bounds (wrt the order in question). Similarly for meet. These definitions allowed us to consider the cases where join and meet were applied to sets of two elements, and to treat them like associative, commutative, idempotent binary operators on the poset’s domain.

Another approach to lattice structures is to *start with* an associative, commutative, idempotent binary operator `⊛`

on some domain. We can then “treat” that operator “as a meet,” and use it to define a relation `⊑`

as follows:

`a ⊑ b =def a = a ⊛ b`

You can then prove that the `⊑`

so defined will be a partial order, and moreover one that satisfies the requirements to be a meet semilattice.

Alternatively, you can treat `⊛`

“as a join,” and use it to define a relation `⊑`

:

`a ⊑ b =def a ⊛ b = b`

You can then prove that the `⊑`

so defined will be a partial order, and moreover one that satisfies the requirements to be a join semilattice.

In either case, if the defined order *also* satisfies the requirements to be the other kind of semilattice, you’ll have a lattice and can understand the dual operator (that is, join if you’re treating `⊛`

as a meet) in terms of the lub (or glb) properties of the defined order `⊑`

.

Alternatively, suppose you have *two* associative, commutative, idempotent operators `⊛`

and `⊙`

on the same domain, and they interact as follows:

```
a ⊛ (a ⊙ b) = a
a ⊙ (a ⊛ b) = a
```

(Compare the “absorption laws” for join and meet mentioned above.) In that case, you can choose either of the operators to be the meet, and the other to be the join, and you’d get a lattice using the order relations defined above. (The two definitions of `⊑`

would end up being equivalent.)