joppy

I would say that your stipulation is (if anything) the wrong way around - most people I know would limit representation theory to linear actions on a vector space (or module over a PID), but would not limit it to a group G: there are groups, Lie algebras, algebras in general, etc etc.

I think going down the route of trying to identify fields of maths with specific “things that can be stated in category theoretical language” is a bit wrong and bordering on hubris - sure, all group representations can be stated as some kind of functor between categories, but this is just convenient compact language for describing the definition. Any deep theorems that follow can almost certainly not be deduced from the categorical description, and are many times inhibited or obscured by it.

Yeah I was going to say, this sounds like a normal way of getting around the literature. We were taught to start mostly with review/summary papers from high-quality places, and work our way out from there.

The set of positive integers starts {1, 2, 3, …} and there are no positive integers smaller than 1. On the other hand the set of positive real numbers has no smallest element, since for any positive real number x, the number x/2 is smaller and still a positive real. It’s not that the reals are unorderable (they are most certainly ordered), it’s that certain subsets of the reals do not necessarily contain a minimum/maximum.

In a field like crypto you also have the concern that someone might copy your implementation and actually use it - this is fine if your specialty is crypto implementation (resistant to side-channel attacks and so on), but if your specialty is instead coming up with faster algorithm, your implementation is going to be much more proof-of-concept. In the theme of “don’t write your own crypto” is “don’t release your own crypto if you look authoritative (Eg a professor) and are not absolutely sure of it “

It’s obscure unless you’re a classical musician (or a pitch/tuning nerd): a lot more people than just piano players know of Bach’s work.

I guess this must be true, but from the sidelines it seems that “the set of points 1 metre from this particular point” and “the solution to this particular second-order differential equation” are quite different things. Any competent student of mathematics can connect them for sure, but it’s still quite remarkable they’re related isn’t it?

In Riemannian geometry (i.e. GR) each point has some local invariants associated to it, a famous one being curvature. "Local" here means that it only depends on the metric in an arbitrarily small disc/ball around the point. So the answer is no, in GR you can't always change coordinates so that space is locally flat. (This is in contrast to symplectic geometry for example, where each point does look locally like the model space).

“Having access to such a room is your own responsibility”…

It might be a little much to ask for during a pandemic where people are stuck in places they didn’t expect to be for a long while though, with a whole bunch of other people also stuck inside.

This is such a fantastic article. When I was doing my undergraduate thesis on lock-free and wait-free data structures, it was so difficult to find resources that explained these things in a straightforward way (or indeed in any way at all). I look forward to the future instalments!

“ If you code to just the DOM - that is is where you will stay. Forever.”

Svelte native exists…

The VDOM which mirrors the document DOM is an implementation detail of React, as something sitting between the actual DOM, and the VDOM fragment returned by a React view. It’s true that if the document DOM gets fast enough, the mirroring VDOM could go away, but some diffing algorithm would still have to reconcile the document DOM with whatever fragment is returned from a view.

I think one of the realisations of Svelte is that rather than returning arbitrary runtime generated DOM fragments from views, it is better to have the view implemented by a template that a compiler can understand and manipulate at compile-time. Here we trade off some expressivity (run-time generated DOM) for the ability to do much much more at compile time - I think this is the real point that should be being made in the article.

Lots of vdom frameworks are more than fast enough to run business-style SPA applications, but start being very laggy for data visualisation kind of work, or anything where complicated animation combined with user interaction is involved. This means the developer only gets a nice declarative framework sometimes, and has to go back to a more messy way of thinking otherwise.

Svelte (and some other contenders, like concurrent mode React) improve performance enough that interactive animated datavis stuff can also be done declaratively.

I've not used Vue, but how does this solve the problem? In most of my own sites, whatever preprocessor (eg markdown -> html) I use is instructed to replace mathematics with something like <span class="math">z = \frac{x}{y}</span>, then after the page has loaded a small loop runs KaTeX on all eligible spans. This results in some small amount of jumping, but I've found anchors to still work quite well.

