
New Proof Shows Infinite Curves Come in Two Types - gotocake
https://www.quantamagazine.org/new-proof-shows-infinite-curves-come-in-two-types-20181107/
======
claar
The headline seems inaccurate to me.

The proof in the article states that there is a 100% chance of a random
elliptic curve being either rank 0 (50% chance) or rank 1 (50% chance).

However, the article also informs us that there are an infinite number of
elliptic curves with rank 2 or more. For example, the elliptic curve
`y2+y=x3+x2−2x` is of rank 2.

So is it truly accurate to say that elliptic curves come only in two types?

~~~
ducttapecrown
I'm an undergrad taking some measure theory right now.

This is probably not exactly the mathematical formalism they are using, but it
could be similar.

If I asked you to pick a random real number from 0 to 1, what do you think the
probability is that the real number is rational? A natural way to answer this
question is to try to generalize the way we say the interval from 0 to 1 is
length 1 to more kinds of sets. Measure theory does exactly this, but we find
out that the measure of the rational numbers is 0! This means that the
probability of picking a rational number is 0. But that's clearly impossible
you say, because there are an infinite number of rational numbers from 0 to 1!
But in a precise mathematical way, the probability is 0.

Now a funny think I said was "pick a random real number". Since the computable
numbers are also a measure 0 subset of the real numbers, it's literally
impossible to randomly pick a real number with a computer...

~~~
cix_pkez
Hey, non-mathematician computer science type here.

If I follow correctly, the issue with randomly picking any real number in that
interval is that irrational numbers would require infinite computational steps
to resolve. So the probability is really 0 that you'll get an irrational. If
you have a finite number of computations, you're guaranteed to resolve to a
rational, while if you have an infinite number of computations, you never
resolve to anything.

Is that a decent lay interpretation?

~~~
gpm
Uniformly at random picking a number from the interval [0, 1] isn't possible
with a turing machine (even giving it access to random coins). I.e. it's not a
computable function.

It doesn't even really make sense, you can't represent uncountably many
numbers on a turing machine, so it isn't even possible to return all but a
tiny subset of the space.

You're imagining some turing machine that attempts to compute it anyways and
thinking about the output. You seem to think that you can make a turing
machine that

\- In the probability 0 case that we should output a rational, will output
that number

\- Will otherwise infinite loop

This is randomized, so we are getting our randomness from some kind of "coin
flip" like process. To know that we are in the that probability 0 case of
outputting a rational, we will need to have seen infinitely many coin flips.
If we've seen only n coin flips, there is still 1/2^n > 0 of the probability
space that we haven't explored. So in fact any such turing machine has to loop
infinitely in the rational case as well.

~~~
man-and-laptop
Replace the role of Turing Machines with Type 2 Turing Machines. Then it _is_
possible. And it's got absolutely nothing to do with computable functions.

[edit] The downvoters can't argue with facts. I am _not_ deleting this
comment.

~~~
gpm
Computers are not type 2 turing machines, nor are any other physically
existing thing that we know of. They aren't really turing machines either
because they have a finite tape, but since we are only interested in running
the turing machine for a finite amount of time and thus accessing a finite
amount of tape that distinction is unimportant.

The standard definition of computable is on a turing machine, not a type 2
turing machine. Of course we can define an alternate model where more things
are computable. Edit: And the standard definition of computable is relevant
because it happens to be the exact set of functions we can compute on real
computers.

While Weihrauch [0] does introduce a _different_ definition of the word
computable, that would in a randomized setting allow for sampling from the
interval [0, 1] (and not just for rationals as I understand it either). Any
algorithm on his "oracle turing machines" will still have to take an infinite
amount of time, even to return the rationals. He just allows that in his
definition of computable.

[0]
[https://core.ac.uk/download/pdf/82440448.pdf](https://core.ac.uk/download/pdf/82440448.pdf)

~~~
man-and-laptop
Type 2 Turing Machines are a conservative model of computation. They are as
realistic as Type 1 Machines. Both models involve an infinite tape. Your
previous comment used the Turing Machine abstraction, so my response was
entirely valid, suggesting that replacing your abstraction with another
equally valid, and I believe more appropriate for this purpose, abstraction
eliminates the problem.

Also, by the way, the distinction between "complete" and "potential" infinity
is useful here. The Type 2 Turing Machines features only a "potential"
infinity, the same type that's common throughout Theoretical Computer Science.
A real number is a only a "potential" infinity -- a process of sorts. You seem
to be demanding that a real number be represented as a "complete" infinity,
but this isn't needed for anything in physics or engineering or anything else.
The demand you're making, which would imply that an infinite amount of time is
needed, is unreasonable.

And by the way, the downvoter is somebody who can't argue with facts.

~~~
gpm
I suppose the argument you are trying to make here is basically "having a
machine that if we run it for long enough, will tell us any particular digit
of a number, is as good as having that number".

In the concrete example, you would argue that if a machine which after n time
steps specifies which 1/2^n sized interval the randomly generated number lies
in, then having that machine is equivalent to having the randomly generated
number.

I disagree. If I come up with any property of the number that requires seeing
arbitrarily many digits to specify (e.g. "is rational", "contains more 1s than
0s", etc) you can never tell me whether or not the number your machine
specifies has that property. That said, I can see where you are coming from.
There is at least some argument that under this model it's not the number
which can't be computed, but the "is rational" function.

Personally, I wouldn't worry about the downvotes. Internet points aren't
important in life anyways.

~~~
edflsafoiewq
What does "to have a number" mean?

A program isn't a black box. The number specified (in binary) by this program

    
    
        emit "0."
        loop forever:
            emit "110"
    

is both rational and contains more 1s than 0s. You no more need "run the
program forever" to determine these of the number it presents than you need to
perform an "infinite amount of long division" to determine it of the number
presented by 6/7.

~~~
gpm
For arbitrary turing machines, determining what they will output solves the
halting problem. E.g. the following machine is pi if M' halts else 0.

    
    
        simulate machine M'
        emit pi
    

Because of the halting problem you more or less do have to treat arbitrary
machines as black boxes.

~~~
edflsafoiewq
So? That's no different than a number specified in a "conventional" way, ie.
by some mathematical formula in propositional logic. Let x be 0 is P if true
and pi otherwise.

~~~
gpm
I'd recommend reading the relevant portions (or just all of) this paper:
[https://www.scottaaronson.com/papers/philos.pdf](https://www.scottaaronson.com/papers/philos.pdf)

The conventional way of knowing a number is specifying it in a way that we can
_quickly_ determine what it is and operate on it.

If I say "the next prime after 9^9^9^9^9^9^9^9^9", or indeed "the next prime
after busy beaver(1000)" I have specified a precise number. But you don't
think I _have_ it in any useful sense, because I can't compute it quickly (or
in my second example at all).

Edit: And it should be noted that the above is more akin to the busy beaver
example, no matter how long you operate that turing machine, if M' happens to
be of the sort that doesn't halt but doesn't provably not halt, then you will
never be able to tell me whether the number I "have" is 0 or pi.

~~~
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](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](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)).

------
wallace_f
Why do you think the article garnered 7 comments on its website, but 25 here
on HN?

~~~
AlexCoventry
A lot of people were confused by the paper's probabilistic claim, and tried to
correct each other. At the time I'm writing this comment, only one of them has
done so accurately and germanely, as far as I can tell.

~~~
Dylan16807
It's not unexpected for people to be confused when the article is stretching
the truth to the breaking point.

