Comments on: Generatingfunctorology

By: pozorvlak

pozorvlak — Thu, 29 May 2008 01:20:01 +0000

aed: it’s common in category theory to use + for coproduct, which in the category of sets is indeed disjoint union. If you allow a natural number n to be represented by the finite set {1, 2, … n}, then + becomes ordinary addition :-)

By: aed

aed — Sat, 17 May 2008 23:35:01 +0000

Oh — I think I should stop seeing “+” as addition, and more as algabraic union — the possible values of Maybe x are 1 or x. So generating fuctions enumerate out the return values of a function (the “clothesline” upon which we hang numbers), but also can be composed together and manipulated with finite calculus and such.

Ach! So confusing.

By: Edward Kmett

Edward Kmett — Sat, 17 May 2008 04:06:02 +0000

Well, D is affine, as well as being singular in the fashion described.

Also, I think some of the usual isomorphisms such as the x^2 -> 2*x^2/2 one break down for the same reason the connection between ~~a and a breaks down, because we are working in an intuitionistic setting.

(At least my hand-wavy attempts to try to realize negative values as continuations accepting a given value type seemed to run into that)

By: Dan P

Dan P — Sat, 17 May 2008 03:11:22 +0000

Ah…it’s called affine logic. I don’t know the terminology.

By: Edward Kmett

Edward Kmett — Fri, 16 May 2008 19:14:37 +0000

Hrmm. Just an observation:

If D^2 = 0, then given a functor F described by a generating function

F x = a_0 + a_1*x + a_2*x^2 + …

then

F D = a_0 + a_1*D

cuts off the series.

It also seems that D as a ’singleton pattern’ is affine (permits weakening), because nothing currently prevents you from ‘not using’ the D, as evidenced by the possibility of a_0 being non-zero.

By: Edward Kmett

Edward Kmett — Fri, 16 May 2008 17:31:45 +0000

Dan,

I love the notion of D as a singleton type.

I’ve been thinking about the idea of trying to represent the infinite cases using bivariate generating functions.

The idea would be that you ‘hang up on the number line’ quantities based on two parameters. One the number of traversals of the structure of size >= m that touch n values to give you an idea of the branching structure. Then clearly for n > m, the tail of the series = 0.

You then count the number of cases involved in using productive corecursion to visit n values in the structure rather than the number of distinct ways you can use well-founded recursion to build a structure of a given size.

I haven’t had time in the last couple of days to investigate the idea any further though.

[Edit: this doesn't appear to be sufficient and I haven't been able to find any good closed forms this way yet]

By: Edward Kmett

Edward Kmett — Thu, 15 May 2008 06:11:58 +0000

Ah, nice. My ‘naive encoding’ was apparently better than I thought =)

Currently mining the material written on species and what is in that Flajolet/Sedgewick book.

Awesome link, aed. Thanks!

By: Pseudonym

Pseudonym — Thu, 15 May 2008 05:40:41 +0000

In fact, that is a fairly efficient representation for trees. I’ve used something very close to it before, in C.
You have to remember that C(n) is 4^n/n^1.5 times some constant. So to store a number between 0 and C(n), you need 2n – 1.5 log n bits.
If you think about that for a moment, it’s easy to do with exactly 2n bits: Introduce a parallel array of 2n bits, each element of which represents whether or not each node has a left or right child.
If you were compressing this bit vector, you could get closer to the asymptotic behaviour by noting that there’s some redundancy: In your array of 2n bits, exactly n-1 of them will be 1 and the remaining n+1 of them will be 0. It’s probably not hard to exploit this and recover a representation that’s optimal in an asymptotic sense.

By: Dan P

Dan P — Wed, 14 May 2008 23:24:33 +0000

Edward, Did you ever read this or this? I spent lots of time thinking similar thoughts but eventually got stuck.

By: Edward Kmett

Edward Kmett — Wed, 14 May 2008 20:53:05 +0000

Well, a naive implementation for the ordinary generating function case is to just allocate an array of values the size of your structure, and store its size, and an ‘index’ into the possible structures of that size. This manipulates very poorly, but does allow for a linear time (heck, data parallel!) implementation of fmap. =)

A more practical implementation would necessarily want to take a generating function and generate a recurrence. This should give you a refolded version of the functor, like running the derivation for the list and tree functors backwards. This would let you do a transformation like turning the functor ‘Either Bool’ into a ternary constructor, which would then permit the use of partial-tagging to do dispatch with one case rather than two.

At this point though, I am still working on how to use these to model isomorphic structures, modeling contracts by division and subtraction, and what the right way is to extend it to cover codata.

Unfortunately, if we allow arbitrarily complex generating functions the comparison of the resulting streams requires an oracle for the halting problem, so, so far this is just a reasoning tool.