Straw

In the theoretical section, they extrapolate assuming a polynomial from 40 to thousands of dimensions. Why do they trust a polynomial fit to extrapolate two orders of magnitude? Why do we even think it's polynomial instead of exponential in the first place? Most things like this increase exponentially with dimension.

In fact, I think we can do it in d=2k dimensions, if we're willing to have arbitrarily precise query vectors.

Embed our points as (sin(theta), cos(theta), sin(2 x theta), cos(2 x theta)..., sin(k x theta), cos(k x theta)), with theta uniformly spaced around the circle, and we should be able to select any k of them.

Using a few more dimensions we can then ease the precision requirements on the query.

They are pitching co-located PV, and they already have a system to move the heat inside the pile of dirt!

If you want heat, why bother converting sunlight to electricity first? You lose 80%. Is it that much more expensive to use mirrors to concentrate sunlight and capture near-100% of the energy as heat?

If you don't include rent, real estate has significantly underperformed equities as an investment:

https://www.frbsf.org/wp-content/uploads/wp2017-25.pdf

I broadly agree with you, but there is really a point here about land ownership.

Although developments of the land do improve the value, and thus land ownership has significant utility economically by incentivizing this, there isn't really an economic justification for the owner receiving value for the land itself- why should someone have exclusive rights to a piece of land they didn't create? They bought it, sure, but why did the previous owner have perpetual exclusive rights?

I'd advocate for a small property tax as a replacement for other taxes, because the component that does tax "land value" won't cause economic harm, but all of income tax causes deadweight loss. (Note, Land Value Tax is great in theory, but impossible to define practically- property tax good enough, much harder to game!)

Note that in practice, the biggest abuser of land hoarding is local governments with extremely restrictive zoning that stops productive development of the land- from an economic perspective they own the land, and have sold (or in reality, seized) some but not all of the rights from the 'landowner'. Although this can have advantages to help with coordination problems, in practice it's caused enormous economic damage to many cities by preventing development. At its heart, it's a problem with land hoarding.

It's because going from 1 to 2 changes the expected worst case load from an asymptotic log to an asymptotic log log, and further increases just change a constant.

See https://en.wikipedia.org/wiki/Balls_into_bins_problem

I think the parent meant that R6RS has `syntax-rules`, which has enough power to implement CL `defmacro` as well as `syntax-case`.

If you criminalize hiding your mental illness, you can be sure that people will hide it! Even if the alternative has some money attached.

I'd much rather have a mentally ill person with treatment flying the plane than without!

You don't get to choose "no mental illness" because of the bad incentives of hiding them!

Good catch, thank you!

One can generalize this to k missing numbers the same way as we typically do for the addition case by using finite fields:

XOR is equivalent to addition over the finite field F_2^m. So, in this field, we're calculating the sum. If we have two numbers missing, we calculate the sum and sum of squares, so we know:

x + y

x^2 + y^2

From which we can solve for x and y. (Note all the multiplications are Galois Field multiplications, not integer!)

Similarly for k numbers we calculate sums of higher powers and get a higher order polynomial equation that gives our answer. Of course, the same solution works over the integers and I'd imagine modular arithmetic as well (I haven't checked though).

sqrt(2), and pretty much everything else you can think if, is computable- there's a program that can output rational numbers arbitrarily close.

BB(n) is not.

It likely comes from the smallest machine that someone has been able to construct that can diagonalize over all proofs in ZFC, or something similar.

To downvoters:

I'm well aware that BB(748) is an integer definable in classical logic. My claim is that "integer definable in classical logic" does not actually correspond well to what people mean by "number" in almost any other setting when pushed to extremes such as this.

Don't you want the weakest (ie makes the fewest assumptions) theory that works?

Yes, I would say that neither is really a number in the traditional sense of the word, nor in constructive analysis.

You say the busy beaver function is a function. But I can claim it's not, because you cannot make it constructively- in constructive analysis, all functions are computable.

Many other numbers and functions are computable, including e, pi, 10^100, etc- these are fundamentally different than BB.

So in what sense is it actually a number? There is no algorithm which can resolve questions such as BB(748) < x given x. That doesn't seem like a number to me!

In fact, for some x, such questions will depend on the consistency of ZFC. All normal math we do is expressible in ZFC, but by incompleteness, ZFC cannot prove it's own consistency or is inconsistent. So, we cannot really ever know the value, we can only ever find lower bounds. Does this seem like a number to you? It's not in the English sense and neither is it in what I would consider a reasonable definition of numbers you actually encounter, the computable numbers. Real numbers are in fact, not very real at all.

Sure, if someone just gives you the number, ZFC can represent it. But ZFC cannot prove that the value is correct, so how do you know you have the right number? Use a stronger proof system? Go a bit bigger and same issue.

