consilient

> If you don't come from a math-y background and are trying to "get into serious mathematics", the only way to do this is to get a PhD.

> I realize this might come across as gatekeeping, but the reality is that each subfield of math (or any scientific discipline) has its own set of tactics for approaching problems, which have been developed over the years by the people actually in the trenches.

There are degrees of seriousness. Sure, even a very good foundation is not enough to do novel work in say, algebraic geometry (but then again, sometimes it is enough to make progress in combinatorics) - but the strongest undergrads are still much closer to freshly minted PhDs than they are to laymen.

Mathematical maturity is the first and hardest step; after that, people will know where to go for the folklore if they want it.

> Has anyone ever written a piece of code that's really so difficult for a human to read and figure out whether it halts?

Any interpreter for a Turing-complete language is an example.

> It's possible that what I mean can be turned into a statement like "all functors used in programming are representable", but I'm not sure.

No, this is much stronger and definitely false. Any variable-size data structure is not going to be representable: e.g. `Maybe`, `List`, `BinaryTree`.

Most data structures are sums of representable functors (i.e. are `Traversable`), but not all. Hash sets () are the classic counterexample: you can't walk them in a consistent order because the internal structure depends on the hashes, and you need to recompute hashes when you transform values.

> if we can't even use Monads without mathematically knowing they are Monads then no one is ever going to be using them.

You don't need to know what a monad is to use one. Everyone who has ever written a computer program has used one. Knowing that you're using a monad, and what that means about your program structure, is the entire value proposition here - actually applying particular monad operations is utterly trivial. "Monad" belongs in the same category as "data structure", not "tree".

> Monads, even when restricted to programming language usage, do not fundamentally have anything to do with continuations.

This is a little too strong, I think. If your category is sufficiently nice (complete closed symmetric monoidal, I think) then every monad arises as a codensity monad `Codensity_F x = \int_{y} (x -> Fy) => Fy` (with `->` and `=>` as the respective homs), which is clearly continuationy in character.

There are so far as I know no programming languages that correspond to genuinely complete categories, but Haskell at least is close enough that this construction still works. The main obstacle there to "`Monad`s are just continuations" isn't mathematical, it's the lack of language support for talking about categories other than `Hask`.

> I agree that it would be interesting to learn what non-strong monads look like.

A monad is strong if:

- its underlying functor is strong

- the strength commutes with the monad unit `return :: a -> m a`, i.e. `return (x,y) === strength x (return y)`

- the strength commutes with the monad multiplication `join :: m (m a) -> m a`, i.e. `strength x (join mmy) === join (map strength (strength x mmy))`

So a non-strong monad is one for which at least one of these conditions is false.

Non-strong functors are easy to find examples of: take any container type with multiple "slots" (e.g. lists, arrays, n>1-tuples) and put it in a language with linear types. You can't implement `strength` for these types because you can't necessarily copy the `x` value.

Off the top of my head, I can't think of any non-contrived way to violate the latter two conditions without also breaking the monad laws or the requirements of a monoidal product, but presumably they're out there.

You need it to be symmetric if you want strength as such instead of left-strength and right-strength, but otherwise yes, it makes sense to talk about strength relative to any monoidal product.

> What about between the first photons and the first galaxies?

~200-400 million years. There's a lot of uncertainty from early JWST observations that haven't received more detailed measurements yet.

The CMB is everywhere, but it was emitted by the initial formation of neutral hydrogen (from plasma) in the early universe. When people talk about the CMB being far away they're really talking about the last scattering surface, which is that early plasma as seen 13+ billion years later.

> the Planck length is presumed to be the smallest measurable distance before stuff turns into a black hole

This is not correct. The Planck length happens to be very very roughly the scale at which we expect effective theories that ignore quantum-gravitational effects (i.e. the Standard Model) to break down. It has no special physical significance.

> I'm guessing it's the one that says kinetic minus potential energy, but that seems arbitrary

