You're reading the public-facing archive of the Category Theory Zulip server.
To join the server you need an invite. Anybody can get an invite by contacting Matteo Capucci at name dot surname at gmail dot com.
For all things related to this archive refer to the same person.
Hi there. I was wondering the following:
My guesses are:
A -> B
as a B
-indexed partition of A
into non-empty sets, and of injections X -> B
and X -> A
as X
-sized subsets of the index set and disjoint union of the partitions respectively)Could you spend a bit more time explaining how a surjection is supposed to act to turn an injection into an injection ? Can you give me some sort of formula for in terms of and ?
For some reason I'm not understanding your description, even though I am familiar with how one can think of a surjection as a -indexed partition of into nonempty subsets, namely the fibers for .
@John Baez It turns out that I was simply wrong! I was not thinking carefully enough about surjections. But I hope that I am at least wrong in an interesting way...
The way that I was thinking of a surjection was as a "two part" thing. The first part of a surjection is simply a function . The second part is a function (to non-empty subsets of ), subject to the constraints:
These I think form a category whose composition and identity involve the monad structure of the non-empty powerset monad (whose unit I actually implicitly utilize in the equations above).
Now, precisely as you pointed out, a surjection and an injection do not in general induce an injection . This is because an arbitrary injection need not "respect" the partition induced by the surjection, since it can map multiple elements of to elements of the same partition in . When composed with the of the surjection, injectivity is lost.
It's worth noting however that the composition of a surjection with an injection that "respects its partition" (by mapping distinct elements of its domain to elements of distinct partitions), is in fact an injection.
Hopefully I have managed so far to avoid screwing up again, I would really appreciate correction if not!
So the trouble with my proposal above is that, given a surjection , one can't construct the of a surjection (in some sense is "too large"). But (I believe) there is no difficulty with the "other half"!
That is to say, one can define a mapping of s , and interpret it as an endofunctor on the Kleisli category of the non-empty powerset monad. Given a partition of , and an -sized subset of its indexing set , we obtain all the -sized subsets of in which each selected partition is represented uniquely. There is always at least one such subset, by virtue of the partition consisting of non-empty subsets.
It is also worth noting that every injection in the image of this mapping is a "partition respecting" injection of the sort discussed above.
I was wondering if this perhaps suggests that one can have an honest endofunctor on "partial surjections"? I.e. the output surjection simply neglects to act on any injections that do not respect the partition induced by the input surjection.
For whatever reason I started by thinking about surjections, but I also wonder if there is an analogous "two part" characterization of injections.
Suppose we say is the "maybe monad" with injections and (the unit of the monad). Let's equip each set with a partial order whose only non-trivial inequations are for each .
So now we might define an injection to consist of a function and a function , subject to the conditions:
Does this make any sense?
I'd conjecture there is a "lattice" of monotone maps . If one composes with a discarding of the preorder structure, we also end up with a lattice of monads and their morphisms. A brief description of the functors is:
The bottom of the lattice is and the top is , and we can interpret each inequation in the lattice as both a monad morphism and a natural transformation of -valued functors
All of this is to say the following: it seems like we can generalize from the typical hierarchy of "function, injection, surjection, bijection" to pairs of coalgebras of two functors drawn from the lattice described above (viewed as endofunctors on ), subject to a condition similar to the ones I stated above, but expressed in terms of the meet of the relevant functors. The notion of composition for each such variety of arrow involves the meet of the two selected monads.
This lets one somewhat mechanically define sensible notions of "partial function", "multi-valued surjection", etc, and suggests a framework in which suitably annotated arrows of a type theory are given pairs of "forward" and "backwards" semantics. So a "total surjection" can be run forwards on an input to calculate a precise result, or run backwards on an output to obtain a family of inputs that produce it. Or a "multi-valued injection" can be run on an input to calculate a family of results, or run backwards on an output in some family of results to obtain which (if any) input produces it.
I also wonder if all of this can be transported to arbitrary topoi...
I gather that Ord is a category of preorders rather than a category of ordinals? :joy:
What's the motivation for that naming system?
It seems like you're missing an adjointness condition here. After all, a function completely determines its inverse image, so we can't take an arbitrary pair of coalgebras.
The things you suggest towards the end are probably true, but the framework you're proposing carries around a lot of baggage which is avoided by just using relations instead, so if you think there's something in it you'll need to look for some directions where it gets deeper. What's your own motivation for thinking about these things?
@Morgan Rogers (he/him)
I gather that Ord is a category of preorders rather than a category of ordinals?
Yes, exactly! I am unfortunately not very familiar with mathematical parlance and found the name from the Wikipedia page for "category of preorders". Is there a more standard name for this?
What's the motivation for that naming system?
You can imagine the functor [x, y]
to be imbuing a given set with the preorder (in fact lattice) of "at-least x-sized, and at-most y-sized" subsets under inclusions. I notate (perhaps poorly) an infinite size as .
It seems like you're missing an adjointness condition here. After all, a function completely determines its inverse image, so we can't take an arbitrary pair of coalgebras.
It is true that you need an adjointness condition, this is precisely what I was referring to by:
subject to a condition similar to the ones I stated above, but expressed in terms of the meet of the relevant functors
So the idea is that the relationship between an arbitrary function and its inverse image is no different from the relationship between an injection and its inverse image: both are characterized by a Galois connection, just for different preorders in the lattice.
What's your own motivation for thinking about these things?
My motivation for thinking about such things is "computationally feasible" reversible programming. It is true that a function, or a multi-valued injection, or a partial surjection, etc. all have inverses in some abstract sense, but this is usually not computationally accessible. If one instead reformulates all these things as simple pairs of functions, it becomes easy to embed this framework in a language that is not a priori designed to work with relations, or to give a type theory semantics using these paired coalgebras.
You say that it is easy to just use relations, but I'm not sure how easy it is to work with infinite relations on a computer in the standard sense of "a subset of the cartesian product". It seems to me that to make the problem tractable one has to rely on the relation being a "functional relation" in some sense, and to switch from an explicit pairing of inputs and outputs to a perspective where the outputs (resp. inputs) latently associated with given inputs (resp. outputs) are revealed by computation.
so if you think there's something in it you'll need to look for some directions where it gets deeper
There is certainly much I haven't said but suspect of such categories, and the relationships between them (e.g. being monoidal, cartesian, sometimes closed, sometimes not-quite-closed-but-cotensored) that is relevant to our ability to interpret suitably typed programs in them. I haven't expended much effort on working this out yet though, given that I have a tendency to screw up basic things and am still trying to verify whether the setup outlined above makes sense.