Work some more on lattices 2
Signedoffby: Danila Fedorin <danila.fedorin@gmail.com>
This commit is contained in:
parent
84f28ae5ce
commit
4938cdaecd

@ 422,7 +422,7 @@ only thing we needed is to be able to check and see if two elements are


equal or not; this is called _decidable equality_. Since that's the only


thing we used, this means that we can define an "above/below" lattice like this


for any type for which we can check if two elements are equal. In Agda, I encoded


this using a parameterized module:


this using a [parameterized module](https://agda.readthedocs.io/en/latest/language/modulesystem.html#parameterisedmodules):




{{< codelines "Agda" "agdaspa/Lattice/AboveBelow.agda" 5 8 >}}







@ 29,3 +29,39 @@ challenging, but for for a twolevel map like \(\text{info}\) above, we'd


need to do a lot more work. We need tools to build up such complicated lattices!




The way to do this, it turns out, is by using simpler lattices as building blocks.


To start with, let's take a look at a very simple way of combining lattices:


taking the Cartesian product.




### The Cartesian Product Lattice




Suppose you have two lattices \(L_1\) and \(L_2\). As I covered in the previous


post, each lattice comes equipped with a "least upper bound" operator \((\sqcup)\)


and a "greatest lower bound" operator \((\sqcap)\). Since we now have two lattices,


let's use numerical suffixes to disambiguate between the operators


of the first and second lattice: \((\sqcup_1)\) will be the LUB operator of


the first lattice \(L_1\), and \((\sqcup_2)\) of the second lattice \(L_2\).




Then, let's take the Cartesian product of the elements of \(L_1\) and \(L_2\);


mathematically, we'll write this as \(L_1 \times L_2\), and in Agda, we can


just use the standard [`Data.Product`](https://agda.github.io/agdastdlib/master/Data.Product.html)


module. In Agda, I'll define the lattice as another [parameterized module](https://agda.readthedocs.io/en/latest/language/modulesystem.html#parameterisedmodules). Since both \(L_1\) and \(L_2\)


are lattices, this parameterized module will require `IsLattice` instances


for both types:




{{< codelines "Agda" "agdaspa/Lattice/Prod.agda" 1 7 >}}




Elements of \(L_1 \times L_2\) are in the form \((l_1, l_2)\), where


\(l_1 \in L_1\) and \(l_2 \in L_2\). The first thing we can get out of the


way is define what it means for two such elements to be equal. That's easy


enough: we have an equality predicate `_≈₁_` that checks if an element


of \(L_1\) is equal to another, and we have `_≈₂_` that does the same for \(L_2\).


It's reasonably to say that _pairs_ of elements are equal if their respective


first and second elements are equal:




{{< latex >}}


(l_1, l_2) \approx (j_1, j_2) \iff l_1 \approx_1 j_1 \land l_2 \approx_2 j_2


{{< /latex >}}




In Agda:




{{< codelines "Agda" "agdaspa/Lattice/Prod.agda" 39 40 >}}




Loading…
Reference in New Issue
Block a user