1/0 = 0 (2018)

Original Article ↗ Hacker News Discussion ↗

Mathematical perspectives on 1/0

  • Many argue that in standard real analysis 1/0 is simply undefined; defining it as 0 (or anything) breaks the usual notion of division as multiplicative inverse.
  • Others stress that division is a defined operation on a given structure, not sacred: you can define a “division-like” operator with 1/0 = 0, as long as you accept giving up some familiar field properties.
  • Several examples are mentioned where similar “convenient extensions” are common (e.g., 0^0 = 1 in combinatorics, conditional probability terms defined as 0·P(A|B) for P(B)=0).
  • Some note there are other algebraic systems (rings, finite fields, wheels, extended/projective reals, hyperreals) where “division” or infinity is handled differently, reinforcing that context matters.

Limits, infinity, and undefinedness

  • A recurring objection: since lim(1/x) as x→0⁺ is +∞ and as x→0⁻ is −∞, any single value at x=0 (including 0 or ∞) fails to match limit behavior; hence undefined is most faithful.
  • Some emphasize that infinity is not a real number; limits don’t literally “reach” ∞, they just diverge.
  • Others counter that many mathematical frameworks do treat infinities as values; conflicts only arise if you naively assume identities like ∞−∞=0.

Programming-language behavior & trade-offs

  • For floats, IEEE 754 behavior (x/0 → ±∞, 0/0 → NaN) is defended as useful: errors propagate and are easy to detect.
  • For ints, many languages either throw, trap, or wrap; some languages (Pony, Gleam, uxn, certain ISAs) define x/0 = 0 or a max value to avoid crashes and keep results in-type.
  • Critics argue 1/0=0 masks bugs and can silently corrupt business/financial or physical calculations; they strongly prefer crashes or explicit errors.
  • Supporters reply that crashes in production are often worse; returning 0 can be “good enough” in many domains (e.g., empty-average cases) and avoids pervasive error handling.
  • Several suggest better defaults: exceptions by default, with explicit “unsafe” or saturating/modular operators as opt-in.

Type systems and safer APIs

  • Ideas raised:
    • Use result types (error/option/NaN/NULL) for division.
    • Use non-zero numeric types so division can be total.
    • Use refinement types/static analysis to rule out zero divisors.

Intuition, notation, and expectations

  • Many feel 1/0=0 is deeply unintuitive: as denominators shrink, quotients blow up, not shrink.
  • Some argue reusing “/” for a non-inverse operation is misleading; a different symbol or name would reduce confusion.
  • Overall, commenters see the choice (undefined, ∞, 0, NaN/NULL) as context- and goal-dependent: mathematical cleanliness vs. ergonomic, failure-tolerant software.