It is arbitrary, in some sense: Lagrangians are specifications of a physical system in the same way that laws of motion are. Instead of directly describing a trajectory as the solution to some set of differential equations, the Lagrangian approach describes it as a stationary point (an extremum or a saddle point) of the action, which is the integral of the Lagrangian over time. The resulting equations of motion are then given by the Euler-Lagrange equation. L = K - V is (one formulation of) the Lagrangian for a system that obeys Newton's laws. Other systems have other Lagrangians, from which we get other laws of motion.

The other important formulation of classical mechanics is the Hamiltonian one, which very roughly speaking reparameterizes the Euler-Lagrange equation in terms of (generalized) positions and momenta, instead of just position. This turns your n-dimensional second order differential equation into a 2n-dimensional first order one, which is often more convenient to work with.

For simple "ideal billiard balls in a vacuum" situations it makes very little difference what approach you use, but Newtonian mechanics generalizes poorly. All of modern physics is based on the Lagrangian and Hamiltonian approaches.

No. Some of them are simply wrong. For instance:

- action is extremized or at a saddle point, not necessarily minimized

- Action is not quantized in QM (and quantum-mechanical action is not quite the same as classical action). There's another very indirectly related notion of "action" which shows up in historical semiclassical approximations and which is quantized. The author has likely confused the two.

- SU(2) is not the gauge group of the weak interaction, because there is no such thing. A purely weak gauge theory with no EM is not possible, on account of having massive force carriers. The SU(2) and SU(1) in SU(3) x SU(2) x U(1) corresponds to weak isospin and weak hypercharge respectively, not weak charge and (EM) charge.

But even if all the errors were corrected there's a huge amount of missing context. (For instance, the actual content of the standard model Lagrangian - the fact that there are 19 free parameters is in no way sufficient to determine it) And even if you had all of that, a full reduction of macrophysics to microphysics is likely computationally intractable, even in principle.

Just skimmed the EM section: I didn't catch anything egregiously wrong, per se (but again, I only skimmed it), but it's mostly fluff, and the actual physics content that does it exist is targeted at wildly different levels. For instance the author goes from "an electric field is like a tiny arrow attached to every point in space" (day 1 of intro physics for non-physics majors) in chapter 1 to assuming the reader knows what covariant derivatives are (advanced undergraduate) in chapter 2. I would strongly recommend against using these books.

> It's not like the object could move out of the way faster than the speed the light it traveling at (ftl)

It doesn't need to move as far as the light does.

> Shouldn’t physics focus much more on the underlying micro states and micro processes than the emergent phenomena? Obviously there needs to be a transition, but at some point you go from physics to engineering.

1. The boundaries between disciplines are where they are in part by historical accident, and in part because that's what the people working in them find useful - there is no actual fact of the matter.

2. We don't actually know the underlying microprocesses of anything. Effective theories are all we have, and there's no fundamental difference between an effective theory for the vacuum (if it is a vacuum) and one for, say, the bulk of a semiconductor.

> Magnetic fields fall off with the inverse square law.

Inverse cube: the simplest magnets are dipoles.

> It's pretty easy to construct a light bulb with a filament which is hotter than the surface of the sun

The surface of the sun is about 10,000 F, well above the melting point of tungsten. Maybe there's some exotic ceramic that can survive those temperatures, but I'm not aware of any.

> I understand that lambda calculus works with expressions and symbols, while standard function notation works with functions and values

There's no inherent connection. You're perfectly free to interpret lambda terms as functions on a domain, or function definitions as abstract rewrite rules.

> It seems to be some kind of multivariate PCA.

No, UMAP is nonlinear. The general idea is that you generate a neighborhood graph of your data points, do a spectral embedding on that to get your initial result, and then do gradient descent to make its neighborhood graph closer to the high-dimensional one.

> How much mass would need to be collided to suck in Earth?

A significant fraction of the mass of the Earth. Black holes don't "suck" any harder than other objects of the same mass.

Room temperature superconductors would not give us zero-cost energy any time soon. Even if one had a high enough critical current to be used in transmission lines (which is not a given), transmission losses are under 10% in modern grids.

> its great to be excited for real science discoveries but hoaxes are not good,