The "server-side rendering" aspect of KaTeX is (and always has been, as far as I'm aware) front-and-centre on their landing page [1]. It allows you to input LaTeX and output HTML ready for inclusion server-side - the only thing this HTML needs to support it is the KaTeX CSS. This is very easy to do if your web server or static site generator is running on Node, and only a bit more difficult if it's running on something else (and therefore needs to shell out to Node). So if the author wants a good solution to server-side rendering, just look a little more at KaTeX.

On the flip side, I have reverted some of my server-side rendering of mathematics back to client-side rendering, because of considerations like webpage size. On mathematics-heavy pages, I found that pages that would otherwise be about 50KB in size got inflated up to about 1MB after server-side rendering all of the mathematics. After compression the difference was more like 70K, but this difference is the entire size of the (compressed) KaTeX library. I think it is completely reasonable to only transmit LaTeX markup over the wire, and have a client-side library take care of the presentation (as we do for HTML, SVG, ...).

I've also investigated MathML, but cross-browser support is terrible and has been for years. You also still get the size explosion problem, because LaTeX markup is just so much more compact than whatever MathML soup is equivalent.

[1]: https://katex.org/

Yes, it makes total sense for the garbage collector to be tightly coupled to the memory allocation system, which is also tightly coupled to code generation (as is done in the case of various high-performance managed languages: Java, C#, Haskell, …). I remember hearing a talk a few years ago about a system of the kind you’re talking about - a kind of “managed language” micro-core that ran alongside LLVM so that it could hook into code generation, and was intended to be a kind of toolkit for making new managed languages. Can’t remember the name…

“Arguably, the main reason why costs have gone up in [healthcare and education] is because society is richer, and thus more willing to bear the cost of better facilities and higher wages for healthcare and education workers.”

Please show me the nurse or teacher whose wages have risen proportionately to the cost of healthcare or education…

Isn’t this an argument for better code review, rather than against comments?

Differentiation is a function that takes a function and spits out a different one. (This may fail at points, but wherever the function is smooth enough, you get a corresponding point on the derivative). It is relatively simple to define, if somewhat laborious to make precise (real analysis etc).

The most straightforward definition of indefinite integration on the other hand is “the inverse of differentiation”. Like a lot of functions, inverses are much more complicated. Even in the case of matrix-vector multiplication, the inverse function (the inverse matrix) has an expression in terms of determinants in the original entries of the matrix - much more complicated than the original problem.

So I think that it’s the more simple theme of: even if the function is easy to describe, its inverse may be extremely complicated.

There are two ways you can define the hotel as being full:

1) The hotel is “full” if all the rooms are occupied.

2) The hotel is “full” if there is no way to rearrange the existing guests to leave an empty room.

These two definitions of “full” are equivalent for finite hotels. The ‘paradox’ is illustrating that these two definitions are not the same for infinite hotels. It serves as a useful reminder that there might be more “space” in infinite sets than we are used to in the finite case, and that if we are dealing with infinite sets we should keep in mind the fact that (1) and (2) (or whatever analogues are relevant for our problem) might be different, despite seeming the same based on our real-world experience.

Is it normal to deal with returns over time as log-returns log(R) rather than simple returns (R - 1) for this reason? The average log return does the right thing.

I think this really hits at why the identity is so famous: people tend to have been introduced to pieces in entirely separate ways, and from that perspective it’s quite surprising to see them all come together to create something nice.

I agree with you on the incomprehensibility of mathematics Wikipedia pages, even as a working mathematician I can really only read the pages about content I already know in-depth. But Wikipedia (and many other reference-type sources) are not the place I would go to learn a new topic in maths, I would always prefer to read a short book aimed at the correct level of knowledge, or a set of course notes (many of which are available online). I don’t think Wikipedia is representative of the teaching of maths at all.

Many of the courses on very abstract content I’ve taken (from other people, in person) has been very concretely introduced, or at least the course has been run with a 50/50 split on the abstract (general theory) and the concrete (solving problems).

The alternative being the pretty-much-just-as-short indices.map(i => myObjectArr[i])?

Log probabilities are used a bit for this, and most numeric packages (numpy for instance) have special functions for computing log(1+x) which are more accurate when x is tiny.

That really depends on how you define Spin(3), for example some would define it as the compact simply-connected Lie group of a certain type, at which point the unit quaternions model of Spin(3) is as good as any other.

That does sound super weird but I can see how it would work! I’d probably still prefer a stylus though :P

This is right - asymmetric crypto is awesome but just not anywhere near as fast as something like AES for chewing through chunks of data. So some anonymous asymmetric crypto (Diffie-Hellman or similar) is used to set up an encrypted channel, i.e set up a shared AES key, and then RSA is used to verify that the entity on the other end actually holds the private key for that subdomain. After that it’s AES pretty much all the way.

During my time I spent in the USA (I’m from Australia), I was very surprised at the way money and transactions worked. This was 2014/2015 - in Aus pretty much every consumer bank already had paywave (or whatever compatible technology) cards, which either paywave or also ask you for a PIN if the transaction is large, and here I was in the USA being asked to swipe my card and sign for things.

In small transactions (say, less than $100), no-one really cared - I would scribble my signature on a docket, no-one would double-check it with my card, everyone went on their way. Signatures were required but not respected or checked. In large transactions (I bought a MacBook, for example), the staff could not care less about my card or the signature scrawled on the back, but they would only take my money after I could produce some photo ID (a passport in my case) showing that the name on the card correlated to my face. In this case signatures were technically required but totally ignored because they’re easily forgeable. (A fact I’ve always been bemused by is that the signature is on the card - if you drop your card or something the signature is right there).

End of long story - how valid are “just signatures” legally? As someone with zero legal experience (clearly qualified to comment) I feel like other evidence showing that someone received and signed the document would be much more valid than just “the signature” by itself.

Agreed - what a great story!

Yeah, tablet and stylus is one of the best solutions for this. Even finger-on-iPhone is pretty janky-looking.

Which usually turns out a lot better - I tried signing on a trackpad but it looked like a preschooler signing their name :P