If so, does ‘multiple values’ equal ‘a subset of Z’?
Ummm… or perhaps ‘a finite subset of Z’?

did you ever read Frank Herbert’s novel “the White Plague”?

http://www.skousen2000.com/religious%20products/Atonement.htm

Hi Mike,

your string diagrams are known as “sharing graphs” in the literature,
and are extremely well-studied. See e.g.

[1] Stefano Guerrini, A general theory of sharing graphs (1997)
http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.52.530

There is a reduction strategy on sharing graphs that is provably the
most efficient possible reduction strategy for lambda calculus; this
goes back to the work of Levy and Lamping (both cited in the above
paper).

Guerrini also gives an algebraic semantics of these sharing graphs,
see section 7. I don’t know whether it is related to your categorical
view.

I also like the book by Peyton-Jones:
[2] Simon Peyton Jones, The Implementation of Functional Programming
Languages (1987)
http://research.microsoft.com/en-us/um/people/simonpj/papers/slpj-book-1987/

It shows how to use sharing graphs as the basis for a practical
implementation of lazy programming languages. As far as I know, this
is still state-of-the-art and is used in the implementation of Haskell.
In keeping with the practical nature of the book, the sharing graphs
are represented in slightly different form (with syntactic variables
rather than backpointers), but this is of course equivalent.

As for the categorical semantics, what you have in mind is a kind of
abstract syntax with variable binding. To put this into perspective,
the semantics of ordinary abstract syntax (i.e., without variable
binding), is given by an object A in a cartesian category, together
with interpretations for each n-ary function symbol f : A^n -> A. One
can then inductively define the interpretation of terms, speak of the
free such object, etc.

Things get slightly more complicated if one adds variable binding to
this picture. This has also been studied, though perhaps not in the
same form as you are proposing. Perhaps the closest to your approach
is

[3] Martin Hofmann, Semantical analysis of higher-order abstract
syntax (1999)
http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.46.4082

Here one has var : V -> T, app : T x T -> T, and lam : (V => T) -> T
(see top of p.9, with the obvious changes in notation). You will note
the use of a function space (V => T) in place of your cartesian
product V^* x T.

Another very similar paper is

[4] M.P.Fiore, G.D.Plotkin and D.Turi. Abstract syntax and variable binding (1999)
http://citeseerx.ist.psu.edu/showciting?cid=198434
http://www.cl.cam.ac.uk/~mpf23/papers/Types/Types.html

Here, one has var : V -> T, app : TxT -> T, and lam : delta T -> T (as
contained e.g. in the commutative diagram on p.6). Again, delta T is
something akin to the function space V => T, but is also isomorphic,
in a suitable sense, to T => T, as far as I remember (this is
important for substitution, see below).

A third, technically slightly different (but conceptually similar)
approach to abstract syntax with variable binders is:

[5] Murdoch J. Gabbay, Andrew M. Pitts: A new approach to abstract syntax
with variable binding (1999)
http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.38.9383

[6] Murdoch J. Gabbay, Andrew M. Pitts: A new approach to abstract
syntax with variable binding (2002)
http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.62.9845

See especially the second-to-last line of [6, p.356], and you
immediately see the similarity. Their [A]T operation is akin to
V => T in [3] and delta T in [4].

It is fun to note that [3-5] all appeared (independently) in the same
conference in 1999. Semantics of variable binders was clearly a
pressing problem that year.

I can comment briefly on the main difference between these works and
what you are proposing. One thing that is important in syntax is
substitution (of a term for a variable). In fact, in the usual
abstract syntax (without binders), a term with n variables is
represented as a morphism A^n -> A. This is useful for substitution:
namely, if f : A x A^n -> A represents the term t(x,y_1,…,y_n) and
g : A^n -> A represents s(y_1,…,y_n), then f o represents
t[s/x].

In the presence of variables, a term with n variables is represented
as 1 -> V*^n x T (in your notation). However, for reasons of
substitution, one would still like this hom-set to be in 1-1
correspondence with T^n -> T. Somehow this is what the papers [3-6]
manage to do, each in their own way.

I hope these references will be useful. It would be great if you had a
more abstract monoidal framework of which the particular constructions
in [3-6] are concrete examples. I have always wondered about the
precise connection between [3-6], and whether there is a bigger
picture.

Good luck, and let me know how it goes! — Peter

So when I made the mistake of currying above, it wasn’t so far off.

Boy, that makes everything on my list look so juvenile

As for the response, it’s been muted at best. The paper I cited is hard to read; it took me a long time to understand as much as I have. That, combined with the proliferation of various calculi, each designed to illustrate one point or another, probably means that no one will pay attention to it unless someone promotes it heavily.

My real interest in it is to understand how to model concurrent objects using category theory, and from there to get a category-theoretic description of object capabilities.

(((S I) I) x) = (x x)
((K I) x) = I

The relation you noticed with B and C is real. In Haskell, you can have parameterized types, called “type constructors,” rather like functions whose inputs are types instead of values. The “context” type constructor is just type-lifted linear logic.

I’ve read your post about infinitesimal types; have you seen Joyal’s species (aka “structure types”)?

Given a tree, a zipper for the tree is a type that corresponds to a tree along with the address of a slot in the tree from which an element has been excised. McBride generalised this to any (regular) type, not just trees. The cool thing is that the type of a structure along with the address of an excised element is given by a type of derivative.

How does this duality appear in string diagrams? Is there a well-known transformation like this in Feynman diagrams?

For the monad T(A)=AxE a Kleisli arrow is an ordinary arrow A->BxE. That can’t read side effects, only write them.

For the monad T(A)=E->AxE a Kleisli arrow is A->T(B) = A->(E->BxE) = AxE -> BxE so it can read and write an E.

In fact, you’ve given me some deeper insight into continuations. The idea is this. In the context of continuations, the function ‘return’ maps from the type type a to the type (a->b)->b which can also be written Cont b a in Haskell. This (kind of) embeds a in Cont b a. That makes sense, Cont b a is like the value a but computed with a different style of programming, continuation passing style. But it always bothered me that it wasn’t an isomorphism because, as I say, it should just be the same thing coded up in a different way. But the missing piece is this: it *is* an isomorphism when you consider ‘return’ not as a function a -> ((a->b)->b) for some fixed b, but as a function polymorphic in b. In Haskell that’s written a -> (forall b . (a -> b) -> b) and that’s an isomorphism.

So thanks for helping me make the link between two different aspects of Haskell programming that I hadn’t connected together myself.

Boudol’s blue calculus paper describes how to transform from the standard call-by-value lambda calculus to the call-by-name calculus, and then how to encode the result in the pi calculus.

Here’s the homomorphism between the call-by-name transformation (CBN) and the continuation passing transformation (CPT):

`cf ⇒ :k `uf
`u`gf ⇒ ` `cf `ug
`uv ⇒ v (v is a variable)

where ` is Unlambda’s prefix application operator, c is whatever transformation we’re talking about, and u is a helper transformation. In CBN, :kx translates to “q ↦ def k = x in `qk,” where q is a new variable. In CPT, :kx is the term “k ↦ `kx.”

In both cases, :kx is the continuization of x.

I’ll have a look at your thesis to see if that clarifies anything for me.