 There are a number of logical equivalences that we'll find useful to know while we're building our architecture. These are essentially just a bunch of simple rules that are already known to be true and can allow us to simplify or transform a proposition that we already have that might otherwise look rather complex. So, a lot of these should be pretty straightforward and really obvious. Things like p or true is true because, well, if one of your inputs to an or operation is true, it doesn't really matter what the other one is. The result will be true either way. On the other hand, if you have p and false, well, you're not going to be able to get a true out of this expression, so that's going to end up being false. Some things are just really important to have in the system like the negation of p is also p. If this didn't work, we could end up having trouble with our actual operations here. We saw one of these earlier when we looked at the truth table, which was that p or p and q turned out to just be the same as p. We showed that using the truth table, but that's another example of an absorption law where the p on the left-hand side ends up being far more relevant than the complex term on the right-hand side. Knowing that absorption law would allow you to reduce a complex expression into a much simpler one that just had p. De Morgan's laws are one of the more interesting and less obvious of these logical equivalences. De Morgan's laws allow you to distribute a negation over a complex proposition. But in doing so, we end up flipping ores to ands or ands to ores, and the way we're used to a distributive law, we wouldn't expect that we'd have to change our ands to ores. So De Morgan's laws are not the most obvious, but they end up being very, very useful in a lot of cases. The majority of these logical equivalences you'll see once in a while they'll give you a nice way to simplify expressions, make your hardware simpler or easier to just understand what the hardware is doing. So these are useful to know.