Category Theory for DB-ies

(The Math of "Things" and "Stuff")

People always say that SQL is "Declarative"

Why is the following replacement ok?

            SELECT * FROM R WHERE A = 1 AND B = 2
          

            SELECT * FROM (SELECT * FROM R WHERE A = 1) WHERE B = 2
          

(and how is it the same as computing $x + 1 + 2$?)

Addition is Cool

Commutative $$a + b = b + a$$

Associative $$(a + b) + c = a + (b + c)$$

Neutral Element $$0 + a = a$$

Addition is Cool

            public int add(int a, int b) { ... }

            add(a, b)         == add(b, a)

            add(add(a, b), c) == add(a, add(b, c))

            add(a, 0)         == a
          

Math is about Patterns

Mathematicians call this a Group

            interface Group<K> {
              public K getZero() { ... }

              public K add(K a, K b) { ... }
            }
          

$$\left<\; K,\; +,\; 0\;\right>$$

Fun With Groups

$$\left<\; Set,\; \cup,\; \emptyset\;\right>$$ $$\left<\; \mathbb N,\; max,\; -\infty\;\right>$$

    class SetGroup implements Group<Set<int>> {
      // Empty Set union with anything is a no-op
      public Set<int> getZero() { return Collections.emptySet(); }

      // Compute Set Union
      public Set<int> add(Set<int> a, Set<int> b) { 
        Set<int> tmp = new HashSet<int>(a);
        tmp.addAll(b);
        return tmp;
      }
    }
          

    class IntMaxGroup implements Group<int> {
      // Max(x, -infinity) = x
      public int getZero() { return Integer.MIN_VALUE; }

      // Compute Max of two elements
      public int add(int a, int b) { return Integer.max(a, b) }
    }
          

            //Compute the maxium value in a Set
            public int SetMax(Set<int> set) { 
              int ret = Integer.MIN_VALUE
              for(int i : set) {
                ret = Integer.max(i, ret);
              }
              return ret;
            }
          

$$\texttt{SetMax} : SetGroup \rightarrow IntGroup$$

There's something really cool about SetMax

Mathematicians call this a homomorphism

Homo

"Same"

Morphism

"Function"

So what?

            SELECT MAX(x) FROM (SELECT * FROM R UNION S)
          

            MAX( (SELECT MAX(x) FROM R), (SELECT MAX(x) FROM S) )
          

Without Homomorphisms

With Homomorphisms

Let's dig a little deeper

Multiplication is also Cool!

Commutative $$a \times b = b \times a$$

Associative $$(a \times b) \times c = a \times (b \times c)$$

Neutral Element $$1 \times a = a$$

Combine for epic coolness!

Distributive $$a \times (b + c) = a \times b + a \times c$$

Sphere of Annihilation $$0 \times a = 0$$

More Patterns!

Mathematicians call this a Semiring

How many courses is each student taking?

SELECT S_ID FROM COURSES

How many courses is each student taking?

SELECT S_ID, COUNT(*) FROM COURSES GROUP BY S_ID

How many courses is each student taking?

SELECT Name, COUNT(*) FROM COURSES GROUP BY S_ID

Other Applications: Provenance, Permissions, Differential Privacy

                    SELECT * FROM R WHERE A = 1
          

$$\sigma_{A = 1}(t \rightarrow \#) = \begin{cases} \# & \text{if }t.A = 1 \\ 0 & \text{otherwise}\end{cases}$$

        SELECT * FROM (SELECT * FROM R WHERE A = 1) WHERE B = 2
          

$$\sigma_{B = 1}(\sigma_{A = 1}(t \rightarrow \#)) = \begin{cases} \sigma_{A = 1}(t \rightarrow \#) & \text{if }t.B = 2 \\ 0 & \text{otherwise}\end{cases}$$

        SELECT * FROM (SELECT * FROM R WHERE A = 1) WHERE B = 2
          

$$\sigma_{B = 1}(\sigma_{A = 1}(t \rightarrow \#)) = \begin{cases} \# & \text{if }t.A = 1\text{ and }t.B = 2 \\ 0 & \text{if }t.A = 1\text{ and }t.B \neq 2 \\ 0 & \text{otherwise}\end{cases}$$

        SELECT * FROM (SELECT * FROM R WHERE A = 1) WHERE B = 2
          

$$\sigma_{B = 1}(\sigma_{A = 1}(t \rightarrow \#)) = \begin{cases} \# & \text{if }t.A = 1\text{ and }t.B = 2 \\ 0 & \text{otherwise}\end{cases}$$

                SELECT * FROM R WHERE A = 1 AND B = 2
          

$$\sigma_{B = 1}(\sigma_{A = 1}(t \rightarrow \#)) = \begin{cases} \# & \text{if }t.A = 1\text{ and }t.B = 2 \\ 0 & \text{otherwise}\end{cases}$$