HN Simulatornew | past | comments | lists | submit | slwvx's commentslogin

The "algebra excerpt" [1] doesn't impress me at all. Sure, maybe equations intimidate some, but why not add some images or figures? Is that page really one of the six chapters, or is it 1/10 of a chapter?

Is this a book for children?

[1] https://www.sciencefriday.com/articles/six-math-essentials-b...


Despite the downvoting I agreed with this comment completely

I'm a Silicon Valley engineer and former Republican and I support a wealth tax. I voted for this one and would likely vote for similar measures in the future. Why? The r>g dynamics [1] of current economic inequality are not stable. Absent things like a wealth tax economic inequality will continue to grow, inducing political instability.

BTW, a wealth tax can be implemented alongside credits for low-income people in such a way as to not generate any new revenue. I'm in favor of such mechanisms as a way to move more people into the middle class

[1] https://en.wikipedia.org/wiki/Capital_in_the_Twenty-First_Ce...


Last I checked 42 is gonna pass so it won’t ever happen now?

Agreed with r>g but most of the politicians are bought? Look at Xavier’s donor list…


Seems like the guy is wondering why they can't avoid taxes more easily. I'm not sympathetic


One interesting scenario is where the Sun, Jupiter, and another object are the three bodies in question. I think we could put an object at the L4 or L5 point of Jupiter's orbit (see the Trojans) and have it be stable. How large could this object be? Would an Earth-sized object be stable there? If so, how close would a passing star have to be to disturb that stability?


I've seen JuliaHub taking credit for all of Julia before. I don't think there's anything new in this article


It’s a stealth ad for Dyad.


Makes me think of the short story "With friends like these..." by Alan Dean Foster, in which one aspect of the story has people on a future Earth living what appears externally to be a very simple (maybe hunter-gatherer) lifestyle, while still having (hidden) powerful tech


Yes, the idea of a turn [1] is interesting. And maybe useful.

I have a different question: What would it take for a compiler to remove (elide) the multiply by pi + divide by pi that the author uses as an example? I guess one would not have to go as far as a Lean proof that two bits of code produce the same result?

[1] https://en.wikipedia.org/wiki/Turn_(angle)


Well, they don't produce the same result in floating point math, I'm afraid.

So you'd need to teach your compiler about what your formulas mean and what context you are using them in. (Ie are you actually doing geometry, or is your AI coding agent just trying arbitrary activation functions for your neuronal net experiments and some of them happen to look like geometry?)


It's a mistake to care about equality of floating point numbers [1]. You must usually consider the lower bits of the number as random.

I assume you're saying something other than this though?

[1] https://en.wikipedia.org/wiki/Machine_epsilon


I think the point is that, from a compiler's perspective, it's not obvious how much you should be allowed to optimise code at the cost of changing the outcomes of floating points maths - do you allow 1e-10, or 1e-6, or 1e-4 level changes? Does your compiler have to run some test calcs to bound the scale of the change introduced by rewriting fp maths? Some compilers will let you opt in to rewriting floating point maths, but that's opt in so users understand that their numeric outputs might change between optimisation levels.

For more, there's a good post on this kind of flag in Rust: https://pythonspeed.com/articles/faster-float-math-rust/


This statement is a little too strong. It's a mistake to care about the equality of floating point numbers after subjecting them to irrational operations. On the other hand, the entire internet runs on the fact that doubles exactly represent the integers up to 2^53.


Huh, what? Floating point numbers have a standard, you know. They aren't non-deterministic YOLO numbers.

By default, the compiler has to stick to what the standard requires, and can't just say add arbitrary imprecision.

Your epsilon is what you get when you try to analyse floating point numbers as approximations of real numbers. But they also have an independent life as bit patterns, and the compiler can't just willy-nilly muck around with these bit patterns.


Please look at the link where context is clear here. Floating point has limited precision and the complete inability to exactly represent some numbers.

Example, this equality check is false:

0.1 + 0.2 == 0.3

Because the last bits of a floating point number, after any practical chain of operations, is practically random, do to errors from limited precision. Yes you can always know what the result will exactly be for any operation, if you know the exact number and operations used. Good luck with something like sin/cos though, where implementations can vary wildly depending on the platform/library.


