Hacker News Reader

Comment by TrianguloY | Hacker News Reader

I've always wondered what would happen if we defined /0 as a new symbol, for example 'z'. The same as we define sqrt(-1) as 'i'. So if you can do 4*sqrt(-1)=4i, you could also do 4/0 = 4z. These two seems similar, as in taking something that should not exist, and just letting it exists in a totally different and orthogonal domain.

I tried once to investigate the implications, but it quickly became far more complex that with 'i' and never went far. Still intrigued if this is somewhat interesting or a total time loss though.

View on HN

You might want to look into wheels (https://en.wikipedia.org/wiki/Wheel_theory).

It's just a waste of time. The reason no value is conventionally assigned for division by zero is that assigning a consistent value doesn't help. When you want a value for that kind of expression at all, you'll want different values in different expressions.

In SQL, if you divide by zero, you get a NULL. If you divide by NULL, you get NULL (any operation involving a NULL yields NULL, even GROUP BY). I call it "a black hole zero", if it touches anything, that thing becomes a black hole zero.

Some languages will wrap division by zero in a special type, a NaN (not a number). You can then reason on top if that NaN if you want to.

So, in a sense, there are some people already doing practical stuff with substituting /0 for a new symbol.

Does it? Under SQL standard or what engine? At least Postgres raises when dividing by zero.

You're right about division by zero. From SQL92:

         4) The dyadic arithmetic operators <plus sign>, <minus sign>, <as-
            terisk>, and <solidus> (+, -, *, and /, respectively) specify
            addition, subtraction, multiplication, and division, respec-
            tively. If the value of a divisor is zero, then an exception
            condition is raised: data exception-division by zero.

However, the "any operation involving NULL yields NULL" is standard:

         1) If the value of any <numeric primary> simply contained in a
            <numeric value expression> is the null value, then the result of
            the <numeric value expression> is the null value.

https://www.contrib.andrew.cmu.edu/~shadow/sql/sql1992.txt

So, dividing by NULL is allowed and yields NULL. Dividing by zero yielding NULL is non-standard (I used it though).

This is, in some sense, calculus. Look at 0z, which is 0/0, which calculus treats with l'hopitals rule. Another way of looking at it is to say that 0 is dt, then z is 1/dt. Clearly we can have different 0s, so we might name another dx, then take dx/dt, which is an arbitrary derivative.

You might be interested in the hyperreal numbers, which sound a bit like the avenue you were exploring.

You can't divide by zero in the hyperreals any more than you can in the reals.

Since you are composing by multiplication, you can use this symbol: ∞

1,000,000 grains of sand is a heap of sand (Premise 1) A heap of sand minus one grain is still a heap. (Premise 2) - https://en.wikipedia.org/wiki/Sorites_paradox

So one grain of sand is a heap and then when you remove that grain the heap disappears, but you only removed one grain from a heap so this is impossible because it is discontinuous. One solution is to wrap the problem in fuzzy logic with a 'heapness' measure.

Generalizing this type of solution we have a practice of wrapping paradoxes in other forms of logic. You would define an interface between these logics. For example in Trits (0,1,UNKNOWN) you could define an interface where you can change the type of NOT-UNKNOWN from Trit to Boolean. This would return at least some part of the entropy to the original domain, preserving a continuity. Wave Function Collapse is another example of translating from one logical domain to another.

Reply on news.ycombinator.com