Random Hacks: Haskell: What happens when you divide infinity by 2?

"Haskell: What happens when you divide infinity by 2?" by alex

Mon, 11 Jun 2007 15:43:47 +0000

Some professor wrote about something called transreal arithmetic. From what I understant it incorporates infinity and 1/0 as part of the numbering system.

http://spiedl.aip.org/getabs/servlet/GetabsServlet?prog=normal&id=PSISDG006499000001649902000001&idtype=cvips&gifs=yes

"Haskell: What happens when you divide infinity by 2?" by null

Sat, 10 Feb 2007 05:57:47 +0000

when you have a formal infinity, 1/infinity becomes an infinitesimal number, so you can develop non-standard analysis.

"Haskell: What happens when you divide infinity by 2?" by muppt

Sat, 10 Feb 2007 05:51:44 +0000

you can also add a -Infinity, and it’ll still be compatible with Peano axioms.

"Haskell: What happens when you divide infinity by 2?" by Eric Kidd

Thu, 08 Feb 2007 20:51:02 +0000

A caution: I’m still studying the paper by Fokkinga and Meijer. And as I work through various sections, I’m increasingly convinced that my understanding of some of the ideas is still pretty dodgy.

So please don’t take anything in the previous comment too seriously unless somebody with a better grounding in category theory confirms it!

"Haskell: What happens when you divide infinity by 2?" by Eric Kidd

Sat, 03 Feb 2007 19:22:24 +0000

Mikael Johansson: I do, alas, not, however, know how this compares to the category CPO you’re asking about…

Well, the Peano arithmetic is related to the functor K₁+Id. This gives us the F-algebra 1+a → a, which is basically any type of the form:

In a strict language (like ML), this could only represent a finite data structure. After all, every value of type T must ultimately end in an A.

Traditionally, we would need to use streams to represent an infinite data structure. In our case, that would give us the final F-coalgebra a → 1+a. In a hypothetical programming language, we might write it:

codata T = A | B T -- Not Haskell!

Basically, instead of having the ability to build a structure using A or B, we’re given a data structure and allowed to pick off one B at a time until we hit an A. It could go on for ever.

Now in the category Set, the F-algebra 1+a → a and the F-coalgebra a → 1+a are different beasts. This means that you can declare the Peano numbers without having to deal with infinity.

But Haskell is a lazy language. As the famous example shows, a Haskell list can be infinity long:

Now, according to Fokkinga and Meijer, there’s actually some pretty deep math lurking here. Apparently, Haskell’s lazy evaluation moves us from category Set to category CPO, where our initial F-algebras and our final F-coalgebras turn out to be the same!

Anyway, here’s the bit in Danielsson et al. which inspired this entire post:

To be concrete, let us assume that the natural number data type Nat is defined in the usual way,

Note that this type contains many properly partial values that do not correspond to any natural number, and also a total but infinite value.

The “total but infinite value” appears above as infinity. One of the partial values turned up when patchwork tried to compute subtract infinity infinity over on reddit.

"Haskell: What happens when you divide infinity by 2?" by Jim Apple

Sat, 03 Feb 2007 15:35:04 +0000

I posted my reply at http://japple.blogspot.com/2007/02/countable-ordinals-in-haskell.html

Summary: I think we should represent countable ordinals as the limits of increasing functions from the naturals to the countable ordinals.

"Haskell: What happens when you divide infinity by 2?" by Mikael Johansson

Sat, 03 Feb 2007 13:26:30 +0000

First off, your implementation of infinity is probably among the saner possible with a Peano arithmetic. At least for the infinity Aleph-0.

I do, alas, not, however, know how this compares to the category CPO you’re asking about; I would, however, suppose that it is a sane way to do it.

You could also have done infinity as

data CompleteNumbers = Number Numbertype | Infinity

or as

data CompleteNumbers = Number Numbertype | Infinity | NInfinity

with the corresponding extensions to Ord and Num implemented specificially. Especially the one-point compactification of R (or … well … machine-R) you’ll find as

data CompactR = (Real a) => Finite a | Infinity

with the correspondingly defined instantiation of Num and Ord.

"Haskell: What happens when you divide infinity by 2?" by Alan Manuel Gloria

Sat, 03 Feb 2007 09:53:20 +0000

I once thought up of a way of doing the Grand Hotel in Haskell, by using an infinite list:

infinityHotel = iterate (+1) 1

So the Grand Hotel is full already. Let’s say number one’s brother decides to check in:

1:infinityHotel

Suppose instead that an infinite number of zero’s decides to check in:

zeroes = repeat 0

Which we enter into the hotel as:

foldr1 (++) (zipWith (:) infinityhotel
                         (map (:[]) zeroes))

Haskell: What happens when you divide infinity by 2?

Eric Kidd — Fri, 02 Feb 2007 22:00:00 +0000

Sometime back in elementary school, I first asked teachers, “What happens when you divide infinity by 2?” Some teachers couldn’t answer, and others told me, “It’s still infinity!”

More recently, a couple of friends were discussing a similar question at lunch: “What happens when you add 1 to infinity?”

Of course I said, “It’s still infinity!”, but I couldn’t explain it much better than my school teachers (at least not without using the word denumerable, which is a good way to ruin a lunch conversation).

And then tonight, while reading a paper about Haskell, I was hit by an evil idea: When in doubt, ask the Haskell interpreter!

Step 1: Counting

First, we need to teach Haskell about the natural numbers. (Why not use Haskell’s built-in integers? Just humor the crazy programmer for a moment, OK?)

A number is either zero, or the successor of another number. We can write that in Haskell as:

data Nat = Zero | Succ Nat
  deriving (Show, Eq, Ord)

Math geeks in the audience will recognize this as the Peano arithmetic. The “deriving” keyword tells Haskell to define show and the comparison operators for us.

Using this definition of Nat, we can now define some numbers:

one   = Succ Zero
two   = Succ one
three = Succ two
four  = Succ three

These work the way you’d expect:

*Main> three
Succ (Succ (Succ Zero))
*Main> two < three
True

OK, I threw in that last example just for fun.