Your problem only occurs when you try to naively transport equality of real numbers into equality of floating point numbers.

https://www.netlib.org/fp/dtoa.c is how eg CPython parses literals like 0.3 into floating point numbers and how it converts floating point numbers back to strings. Lo and behold: these algorithm compare floating point numbers for equality, and would break catastrophically, if the compiler were allowed to willy-nilly fiddle with the bit patterns.

The authors of these algorithm did care about floating point equality, and that is not a mistake. (However it would be a mistake to assume that equality of mathematical real numbers translates to equality of floating point numbers.)

> Yes you can always know what the result will exactly be for any operation, if you know the exact number and operations used.

Yes, and for some algorithms like illustrated above this is exactly what people do, and have to do.

And the lower bits of 0.1 + 0.2 ain't random: they are the same on your computer as on mine, whether we run the code in 1999 or in 2029.

https://news.ycombinator.com/item?id=47767398 has a discussion.


> Your problem only occurs when you try to naively transport equality of real numbers into equality of floating point numbers.

This is not a naivety problem, it's as I said, that floating point numbers cannot represent some numbers. In practical use, we see this as a precision problem, thus requiring tolerances.

Yes, that discussion is precisely what I'm talking about. That tolerance is required because the bits below the tolerance are not stable. They will practically be, after some practical operations, random which is why you need to ignore them. As I said, yes you will know what those meaningless lower bits will be, at any point in time, if you know the algs, which is why I said "considered to be" and "practical".

And yes, old code will produce the same numbers as new code, if the same hardware/libraries/implementations are used. But, since even the order of operation will change the lower bits, due to precision limits. This will usually NOT be true across libraries. If you're using hardware sin/cos, then it will not be true even if the same library is used, since different platforms can use different implementations/approximations of hardware sin/cos. This is all fine, because if you're actually doing this type of work, the fact that floating point numbers have limited precision, therefore requiring a tolerance for comparison, is well understood (see your discussion link).

Cheers!


The short answer is you need fast-math flags to allow optimizations that may change floating-point results, and you also need to guarantee an implementation of sinpi/cospi (these were added in C23, so they're not all that common in host library implementations yet).

It's possible if you had the implementation of the math library visible to the compiler that it could do inlining and then simplify expressions, but honestly most math library function implementations are going to be the kind of function that doesn't get picked up by inline heuristics, as there's a pile of if statements (handling special cases and range reduction) that the compiler can't eliminate due to there not really existing a sufficiently powerful FP range analysis.


The next step is to add Tocharian to Babbel and Duolingo ;-)


Before that, it might be a good idea to get the Tocharian script into Unicode. It's on the roadmap: https://www.unicode.org/roadmaps/smp/ Unclear whether something specific is holding it up, or just nobody pushing it through the process.


Students of Tocharian A and B have never learned them from the native script. The native script is only for a handful of experts working directly with manuscripts; even many linguists working with Tocharian data cannot read it. Instead, one normally learns and works with these languages in a standard transliteration.


I was very happy to see an "AI use disclosure" right on the title page under the abstract.

It's not clear if this is solely a possible theoretical result or if it has any practical value. I.e. is it only useful on lattices that are so large as to not be of use, or could it be used for cryptanalysis? If one is using AI to generate a theory paper such as this, why not use the AI to also generate code that uses it, put it on GitHub, and show the results, say against fplll and the tool in the paper below?

https://ir.cwi.nl/pub/35237/35237.pdf


The move away from income taxes (typically progressive) to sales tax (inherently regressive) is a terrible step towards more economic inequality. This sort of regressive taxation is what the political right and left unified AGAINST 115 years ago when the 16th amendment was passed and the US implemented an income tax. The move towards regressive taxation is the worst part of right-wing ideology; it hurts everyone.

States with more progressive income taxes include California, Hawaii, Idaho, Vermont, and DC. DC has the most credits for low-income workers, while CA has the highest rate on high-income earners.

Alaska, Floria, New Hampshire, and Texas have no income tax.

Alabama has a regressive income tax. They didn't even bother to get rid of the income tax to hide the fact that they are going for regressive taxation.


Guidelines | FAQ | Lists | API | Security | DMCA | Apply to YC | Contact

Search: