In 'Managing Technical People', 1997, page 199, Watts Humphrey says that, after several failed attempts to produce a PC by IBM procedures, they set up an independent team that could skip the procedures as necessary to get the job done. This worked in the short term but it had two side-effects that were catastrophic in the long term: they lost control of the operating system to Microsoft, and they also lost control of the chips to Intel. He says both of these side-effects would have been caught by the checks inherent in the normal IBM procedures.
They might have caught the mistakes but I think the resulting product would have been a flop.
If IBM hadn't done what it did somebody else would have dominated the market with a product to fit the same niche. Perhaps somebody "downmarket" in the more consumer space who managed to punch upwards -- maybe Apple who had some business success with the Apple II + VisiCalc, etc. or maybe Kaypro or somebody in the CP/M space. Or perhaps somebody else "upmarket" like DEC, who came too late the personal computer space with products that nobody really bought (DEC Rainbow, etc) but maybe they'd have had more success if IBM hadn't gotten in there.
The market wanted a relatively open product to innovate in. When the PS/2 came along a few years later with proprietary bus, etc and tried to put the genie back in the bottle, it flopped.
One of my favorite scenes from Pirates of Silicon Valley is when Steve Ballmer (played by John DiMaggio, yes, the voice of Bender) narrates an audience aside, positively giddy with Ballmer glee at how his clever friend Bill put one over on those stodgy fellows from IBM and got them to give away the golden goose. It was like harpooning the great white whale. While it was a telefilm and thus a fictionalization, near as I can tell things happened pretty much as described.
I recently came to realise that my memories of my experiences of early childhood are probably greatly affected by seeing my younger siblings going through those same experiences a few years later. At age five or six I would see my mother reading to them on the sofa and they would be lying with their heads on her tummy feeling her warmth and listening to her heartbeat and stomach gurgles. Seeing this would remind me of when I used to do that, thus reinforcing those memories and probably somewhat distorting them. One of the distortions is that this memory is set in the house we moved to when I was four, and most of my own relevant experiences would have been set in our previous house. I think the accumulation of memories is a bit like training an LLM on a combination of new data and its own data.
It always pleases me to see pictures of NGC 4216, the edge-on spiral galaxy with a star beside its nucleus. I used to use it as a pointer to the short-period contact binary star CC Comae Berenices back when I used observe eclipsing binaries with my Celestron 8.
Category theory is what you get when you take mappings instead of sets as the primitive objects of your universe. At first this might seem a perverse thing to do as mappings seem more complex than sets, but that is just because traditionally mappings have usually been defined in terms of sets.
In set theory you can specify that two sets be equal and you can also specify that one set be an element of another.
In category theory you can specify that two mappings be equal and you can also specify that two mappings compose end to end to produce a third mapping.
Category theory can be used to express some requirements in a very concise way.
> Category theory is what you get when you take mappings instead of sets as the primitive objects of your universe.
I'm not sure about that, because you still need some concept of set (or collection or class) to define a category, because you need a set of objects and mappings between them (technically that's a "small" category, but to define any larger category would require at least as much set-theoretical complication).
More exactly, whereas in set theory it's the membership relation between sets and their elements that is basic, in category theory it's the mapping between objects.
Nevertheless, the basic concepts of set theory can also be defined within category theory, so in that sense they're inter-translatable. In each case though, you need some ambient idea of a collection (or class or set) of the basic objects. Tom Leinster has a brilliantly clear and succinct (8 pages) exposition of how this is done here
https://arxiv.org/abs/1212.6543
The thing is, even defining first-order logic requires a (potentially infinite) collection of variables and constant terms; and set theory is embedded in first-order logic, so both set theory and category theory are on the same footing in seemingly requiring a prior conception of some kind of potentially infinite "collection". To be honest I'm a bit puzzled as to how that works logically
Defining first-order logic doesn't really require set theory, but it does require some conception of natural numbers. Instead of saying there's an infinite set of variables, you can have a single symbol x and a mark *, and then you can say a variable is any string consisting of x followed by any number of marks. You can do the same thing with constants, relation symbols and function symbols. This does mean there can only be countably many of each type of symbol but for foundational purposes that's fine since each proof will only mention finitely many variables.
Allowing uncountably many symbols can be more convenient when you apply logic in other ways, e.g. when doing model theory, but from a foundational perspective when you're doing stuff like that you're not using the "base" logic but rather using the formalized version of logic that you can define within the set theory that you defined using the base logic.
Thanks, that sharpens it then to a question about natural numbers, or at least some idea of an indefinitely extensible collection of unique elements: it seems the ordering on the numbers isn't required for a collection of variables, we just need them to be distinct.
I don't think you need set theory to define set theory (someone would have noticed that kind of circularity), but there still seems to be some sleight of hand in the usual presentations, with authors often saying in the definition of first-order logic prior to defining set theory that "there is an infinite set of variables". Then they define a membership relation, an empty set, and then "construct the natural numbers"... But I guess that's just a sloppiness or different concern in the particular presentation, and the seeming circularity is eliminable.
Maybe instead of saying at the outset that we require natural numbers, wouldn't it be enough to give an operation or algorithm which can be repeated indefinitely many times to give new symbols? This is effectively what you're illustrating with the x, x*, x**, etc.
If that's all we need then it seems perfectly clear, but this kind of operational or algorithmic aspect of the foundation of logic and mathematics isn't usually acknowledged, or at least the usual presentation don't put it in this way, so I'm wondering if there's some inadequacy or incompleteness about it.*
So category theory is really the theory of composition of mappings. I conjecture that all programming can be seen as just the composition of mappings. If this is correct then category theory is a theory of programming.
Category theory is actually a ‘simplified’ graph theory, i.e. you can see categories as a restricted class of graphs. E.G. ‘Category Theory for Computing Science’ introduces categories this way (a category is a directed graph with associative composition and identity; the free category on a graph is the graph with all identities and compositions filled in). But the restrictions (associative composition and identity) are harmless and natural for programming applications where there's always a notion of ‘do nothing’ or ‘do one thing after another’, and unlock a lot of higher structure.
It helps you build an intuition for categories, if you're used to graphs :)
If you have a working intuition for categories then in most cases the specific formulation you choose as a foundation doesn't matter, just as most mathematicians work nominally in set theory without worrying about the subtleties of ZFC.
IMO the right intuition about a tool comes from applying it in the context where it provides a real leverage. In case of Category Theory that would be advanced algebraic topology (not re-phrasing basic things which are easier to understand without CT).
Rephrasing things is useful when it allows you to draw equivalences with other things that might have results or insights that translate across, which is something a lot of people use CT for. As with most maths the payoffs aren't always immediate, though, which leads to a lot of frustration with from programmers who expect immediate results from their insights.
From a programming perspective, though, a fair few important things have (by now) turned out to be useful that have come as a result of rephrasing programming in mathematical terms. Some top contenders are monads (directly from CT — think Haskell, but also LINQ, JavaScript Thenables, async/await, Rust Option/Result combinators, parser combinators), proof assistants and modern approaches to type systems, linear/substructural logic (think Rust or C++ move semantics), functional programming (which is now embraced at least to some extent by all mainstream programming languages), functional reactive programming (the core ideas behind things like React), et cetera.
If you allowed infinite graphs maybe. How would you define a functor or natural transformation in graph theory? Seems like you would need to construct a conceptual system that is just equivalent to category theory
No, but if you want to talk about composing those arrows (and a sensible notion of composition should probably be associative, and perhaps have a unit) you eventually end up reinventing category theory.
That is probably what they mean by specifying that they compose.
If all you know is that you have two mappings you don't know they compose, until you get the additional information about their sources and targets. In a way that's what the source and targets are: just labels of what you can compose them with.
It's more that category theory foregrounds the functions themselves, and their relationships, rather than on the elements of sets which the functions operate on. This higher-level perspective is arguably the more appropriate level when thinking about the structure of programs.
For more detail, see Bartosz Milewski, Category Theory for Programmers:
"Composition is at the very root of category theory — it’s part of the definition of the category itself. And I will argue strongly that composition is the essence of programming. We’ve been composing things forever, long before some great engineer came up with the idea of a subroutine. Some time ago the principles of structured programming revolutionized programming because they made blocks of code composable. Then came object oriented programming, which is all about composing objects. Functional programming is not only about composing functions and algebraic data structures — it makes concurrency composable — something that’s virtually impossible with other programming paradigms."
Take a mapping a and precompose it with the identity mapping i.
By the definition of the identity mapping the resulting composition is equal to a.
i;a = a
(Here ';' represents forward composition. Mathematicians tend to use backward composition represented by '∘' but I find backward composition awkward and error-prone and so avoid using it.)
Now, if there is another mapping j that is different from i, such that
j;a = a
then the mapping a loses information.
By this I mean that if you are given the value of a(x) you cannot always determine what x was.
To understand this properly you may need to work through a simple example by drawing circles, dots and arrows on a piece of paper.
If there is no such j then mapping a is said to be a monomorphism or injection (the set theoretic term) and it does not lose information.
This specification of the property 'loses information' only involves mapping equality and mapping composition.
It does not involve sets or elements of sets.
An example of a mapping that loses information would be the capitalization of strings of letters.
An example of a mapping that you would not want to lose information would be zip file compression.
If you alter the above specification to use post-composition (a;i = a and a;j = a) instead of pre-composition you get epimorphisms or surjections which capture the idea that a mapping constrains all the values in its codomain.
I like to think of this as the mapping does not return uninitialized values or 'junk' as it is sometimes called.
I would think so, but perhaps for the people who are self-defined by the magnitude of their wealth they become more and more obsessed by it as their expenditures on "real" things dwindles in comparison.
And I wouldn't expect it to be, given that were are the product of billions of years of an evolutionary process that has relied on 'scrap and rebuild from scratch' as a mechanism to control errors.
reply