The category error is in thinking that BB(748) is in fact, a number. It's merely a mathematical concept.

Yes, that's right, dividing by that ratio essentially barely affects the number in a sense that 'adjacent' numbers in that notation give a much bigger change.

10↑↑10,000,000 / (sand grains per universe) is vastly larger than, say, 10↑↑9,999,999

So on system we're using to write these numbers, there's really no better way to write (very big)/ (only universally big) than by writing exactly that, and then in the notation for very big, it pretty much rounds to just (very big).

You can do all of these in terms of matmul to some extent:

Solving AX=B can be done with Newton's method to invert A, which boils down to matmuls.

Matrix exponential is normally done with matmuls- the scale down, Taylor/Pade and square approach.

Why do you need Cholesky? It's typically a means to an end, and when matmul is your primitive, you reach for it much less often.

Eigendecomposition is hard. If we limit ourselves to symmetric, we could use a blocked Jacobi algorithm where we run a non-matmul Jacobi to do 128x128 off-diagonal blocks and then use the matmul unit to apply to the whole matrix- for large enough matrices, still bottlenecked on matmul.

SVD we can get from Polar decomposition, which has purely-matmul iterations, and symmetric eigendecomposition.

One does have to watch out for numerical stability and precision very carefully when doing all these!

AZ uses a known transition model. I wouldn't call this model-based, because when people say model-based they usually mean learning a world model.

MuZero doesn't actually learn a state transition function- it only models reward. It's a model that predicts reward given an action sequence. I suppose we could consider this a hybrid that's slightly model based because it does have an incentive to learn what's going on. But there's no feedback where we predict future world states and feed that back in.

Its simpler than that- if you always play what you believe is optimal, you will never explore strategies that may in fact perform better.

This post mischaracterizes AlphaZero/MuZero.

AlphaZero/MuZero are not model based, and aren't on policy either. They train at a significantly higher temperature, and thus intentional suboptimal play, than they use when playing to win. LeelaChessZero has further improvements to reduce the bias on training on suboptimal play.

There's a well known tradeoff in TD learning based on how many steps ahead you look- 1-step TD converges off policy, but can give you total nonsense/high bias when your Q function isn't trained. Many-step can't give you nonsense because it scores based on the real result, but that real result came from suboptimal play so your own off-policyness biases the results, plus it's higher variance. It's not hard to adjust between these two in AlphaZero training as you progress to minimize overall bias/variance. (As in, AlphaZero can easily do this- I'm not saying the tuning of the schedule of how to do it is easy!)

You might find it interesting to know that in the mid 1800s, in the UK, during a 10-year period, private investment in railways totaled 40% of GDP- an average of 4% per year. For comparison, the Apollo program was <0.5% of GDP.

The list of enormously valuable privately developed technologies goes on and on- in fact, almost all technologies. Many of these developed in the 1800s and early 1900s when there was very little government spending on research/etc. For example, oil, railways, cars, etc.

Even in cases where government research did help, often the practical realization takes a lot of money!

P.S. Companies are not necessarily collectives. It depends on the ownership structure.

I'm looking forward to seeing your results!

Here are corresponding results for LCGs, interestingly there's a clear affine relationship between state size and log(bytes to practrand failure).

https://www.pcg-random.org/posts/does-it-beat-the-minimal-st...

I'd be very interested to see a state-size capacity analysis in the style of PCG- if you make cut down versions of your generator with reduced state size, say by reducing the word size of all three words of state, how low can you go while still passing PractRand/BigCrush? This gives a much better idea of how "close" to danger you are than simply passing.

Basically any generator with a 192 bit state can pass BigCrush/PranctRand- even known terrible ones like middle square!

https://www.pcg-random.org/posts/too-big-to-fail.html

I understand that, my claim is that you'd get false negatives- people who aren't laptop farm users but don't know the color of their front door and aren't at home to check.

Why does knowing your front door color have anything to do with hiring? You might just be someone who's very focused on things, so much so that you ignore the environment around you to focus!

Lisp macros allow a general solution to this that doesn't just handle chained collection operators but allows you to decide the order in which you write any chain of calls.

For example, we can write: (foo (bar (baz x))) as (-> x baz bar foo)

If there are additional arguments, we can accommodate those too: (sin (* x pi) as (-> x (* pi) sin)

Where expression so far gets inserted as the first argument to any form. If you want it inserted as the last argument, you can use ->> instead:

(filter positive? (map sin x)) as (->> x (map sin) (filter positive?))

You can also get full control of where to place the previous expression using as->.

Full details at https://clojure.org/guides/threading_macros