Except that there's nothing in the concept of infinity that is specific to sets, so cardinality is not really relevant unless we're specifically discussing infinite sets. Which we're not. We're discussing the limit of a single value that increases without bound as an input condition approaches a critical value. I'm sure you could rephrase that in terms of set theory, but that doesn't imply a fundamental dependence.

And frankly, if you've hung around Slashdot long you should realize that a rather large percentage of the community doesn't have a really firm grasp of much mathematics beyond basic arithmetic. That doesn't mean they're not interested in the concepts being discussed though, and nothing is gained by belittling either them or those who offer them simplified explanations.

Of course, the "rest stops" with their stockpiles of fuel and parts will probably be massive structures, so we'll also need "tug boats" to transfer the satellites from their original orbit to one that can dock with the rest stop, and then return it to it's designated orbit again after repair and refueling. Still far less energy-intensive than sending up a replacement satellite though. And if only refueling is needed then it's probably easier still to outfit the tug with a refueling waldo that can mate with a standardized fuel receptacle on the satellite - then the tug only has to make a single trip from the rest stop/fuel depo to whatever wonky orbit the satellite is in, and the satellite itself need never move at all.

It's not a number in the normal sense of the term, but using it as such is a simple and convenient shorthand for the far more complex and subtle mathematical concepts being expressed by the statement. In fact it's so radically simplified that even a layperson can kind of vaguely wrap their head around it, while you'll probably need a PhD in mathematics to really understand the underlying concepts.

You seem to be discussing asymptotes, which have a bit more subtle meaning. An asymptote is a line that a function gets infinitely close to without ever touching. Essentially the further you follow the asymptote the more it resembles the graphed function, but they will never be quite the same. 5/x gets two lines because it has two asymptotes: a horizontal asymptote at y=0, since the function gets infinitely close to y=0, but never actually reaches it no matter how large x gets, and a vertical asymptote at x=0 since the function gets infinitely close to x=0, but never actually reaches it no matter how large y gets.

Asymptotes don't themselves have anything to do with division by zero though - for example the well-behaved function x^2/(x^2+1) has a horizontal asymptote at y=1, since the function will get infinitely close to y=1 but never actually reach it, but it doesn't have a vertical asymptote since it's well-defined for all values of x.

Asymptotes don't even have to be aligned to an axis - for example, rather than a horizontal asymptote, the function y=x + 1/x gets a diagonal asymptote at y=x: the function will never quite touch that line, but the further you get from x=0 the closer the two resemble each other.

No, it's very context dependent. The usual way to deal with divide-by-zero and other discontinuities is to use the calculus limit operation, the "creeping up on it" I referred to. You can think of it as looking at a graph and, if the function behaves nicely except at that one point, taking the value that it looks like it should have if there weren't an infinitesimal gap present.

(lim x->0 ... is read as "the limit as x approaches zero of...")

lim x->0 1/x = does not exist (positive or negative infinity, depending on the direction you approach it from)
lim x->0 1/x^2 = +inf (the same from either side)
lim x->0 Ax/Bx = A/B
lim x->0 sin(1/x)/x = does not exist (oscillates smoothly between positive and negative infinity with an infinite frequency)

Ah, thought of one with a definite discontinuity: x/abs(x)
lim x->0+ x/abs(x) = 1
lim x->0- x/abs(x) = -1

Now absolute values may not get used a lot in normal calculations, but you may get the same effect if, for example, you're using square roots and only considering the positive result, as is extremely common in computations since standard data types can't hold an ambiguous value:
i.e. sqrt(x^2) = abs(x), rather than the mathematically correct +/-x

> What is wrong with presenting x/x as "1" at zero? When would that ever cause a problem in an application?

Probably nothing, assuming you've got a special case within your evaluation function that checks for encountering the discontinuity and returns the limit. That doesn't mean your function has a value at that point, only that you can fake it in a consistent manner that, in most applications, will result in a graceful workaround of what, in most contexts, is an annoying mathematical anomaly. But as I said such discontinuities can also be indicative of extreme behavior in the components - if this were a piece of engineering design software for example, hiding the discontinuity might conceivably result in a design with unsuspected vulnerablities.

Also, if you are getting such a well-behaved discontinuity, there's a good chance you could simply rearrange/simplify your equation so that the discontinuity is never encountered at all. E.g. algebraically x/x = 1, so why are you ever performing the division at all?

I hope it's also obvious that that is not something that can be gracefully generalized - without knowing the surrounding function there's no way to estimate what the limit at 0/0 might be (lim x->0 7x/3x = 7/3), or even if it has a limit at all.

How about x / x^2? Approaches -inf from the left, and +inf from the right. I'm afraid I can't think of an example that approaches different definite values offhand, but I remember solving far too many back when I was taking Calculus.

And like I said, yes, if you have a single definite two-sided limit on a discontinuity, then for most practical applications you'll probably be fine using the limit as the actual value. Though there's always the risk that you got that nice well-defined limit due to, for example, two counteracting forces approaching infinity, or counterbalanced resonance responses - in which case your practical application will quite likely rip itself to pieces long before you hit the actual discontinuity in your apparently nice smooth function.

