[edflsafoiewq]

But you haven't cleared anything up at all! What do you mean "determine what it is"? Do you mean compute its digits? Can you have an irrational number? a rational number with a non-finite decimal expansion? And what do you mean "operate on it"? By which operation? And what do you mean "quickly"?

In any case, the relevant program (assuming a fast random oracle)

    emit "0."
    loop forever:
        x := query random oracle for one bit
        emit x

seems to fit all your criterion. You can compute as many digits as you like very quickly. If you can have pi I don't see why you can't have this number (if you can have any random number at all).

[gpm]

We have branched into two different discussions it seems.

Does having a turing machine that will eventually output a number x suffice for having the number x.

And does that specific turing machine suffice for having a random number in range [0, 1].

As for the second, I have misgivvings about it but there's certainly an argument that that machine does work. The argument against that I currently find most convincing (that you don't have a classical representation that you can make two isolated copies of) is outlined here: https://news.ycombinator.com/item?id=18424725

The first discussion is more nuanced. The meaning of knowing/having a number is not something I claim to have an exact answer to (and indeed since it's an english term it probably doesn't have an exact meaning). It's clear however that having a turing machine that eventually outputs the value is not the same as knowing the value.

What operations is really the most fundamental question, I'd argue that it's clear that if you know x you can at least tell me what the n^th digit of x is. An arbitrary turing machine fails this, an arbitrary turing machine fails being able to tell me what the first digit is, let alone the n^th one.

I'm not going to take the stance that being able to compute its digits quickly is sufficient for having a real number, but I also won't argue against it. Personally I'd like to ask for equality testing too. I'm willing to yield that since I'm pretty sure that man-and-laptop will disagree and argue that being able to test for closeness is good enough, and he has a point even if I'm not convinced.

As for your the other questions you put to me, they aren't relevant for the turing machine part but:

Quickly, means in at most polynomial time. It might actually mean something stricter, but polynomial time seems to be a pretty clear upper bound on the amount of computation time you can need to find something while still being able to claim to know it. (See the paper I linked above)

We can certainly have a rational number with a non finite decimal expansion, you just need more creative forms of representing the numbers than listing digits. For instance the common method of putting a bar on top of the repeated ones, or alternatively quote notation is rather cool: https://en.wikipedia.org/wiki/Quote_notation

[edflsafoiewq]

> I'd argue that it's clear that if you know x you can at least tell me what the n^th digit of x is. An arbitrary turing machine fails this, an arbitrary turing machine fails being able to tell me what the first digit is, let alone the n^th one.

Sound good (assuming we accept the 999... problem of non-uniqueness). So let's assume the machine makes progress in finite time ie. there is a sequence of natural numbers a(n) such that after time a(n) the machine has emitted at least n digits.

There's another possibility you mentioned above about a machine taking an input n and finding a value within 2^(-n) of the number. A machine that keeps emitting numbers on either side of an integer, eg. 2.1, 1.99, 2.00001, etc. fails to tell the first digit. But these numbers are arguably even more physical that programs-emitting-digits. They're roughly the real numbers you'd get from doing actual (classical) physical measurements.

> Personally I'd like to ask for equality testing too.

You didn't answer the question about irrational numbers but do you think we can have pi? It seems infeasible to mechanically determine that an arbitrary program you are given is a valid pi-digit-calculator though.

If you don't think you can ever have irrational numbers, then I think I see where you're coming from now. Having a number could be having a finite representation of the number that can be mechanically tested for equality (in time polynomial in the sizes of representations): a string of digits, a ratio of strings of digits, a string of digits with decimal point and a bar over the repeated ones, etc. IOW a normal form in some finitary data type.

> Quickly, means in at most polynomial time.

In what? You want the nth digit printed by time O(P(n))? If so, that is strictly stronger than finite time progress so we could dispense with that. But polynomial time doesn't make any sense for a machine that emits a finite string of digits and halts because it doesn't have an input.

> or alternatively quote notation is rather cool

Hah, I was going to ask about p-adics (do I have -1 if I have the machine that emits an infinite string of 1s?).

[gpm]

> 2.1, 1.99, 2.00001

I'm really not satisfied with saying that a machine that gives smaller intervals like that is fully sufficient, on the other hand that's really all we're doing when we specify digits...

> They're roughly the real numbers you'd get from doing actual (classical) physical measurements.

I'd argue that a series of physical measurements don't give you a number so much as a probability distribution, even classically.

> do you think we can have pi

I'm not sure.

The problem I have with denying pi is it doesn't make much more sense than denying 1. Base pi is a perfectly rational numbering system. It's perfectly possible to introduce a special 'pi' symbol (rather like 'i') and define rules of arithmetic so that things work with both rationals and rational multiples of pi. And everything I said just applies to infinitely many other irrationals as well (e.g. 2^(1/n))

> It seems infeasible to mechanically determine that an arbitrary program you are given is a valid pi-digit-calculator though.

Indeed, this is true even if you replace "pi" with "1" though, that's another reason why having a program that calculates the digits isn't sufficient.

> Having a number could be having a finite representation of the number that can be mechanically tested for equality (in time polynomial in the sizes of representations)

Yes.

> In what? You want the nth digit printed by time O(P(n))?

It's a vague definition anyways, polynomial in the sum of everything that is relevant... probably O(P(n + the number represented)).