Comments on: Optimizing CCCs

By: Conal Elliott » Blog Archive » Circuits as a bicartesian closed category

Tue, 17 Sep 2013 20:27:21 +0000

[...] previous few posts have been about cartesian closed categories (CCCs). In From Haskell to hardware via cartesian [...]

By: conal

conal — Mon, 16 Sep 2013 18:45:03 +0000

Derek & Dan: Thanks very much for the suggestions to eliminate const, which felt shaky indeed!

By: Dan Krejsa

Dan Krejsa — Mon, 16 Sep 2013 03:02:01 +0000

A very slightly different take expanding a bit on Derek Elkin's comment. Letting 1 (a.k.a. Unit) be the terminal object of the CCC, one can consider morphisms (1 ↣ b) as "elements of b" in some sense. Then one can have a function corresponding to 'const' applying to CCC morphisms:

const :: (1 ↣ b) -> (a ↣ b)
const e = e ∘ it

where it :: a ↣ 1 is the unique morphism from a to 1.

Now given CCC morphisms g :: b ↣ c and f :: a ↣ b, we may view

g ∘ exr :: (1 × b) ↣ c

and let

g' = curry (g ∘ exr) :: 1 ↣ (b ⇨ c)

Then

const g' :: a ↣ (b ⇨ c)
const g' = g' ∘ it = curry (g ∘ exr) ∘ it

and we have

apply ∘ (const g' △ f)
  = apply ∘ (curry (g ∘ exr) ∘ it △ f)
  = apply ∘ (curry (g ∘ exr) ∘ it △ id ∘ f)
  = apply ∘ (curry (g ∘ exr) ∘ exl △ id ∘ exr) ∘ (it △ f)
  = apply ∘ (curry (g ∘ exr) ∘ exl △ exr) ∘ (it △ f)
  = (g ∘ exr) ∘ (it △ f)
  = g ∘ (exr ∘ (it △ f))
  = g ∘ f

using the defining property of 'curry' that for any f : c × a -> b,

f = apply ∘ (curry f ∘ exl △ exr)

and the result

h ∘ f △ k ∘ g = (h ∘ exl △ k ∘ exr) ∘ (f △ g)

By: Derek Elkins

Derek Elkins — Sat, 14 Sep 2013 06:27:24 +0000

I think your difficulty with apply/const comes from the incoherence of const in this context; it adds a kind of "well-pointedness" that goes beyond a CCC and goes beyond what you need for at least this example. In a nutshell, it doesn't make sense to say "const x" in general since there is no way to talk about elements, x, "in" some object. However, category theory does let us talk about arrows and that leads to what is sometimes called the "name" of an arrow (in a CCC). Specifically, const f = curry (f ∘ exr) which should look familiar. From there, it's easy using the universal property of apply (as a counit of the relevant adjunction) which is: apply ∘ (curry f × id) = f. You get:

apply ∘ (const g △ f)
= apply ∘ (curry (g ∘ exr) △ f)             -- expand definition of const
= apply ∘ (curry (g ∘ exr) × id) ∘ (id △ f) -- naturality of fork, tacitly adding some ids
= g ∘ exr ∘ (id △ f)                        -- universal property of apply
= g ∘ f                                     -- (half of) universal property of pairs