Logical Duals in Software Engineering
More techniques from the math mines
(Last week's newsletter took too long and I'm way behind on Logic for Programmers revisions so short one this time.1)
In classical logic, two operators F/G are duals if F(x) = !G(!x). Three examples:
x || yis the same as!(!x && !y).<>P("P is possibly true") is the same as![]!P("not P isn't definitely true").some x in set: P(x)is the same as!(all x in set: !P(x)).
(1) is just a version of De Morgan's Law, which we regularly use to simplify boolean expressions. (2) is important in modal logic but has niche applications in software engineering, mostly in how it powers various formal methods.2 The real interesting one is (3), the "quantifier duals". We use lots of software tools to either find a value satisfying P or check that all values satisfy P. And by duality, any tool that does one can do the other, by seeing if it fails to find/check !P. Some examples in the wild:
- Z3 is used to solve mathematical constraints, like "find x, where
f(x) >= 0. If I want to prove a property like "f is always positive", I ask z3 to solve "find x, where!(f(x) >= 0), and see if that is unsatisfiable. This use case powers a LOT of theorem provers and formal verification tooling. - Property testing checks that all inputs to a code block satisfy a property. I've used it to generate complex inputs with certain properties by checking that all inputs don't satisfy the property and reading out the test failure.
- Model checkers check that all behaviors of a specification satisfy a property, so we can find a behavior that reaches a goal state G by checking that all states are
!G. Here's TLA+ solving a puzzle this way.3 - Planners find behaviors that reach a goal state, so we can check if all behaviors satisfy a property P by asking it to reach goal state
!P. - The problem "find the shortest traveling salesman route" can be broken into
some route: distance(route) = nandall route: !(distance(route) < n). Then a route finder can find the first, and then convert the second into asomeand fail to find it, provingnis optimal.
Even cooler to me is when a tool does both finding and checking, but gives them different "meanings". In SQL, some x: P(x) is true if we can query for P(x) and get a nonempty response, while all x: P(x) is true if all records satisfy the P(x) constraint. Most SQL databases allow for complex queries but not complex constraints! You got UNIQUE, NOT NULL, REFERENCES, which are fixed predicates, and CHECK, which is one-record only.4
Oh, and you got database triggers, which can run arbitrary queries and throw exceptions. So if you really need to enforce a complex constraint P(x, y, z), you put in a database trigger that queries some x, y, z: !P(x, y, z) and throws an exception if it finds any results. That all works because of quantifier duality! See here for an example of this in practice.
Duals more broadly
"Dual" doesn't have a strict meaning in math, it's more of a vibe thing where all of the "duals" are kinda similar in meaning but don't strictly follow all of the same rules. Usually things X and Y are duals if there is some transform F where X = F(Y) and Y = F(X), but not always. Maybe the category theorists have a formal definition that covers all of the different uses. Usually duals switch properties of things, too: an example showing some x: P(x) becomes a counterexample of all x: !P(x).
Under this definition, I think the dual of a list l could be reverse(l). The first element of l becomes the last element of reverse(l), the last becomes the first, etc. A more interesting case is the dual of a K -> set(V) map is the V -> set(K) map. IE the dual of lived_in_city = {alice: {paris}, bob: {detroit}, charlie: {detroit, paris}} is city_lived_in_by = {paris: {alice, charlie}, detroit: {bob, charlie}}. This preserves the property that x in map[y] <=> y in dual[x].
-
And after writing this I just realized this is partial retread of a newsletter I wrote a couple months ago. But only a partial retread! ↩
-
Specifically "linear temporal logics" are modal logics, so "
eventually P("P is true in at least one state of each behavior") is the same as saying!always !P("not P isn't true in all states of all behaviors"). This is the basis of liveness checking. ↩ -
I don't know for sure, but my best guess is that Antithesis does something similar when their fuzzer beats videogames. They're doing fuzzing, not model checking, but they have the same purpose check that complex state spaces don't have bugs. Making the bug "we can't reach the end screen" can make a fuzzer output a complete end-to-end run of the game. Obvs a lot more complicated than that but that's the general idea at least. ↩
-
For
CHECKto constraint multiple records you would need to use a subquery. Core SQL does not support subqueries in check. It is an optional database "feature outside of core SQL" (F671), which Postgres does not support. ↩
If you're reading this on the web, you can subscribe here. Updates are once a week. My main website is here.
My new book, Logic for Programmers, is now in early access! Get it here.