Except that, like NaN (Not a Number), INF propagates meaningfully. Once you get an INF all future calculations using that number can only result in INF or NaN (or possibly 0 after dividing a normal number by INF, depending on the implementation. But that's probably okay).

MAX_INT/MIN_INT do not share that property, they're perfectly normal numbers at the limits of representation. The only sign you get of an error is that you have inconsistent data. If you have an INF or NaN showing up in your results it's pretty obvious that there's an error somewhere. MAX_INT though - do a little math on it and it will no longer be obvious that there was ever an error, especially if your valid data may be approaching the limits of your integer range.
Some specific failure cases:
+INF / +INF = NaN ----- MAX_INT / MAX_INT = 1 (You've just performed an undefined operation that completely removes any ability to make a reasonable approximation, where's the warning?)
+INF * 0 = NaN ----- MAX_INT*0 = 0 (same problem, you've done something that can't even be approximated, and it just disappears?!?)
0.0 / 0.0 = NaN ----- 0 / 0 = ??? (again, a completely undefined operation, what should you do?)
+INF / 7 = +INF ----- MAX_INT / 7 = some perfectly normal number (really!?!)
+INF + 1 = +INF ----- MAX_INT + 1 = MIN_INT (getting into some pretty esoteric theoretical mathematics to justify that...)

I agree it would be nice if there were a way to represent +INF, -INF, and NaN in integers, but doing so would greatly complicate integer calculations, which are extremely straightforward in silicon (well, division is a *little* complicated, but not remotely as complicated as floating point addition). And without silicon-level support you'd need to add branching conditionals to EVERY integer calculation, completely killing performance, as well as disrupting lots of traditional integer exploits such as rollover, bitwise operations, and others that are widely deployed as dramatically performance-boosting hacks.

>1/0 is indeed infinity.

Is it? 1/+0 = +inf, but 1/-0 = -inf, VERY different results (consider the graph of 1/x where x varies from -1 to +1). And dividing by "neutral zero" should thus be either both or neither, an impossible situation, hence it MUST be undefined. (unless you're assuming a number system where +inf=-inf, but that's getting rather esoteric)

And if you're taking limits as you approach a discontinuity, 0/0 may well be perfectly well behaved. Consider x/x - it equals 1 at all points *except* x=0, so it could be considered reasonable to consider it to equal 1 when x=0 as well. Of course as 2x/x remains constant at 2, so there can't be any general "solution" to 0/0

I was waiting for this one...

>Does the fact that x/0 mean that it is not solvable?

Yes. Yes it does.

In the most trivial simplification x/0 will be either positive or negative infinity, depending on the sign of x. If x=0 then we can't even say that much.

It's not a matter of "we haven't figured out how to wrap it up nice and neat", it's "We've tried to wrap it up nice and neat, but determined that the behavior is *extremely* context-sensitive and provably CAN'T be wrapped up". If a function has a discontinuity in the form 0/0 then you can "creep up" on it, evaluating the function at smaller and smaller distances from the discontinuity, and depending on the *exact* details the function may approach negative infinity, positive infinity, 1, 2, -237.428, or *any* other value. Or it may not approach any value at all - some functions will have a different value depending on whether you're creeping up from the left or the right, and some will even begin oscillating wildly with a frequency approaching infinity as they approach the discontinuity, so that it's not possible to get *any* approximate answer.

THAT is what is generally meant when a mathematician says an operation is undefined. Not that we don't understand it, but that we DO understand it, and no general answer is possible.

It's a very different situation from Sqrt(-1), which had provably consistent behavior [ sqrt(-1)^2 = -1 ] but simply couldn't be represented on the standard number line, requiring expanding to a two-dimensional complex number system in order to represent its behavior.

>0/0 is undefined, but f(y)/f(x) where f(x)=0 isn't necessarily undefined.

Yes, it really is. You *may* be able to determine a definite value for the *limit* of f(x)/g(x) where g(x)->0, and that may be a useful and meaningful value, depending on context. But that doesn't mean that there isn't a discontinuity in your function, only that the discontinuity *might* not be relevant in practical applications. And there are of course also plenty of functions where the limit as you approach the discontinuity is different depending on whether you approach it from the positive or negative direction.

>Shouldn't be too hard...

Careful there, you're oversimplifying things and are going to confuse some poor sod. Not only do you have an infinite number of special cases to consider in which 0/0 has a function-specific definite value in the limit, you ALSO have an infinite number of discontinuous functions where 0/0 has a different value in the limit depending on whether you approach the limit from the positive or negative direction, and there is thus NO reasonable "approximation" to be offered.

Also, you've got a math error:
lim x->0 x^2/x = lim x->0 2x/1 = 0

Hmm, how about the fact that I and my friends personally remember many of the events happening at the time?

Oh no!!! I just realized my own memory must be in on the conspiracy! This is so much worse than I ever imagined! Or is it? Maybe this isn't the first time I've realized this - if my memory is in on it then it could simply refuse to recall any previous realizations... Thanks a lot, I can't trust anything now!

Wait, what was I talking about? Oh well, can't have been too important. If you'll excuse me I'm off to watch funny cat videos. Those things won't laugh at themselves after all.