Hacker News Reader

Hacker News

Comment by fatneckbeard | Hacker News Reader

Full thread

fatneckbeard

interesting that matrices are a kind of data structure in mathematics that has so many 'invalid' operations.

in the integers basically the only thing you can do to break arithmetic is 'divide by 0'

in matrices there are a lot more ways to do something resulting in an error.

there are ways to reimagine integers so that divide by zero is not an error. they are esoteric but they exist.

i wonder if they have done this for the matrix?

View on HN

I think the key here is that matrices are a "higher-kinded" data structure. That is, they're parameterized not only by the shape (number of rows and columns) but also by the type of the elements themselves. Furthermore, the elements of a matrix need not be plain numbers (such as plain integers or floats) but can themselves be elements of any sort of ring, such as polynomials or even elements of a quotient ring.

Now, you may think a matrix whose elements are polynomials with coefficients that are integers modulo some prime p with the polynomial ring itself quotiented by some irreducible polynomial might be too bizarre and esoteric to be useful but in fact these structures do see a lot of use in cryptography.

"for matrix multiplication, even in relatively simple cases, every step can present more than 10^12 options." [1] Not sure if valid, but it's worth considering: what if we don't have the best matmul algorithm yet.

[1] https://www.quantamagazine.org/ai-reveals-new-possibilities-...

In mathematics, operations are basically sets. The fact that `n/0` is not defined... doesn't really make 0 or division special, so I don't suppose that anybody has seriously worked on that.

It's very different in programming, of course.

Seriously worked on what?

On what the GP was asking, i.e. giving a meaning to matrix operations that are not defined.

This is correct as long as you restrict your point of view only to sets. Even in pure mathematics one is usually interested in sets with additional structures. For instance, even though one speaks of the "set of real numbers" one usually implies that there is extra structure. In particular one usually requires that this set has operations "addition" and "multiplication" that make this set a ring. Then zero is the neutral element of addition and the annihilator of multiplication, so very special indeed!

Operations are just sets :)

See the pseudoinverse: https://en.wikipedia.org/wiki/Moore–Penrose_inverse.

> basically the only thing

There is also the overflow which is even more nasty than the zero-divide, because often it goes unnoticed.

One of the many problems you get from assuming that floating point "numbers" are a field (or ring for ints), when they aren't even associative, let alone commutative. I hope in 100 years we have a practical representation for the reals without all these slings and arrows. Floats are more-or-less the best minimal message length encoding if you have no prior information, but I think there could be better encodings for most purposes, especially to prohibit many cases of numerical issues.

Interesting thought! Does a rational representation do any better by field standards? https://iquilezles.org/articles/floatingbar/

What would it take to have a practical representation that’s better? I’m not well versed in the fields and rings theories in math, but it seems like the fundamental problem here is that floats have a finite number of bits, which means they are forced to round the results. That rounding is what causes a very large portion of all the trouble, it is what breaks associativity & commutativity. Since there is no practical way to have an unlimited number of bits, I wonder if a practical field of floats cannot exist in general?

I know rational representations (with bignums) can work better for some purposes (albeit not high-perf numerical ones), but the rub is, like you say, you're trying to represent an uncountably infinite set with finite memory, so everything is going to be some kind of space/time/fidelity tradeoff.

The only concrete finite fields are the finite fields of size p^k, where p is prime. I'm kind of thinking that there must be some representations that at least can shove off the breaking of associativity, commutativity, etc more into the background. It's probably more of a computer science and usability problem, but hopefully backed up by enough theory to provide some guarantees.

You can make a "free" field as a programming interface (like in the OP) - and the floats would then be a leaky implementation of that interface. I think the question is how to make an implementation that better captures what we talk about when we talk about real numbers, while having good enough performance for big numerical tasks, and avoiding common numerical problems. Definitely not easy, and I think application dependent to a great extent - a place where one really has to be able to glide up and down levels of abstraction.

The thing about floating point numbers is that while they're not associative... they are approximately associative (mod inf and nan). In other words (ab)c = a(bc) + e where e is is a number much smaller than max(a,b,c). This means that we can measure quite easily how bad an operation is in floating points, using what's called the condition number, and there are many many good ways of either estimating or bounding the condition number. So floating point numbers are easy to analyze, though they require a bit more machinery than most programmers get in intro to computer science. Really floats are the right way to do calculations involving reals on the computer. Of course, if you're not actually using reals, you shouldn't use them!

Yeah the condition number helps in simple cases (or when solving single linear systems), but things rapidly spiral once you start getting into solving stiff ODEs, etc - to the point that only numerical specialists can judge it. I feel like there ought to be ways of dealing with these issues in a more fine-grained manner with better guardrails - something like a numeric-aware typesystem or automatic algorithmic scheme generator. Like I said though, maybe in 100 years.

stiffness has nothing to do with fp numbers... stiff equations are just as hard to solve using arbitrary precision bigints since the issue is the limits of approximations of the integral.

That's getting back to my point though - the integral is over measurable sets of reals, and we are approximating that with finite-difference floats. This is a complex problem with many guises.

there is no practical representation of the reals because their theory is based on infinite numbers and computers are finite.

aka you are never going to store sqrt 2 in a register.

the closest you can get is symbolic algebra packages. but at the end you still have to come down from infinite land and actually have an ASCII decimal representation because you cannot cut a board at sqrt2 feet long or fill your car with sqrt2 gallons of gasoline. or pay pi dollars for a pizza and expect your bank to keep a list of all the different transcendental atomic values you have used for payments over the years. "Your account has 17 pi plus 45 sqrt2 plus 97 e minus the golden ratio" is never going to work very well.

one thing that i think would help is to put non-real mathematics into the mathematics curriculum and stop handwaving about how a computer does real numbers.. (it doesnt). teach discrete math, modular arithmetic, prime number theory, at the same time as pre-calculus.

Reply on news.ycombinator.com