From Sets to Categories (2023)
abuseofnotation.github.io
abuseofnotation.github.io
Like, ok?
It seems to appeal to computer science folks who want to level up their math chops, enjoy an exclusive "boutique" branch, and long for grand unification schemes. But IMHO it simply doesn't deliver. It's a whole lotta talk to say nothing.
I always compare with abstract algebra, where you start with a basic definition of groups and within a few pages you reach Lagrange's Theorem and now you understand something amazing about primes and sets, and you can keep squeezing and twisting the basic definitions for ever-more complex and brain-punishing results.
What would be the first interesting (if even mildly insightful) result in CT? I'll pull out my books and take a look...
There’s a whole section of Emily Riehl’s book Category Theory In Context on ‘theorems in category theory’ (since it’s famously said that there are none — you’re certainly not the first to level such an accusation!).
- associate immutable contextual stuff with your data
(think configuration, in C you'd add a context object
pointer argument to all your functions, but in Haskell
you'd just wrap your objects in monads)
- associate "mutable" contextual stuff with your data
(think state, in C you'd add a context...)
- abstract out I/O so you can write fully deterministic
code that's easy to test
- etc. (e.g., tracing, logging, transactions,
backtracking, and whatever else you can imagine)
A group models the invertible maps from one structure to itself. A groupoid models the invertible maps between a number of structures. A monoid models the maps from one structure to itself (without presuming invertibility). A category models the maps between a number of structures (without presuming invertibility).
CT is just... statements. It's "observational." I suppose maybe one should simply understand that going in, that there are no (or very few) actual results, it's just a set of descriptors.
Since you mention Lagrange's theorem, I presume you are looking for introductory results rather than advanced results. E.g., the result that a functor has at most one left adjoint up to isomorphism (a direct generalization of the fact that inverses are unique in groups). Or the result that a functor which has a left adjoint automatically preserves limits (and the near converse to this given by the Adjoint Functor Theorem). Or the theorem that a category has a limit for the entire category if and only if it has an initial object. Or the Yoneda lemma, which is a direct generalization of Cayley's theorem for groups. Or Lambek's theorem that every initial algebra is invertible.
What is a group-theoretic result of interest to you, apart from the aforementioned Lagrange's theorem? It might in particular be good to see a group-theoretic result which you find interesting even outside the context of finite groups (as there is not such an emphasis on considering finiteness in typical category theory, though one could of course say things specifically about finite categories too).
Presumably, what you have in mind here is the proof of Fermat's little theorem by saying "The integers modulo prime p under multiplication form a monoid of size p, among which the invertible subgroup comprises precisely the values not equivalent to zero (thus, of size p - 1). Within these, the order e of any value x is equivalent to the size of the subgroup x generates, which by Lagrange's theorem (decomposing the entire group into its cosets; i.e., its isomorphic orbits under the subgroup acting freely upon it) must divide the size of the overall group. Thus, x^(p - 1) = 1 mod p".
Yes, you can say all that in group-theoretic language. But someone skeptical of the value of group theory might object "All you are doing is using fancy words to say what could be said more straightforwardly. After all, Fermat's little theorem was understood by Fermat and others two hundred years before group theory was invented. Euler published his generalization of Fermat's little theorem a hundred years before group theory was invented. All your fancy-schmancy group theory is just pointlessly obfuscatory language for describing something already well understood".
And indeed, all group theory is doing in this case is showing us how to relate this one particular result to many other similar results. But that is the value of abstraction and generalization. That is how math often works. Recognizing a common pattern that comes up repeatedly, making particular instances obvious in retrospect, through fluently understanding their shared connection, once and for all. That's how it worked for groups, and that's the same way it works for categories.
I think if you do, you’ll discover quickly why category theory is so nice — and useful! Its origins aren’t in staring at a blank sheet of paper and trying to come up with needlessly complicated notations and idea; it comes only after centuries of observation and gradual pattern recognition.
Conversely: if you don’t, I don’t think you’ll ever get it. At least not without much difficulty.
It’s a bit like set theory: basically everyone uses it because it’s such a useful paradigm; hardly anyone studies it for its own sake. Those who do can tell you ‘theorems’ of set theory, and those who do the same for category theory can tell you ‘theorems’ of category theory. The rest of us use it as a convenient (and mind-expanding) language.
By the way, you shouldn’t consider it to be some kind of ontological theory (or even foundation) for mathematics. It makes no attempt to tell us what there is, or even particularly what is true; it gives us a way of simultaneously generalising thousands of definitions and facts, allowing us to see commonalities between a priori only distantly related concepts and therefore further generalisations more easily.
https://en.wikipedia.org/wiki/Weil_conjectures https://en.wikipedia.org/wiki/%C3%89tale_cohomology
If you can get to the point of understanding this stuff, which admittedly takes a long as time, I promise you that you'll appreciate category theory, lol. I didn't understand the significance of the Weil conjectures until my 4th year in a math phd program where I studied number theory.
The problem (at least partly) is that it's possible to read about and understand the statements in category theory long before you can understand any of the elegant and great uses of it, great uses of it in pure mathematics at least. I'm not familiar with the uses of category theory in computer science.
To make that more explicit, consider the space of left-multiplication maps Lr(x) = rx for real numbers r and x. Similarly, for right-multiplication maps Rr(x) = xr. Then the associative rule a(xc) = (ax)c can be re-written La∘Rc(x) = Rc∘La(x), which is precisely a commutativity relation.
The above obviously generalizes to arbitrary Abelian groups, but I'm curious if there's more depth to this idea of associativity as "higher-order commutativity" than just what I've said here.
The distributivity argument is a bit sketchy, though. It defines g.p := p▫q, meaning that g implicitly depends on q, but then writes f(y▫z) = f(g.y) and fy▫fz = g.f(y), where in the first instance g.x = x▫y and in the second g.x = x▫fz.
That said, I do see the point. The distributive rule let's us commute the order in which we compute addition and multiplication. Generally, I guess if we have some family of arrows A and B, where all commutative diagrams Bx∘Ay = Az∘Bw hold, then we can say "A and B commute". This can probably be expressed as some literal commutativity using natural transformations, but I'll need to think on it some more.
Thanks for the prod!
Another less high-brow connection: associativity of matrix multiplication relies on the usual distributivity law..
* and also data; with suitable choices of definitions there are very few differences between the left and right hand arguments to application.
"For any scheme X the category Et(X) is the category of all étale morphisms from a scheme to X. It is an analogue of the category of open subsets of a topological space, and its objects can be thought of informally as "étale open subsets" of X. The intersection of two open sets of a topological space corresponds to the pullback of two étale maps to X. There is a rather minor set-theoretical problem here, since Et(X) is a "large" category: its objects do not form a set."
There's a lot of advanced math in that paragraph, but it should be clear that Category Theory is needed to define etale cohomology.
This might not meet your criterion exactly, as one can extract a more topological proof and relegate the category theory to a non-essential role, but this requires some more effort and is a harder proof. So I do think it still illustrates that the category theoretic approach does add something beyond just a common language.
Grothendieck wrote modern Algebraic Geometry in the language of Category Theory. This is the first time I saw Category Theory really used in a useful way. Grothendieck's proofs of the Weil conjectures I would say is a good example of using Category Theory to solve a famous problem. Category Theory is used to define and work with etale cohomology and etale cohomology plays a fundamental role in Grothendieck's proofs of the Weil conjectures.
Last years SoME3 has this entrant https://youtu.be/Njx2ed8RGis?si=-Q0TwT8LKmTC9o0R
Also Oliver lugg has a hilarious overview of the topic
That's not an application of category theory. The important theorem here is that the fundamental group is a functor, plus computations of the fundamental group of the disc and the circle. But that's a theorem from topology, not a theorem from category theory. Category theory is merely used as a language, to give the proof a structure.
By that I don't want to say category theory is useless. But regarding the video it's neither necessary, nor an application of category theory.
> Proceed to link to a non-constructive proof
Why are mathematicians like this?
[1]: https://www.youtube.com/playlist?list=PLbgaMIhjbmEnaH_LTkxLI...
I think your question is wrong in a sense. Category theory is one of several languagues of mathematics, and there are analogies between them. It's kinda like asking "is there a computer program that requires to be written in C?"
So I think there is an element of taste whether you prefer category theory to some other (logical) language. That being said, just like in programming, it's still useful to know more than one language, because they potentially have different strengths.
Group theory -> Abel's theorem
Category theory -> ???
(below I got the answer 'Weil conjectures')
That said, two comments:
1) The definition of a category is just objects, arrows, and composition. If you're looking for more features, you might be disappointed. (If you've grown up with 'methods' rather than arrows, then you don't necessarily have composition.)
Writing your logic with objects and arrows is just damn pleasant. If I have bytes, and an arrow from bytes to JSON, then I have JSON. If I have also have an arrow from JSON to a particular entry in the JSON, then by the property of composition, I have an arrow from bytes to that entry in the JSON.
2) The various CT structures are re-used over and over and over again, in wildly different contexts. I just read about 'logict' on another post. If you follow the link [2] and look under the 'Instances' heading, you can see it implements the usual CT suspects: Functor, Applicative, Monad, Monoid, etc. So I already know how to drive this unfamiliar technology. A few days ago I read about 'Omega' on yet another post - same deal [3]. What else? Parsers [4], Streaming IO [5], Generators in property-based-testing [6], Effect systems [7] (yet another thing I saw just the other day on another post), ACID-transactions [8] (if in-memory transactions can count as 'Durable'. You don't get stale reads in any case).
They're also widespread in other languages: Famously LINQ in C#. Java 8 Streams, Optionals, CompletableFutures, RX/Observables. However these are more monad-like or monad-inspired rather than literally implementing the Monad interface. So you still understand them and know how to drive them even if you don't know all the implementation details.
However what's lacking (compared to Haskell) is the library code targeting monads. For example, I am always lacking something in Java Futures which should be right there: an arrow I can use to get from List<Future<T>> to Future<List<T>>. In Haskell that code ('sequence') would belong to List (in this case 'Traversable' [9]), not Future, as it can target any Monad. This saves on an n*m implementation problem: i.e. List and logict don't need to know about each other, vector and Omega don't need to know about each other, etc.
[1] https://www.youtube.com/playlist?list=PLCTMeyjMKRkqTM2-9HXH81tvpdROs-nz3
[2] https://hackage.haskell.org/package/logict-0.8.1.0/docs/Control-Monad-Logic.html#g:2
[3] https://hackage.haskell.org/package/control-monad-omega-0.3.2/docs/Control-Monad-Omega.html
[4] https://hackage.haskell.org/package/parsec-3.1.17.0/docs/Text-Parsec.html#t:ParsecT
[5] https://hackage.haskell.org/package/conduit-1.3.5/docs/Data-Conduit.html#g:1
[6] https://hackage.haskell.org/package/QuickCheck-2.15.0.1/docs/Test-QuickCheck-Gen.html#g:1
[7] https://hackage.haskell.org/package/bluefin-0.0.6.1/docs/Bluefin-Eff.html#g:1
[8] https://hackage.haskell.org/package/stm-2.5.3.1/docs/Control-Monad-STM.html
[9] https://hackage.haskell.org/package/base-4.20.0.1/docs/Data-Traversable.html#t:Traversable var tasks = names.Select(GetThingAsync); // IEnumerable<Task<Thing>>
var things = Task.WhenAll(tasks); // Task<Thing[]>, await to get Thing[]
As in, from outside, it looks like you are in there way deep, but it might need some more work to go and fetch the (assumed) target audience.
Every undergrad course, office hour, research paper, and manual that I've ever seen spams it.
The common formulation is that a "monad is just a monoid in the category of endofunctors", which is not saying much but with big words, and the joke lies in understanding what it's saying. Bartosz Milewski has a lecture video series on youtube that's all about explaining that joke, and I highly recommend it because it's actually a wonderful CS lecture series.
A (small) category is a partial monoid. The domain of m is the set of composable arrows.