There's absolutely no evidence of a hoax. The original authors were sloppy and overeager, not malicious.

> They simply aren't particles the way people think of them

They're not anything the way laymen think of them. They're not classical particles, they're not classical waves, they're not classical anything. They're not really probability waves either, for that matter, or even field configurations - the real object is the algebra of observables. But laymen don't get to dictate the vocabulary of physics, and neither do mathematicians. Fields are the things that would be dual to the observable algebra, were it always equipped with a dual; particles are the things whose creation and annihilation operators would generate it, were there only always such things.

> Almost every non-trivial component is bound to have some sort of state, doesn't it?

No, not at all. Any nontrivial component is going to have some sort of conditional rendering, but whether the inputs are supplied explicitly as function arguments or implicitly as state is for the most part orthogonal to what you do with them.

> btw "any other particle" doesn't fall out of EM fields.

I very obviously meant that XYZ-particle states fall out of mode expansions of the XYZ-field, not that all particles are EM quanta.

> what i said is not backwards unless you use the inverse understanding of "exist". and how can photons exist without interaction?

Exactly the same way any other field configuration can? The state space of the free EM field simply is the photon Fock space.

The state space of an interacting 4D EM field is unknown and may well not exist, hence the need for perturbative approaches and renormalization - in which particle states again emerge as terms in the perturbation series.

> The rate of churn is accelerating while nothing really new theory-wise has been added.

There's plenty of novel stuff out there, it just takes a long time to filter down to the mainstream. React hooks are probably the best example here: they're a crude approximation of an algebraic effect system from the early 2000s.

> study some qft

I have. Srednicki and Weinberg are sitting on my bookshelf right now.

> photons dont exist, dude, except in connection with and at the site of the detector.

Exactly backwards.

Photons fall out of mode-expanding asymptotic EM field states just like any other particle. It's the interaction picture that can't be rigorously built up out of particle states.

> Stars eventually wind up as black holes.

The vast majority of stars will end up as white dwarfs. Stars need to be about 10 times the mass of the sun to undergo core collapse, and about 25 solar masses (or more, depending on composition) to form black holes.

> So it stands to reason so would galaxies.

Galaxies are loosely bound clouds of dust with a few stars here and there, relatively speaking; stars are dense roiling balls of plasma. Their dynamics are extremely different.

> So from a classical point of view light travels as a wave but interact as a particle.

And the classical point of view is wrong. Photons resemble classical particles in a few respects, and classical waves in a few others, but at the end of the day they're neither.

> Still the point stands that we never observe light directly but only through its effects on electrons and other charged particles.

This is true of literally everything. "Direct" observation does not exist. Every atom, every cell, every person, every planet, every star - you know them by their effect on your sense-data, or else not at all.

A small sample:

The existence of `any`; worse yet, the use of `any` in the standard library.

Mutable arrays are treated as covariant: the classic `cats : Cat[] ; animals: Animal[] = cats; animals.push(dog);` problem.

Methods are both co- and contravariant in their arguments by default, which is comically wrong. Member variables which are functions, meanwhile, are handled correctly.

`readonly` is a lie:

    const test: {readonly a: number } = {a: 0}
    const test2: {a: number} = test
    test2.a = 5

`Record<string, string>` is actually `Record<string, string | undefined>`. There's no way for an interface to specify that it really does return a value at any string index (e.g. for a map with a default value).

`{...object1, ...object2}` is typed as the intersection `typeof object1 & typeof object2`, which is not correct.

    const a: {a: 5} = {a: 5}
    const b: {a: 4} = {a: 4}

    const spread = <L, R>(l: L, r: R): L & R => ({...l, ...r})
    const impossible: never = spread(a, b)

You have to resort to bizarre conditional type hackery to control when unions distribute and when they don't.

You can constrain generics as `<T extends string>foo(t: T) => ...` but not `<string extends T>foo(t: T) => ...`, which makes many functions (e.g. Array.includes) much too strict about what they accept.

Turing complete type systems are extremely common. C#, C++, Java - it's hard to avoid if you have subtyping and generics. In practice it almost never comes up.