On 13 Jul 2015, at 15:29, Pierz wrote:
Here's something that bothers me when I try to think of the brain
too much as a computer. How would I teach a computer the notion of
infinity?
That's an excellent question.
Logic put some light on this, by showing that the notion of
"finite" (and thus infinite, as the negation of finite cannot be
defined in first order logic. This only indicate that the notion of
finite/infinite needs a necessary informal higher order logical
intuition. That is the coherent with the "failure of logicism"
interpretation of the theorems of limitations of formalism/machine.
You question is almost akin to the difficulty of getting the qualia of
the conviction of our understanding of infinity, like when we say,
innocently, let us consider the set N = {0, 1, 2, ...}. How can "we"
understand this in a finite time?
But, and that's the main key to progress, the introspecting machine is
"aware" of its incompleteness, and can deduce that if she is a
consistent machine then attempting a proof of its own consistency
would never stop. By the same token, the machine, always embedded/
emulated by some universal number can de visu realise what non
stopping mean, and eventually bet ("consciously, then automatically)
that the two non-stopping are related, which technically, consists in
applying the Theaetetus definition which connects the representation
([]p) and the truth (p).
Infinity comes from the fact that the machine can find number k such
that phi_k(k) = phi_k(k) + 1, or put in a different way, that some
program does not stop. The concept of infinity appears as the
platonist negation of the finite. It can be semi-constructive, like
with the infinite recursively enumerable set.
Or put two universal machines in front of each other. Universal
machine can be dynamical mirrors, and they will reflect each other to
infinity, and then a third can "grasp" why.
In simple terms, how can I represent infinity in a computer program?
Let me be naive.
In the language BASIC: "10 goto 10".
"10 goto 10" = infinity in basic.
With the combinators. Well, you need the most famous Mocking Bird
itself, the combinators M such that
Mx = xx
So MM will be the solution, provided we find that M. MM = infinity in
the combinators.
Can you find a combinator (that is, a combination of S and K) which
computes M?
I recall
(1) Kxy = x
(2) Sxyz = xz(yz)
Hmm... if Ix = x, SII is a solution, as SIIx = Ix(Ix) by (2), which
gives xx. So M = SII, and infinity = SII(SII).
But is there a combinator I? Yes, I = SKK, as you can see that SKKx =
Kx(Kx), by (2), and Kx(Kx) = x, by (1).
So infinity, the basic "10 goto 10", is S(SKK)(SKK)(S(SKK)(SKK)).
infinity = MM = S(SKK)(SKK)(S(SKK)(SKK))
You can evaluate it following (1) and (2). It does not reproduce
itself, but it call itself again and again.
If you take a Löbian machine, which believes such axioms (or
equivalent), but also believes in induction principles, they can
reflect such fact, and prove that on some input they would not stop.
PA can prove that
S(SKK)(SKK)(S(SKK)(SKK)) does not stop.
All a computer knows about infinity is 'stack overflow' (or simply
integer overflow), an inability to continue a calculation due to
lack of computational resources. Yet obviously such a state has
nothing to do with infinity,
OK.
That reflects only the fact that people are not intersted in
discussing infinity with machine or formal systems, but somehow that
is what the logicians do.
and the halting problem shows that no computer can "grasp" the
notion of infinity through some algorithmic method.
Hmm.... The halting problem just show that there is no general
mechanical procedure to decide if some program will stop or not. It
does not mean that this or that machine, having this or that beliefs,
will believe (correctly or wrongly) that this or that program will
stop or not.
The difficulty is in the qualia of that understanding. It is amazing
for us too. But eventually, the machine can reflect its ignorance of
any mean to even express that qualia.
In some religion, only God is infinite, and cantor asked the
permission of the Church to make the infinite into a mathematical
object. I am not yet sure if that is not a sort of blaspheme. What can
be shown is that it makes the quantified hypostases of the machines
believing in infinities subjected to Quine critics of modal logic. Not
so for PA and "pythagorean" machines.
I could program in an infinity symbol and under certain
circumstances teach the computer to spew out this symbol, such as
when asked to divide by zero, but that's like teaching a monkey to
press a button that causes a recording of Hamlet's soliloquy to be
played whenever the monkey is asked, "How do you feel about your
life?" The understanding of the connection between input and output
is all external to the system. I'm curious to know - how could one
even in principle write a program that would produce an output that
could plausibly be regarded as a representation of infinity,
generated by the machine?
By non-stopping programs, for machine having enough beliefs such that
she can justify to you that such program are non-stopping one. PA can
prove that there is no biggest prime number, or that for all prime
number we can find a bigger one.
But the qualia of the "genuine understanding of this" is hidden in the
intensional nuances, usually not taken into account in the
instrumentalist use of (extensional) mathematics.
How, for example, could one get it to "work out" that a number
divided by zero gives an infinite or undefined result, without
simply programming that response?
By letting a machine deduce things from elementary beliefs, but the
genuine understanding will appear with instinctive connection between
representation and truth, above the fixed points provided by self-
reference.
Eventually, the machine learns this by accumulation of experience,
theorizing, self-correction, etc.
This is just another variant on the symbol grounding problem of
course, but it seems a telling one, because infinity is a
mathematical concept, and in its way almost as important as zero.
Well, I avoid it in the ontology (RA), and it is permitted in the
"epistemology" (PA, ZF, I consider the notion of set as
epistemological). So all you have is 0, 1, 2, 3, .... (or K, KK, S,
KS, KKK, K(KK), ...). But as noticed, some expression will refer to
non-stopping behavior, and the machine can learn to relate such non-
stopping description with actual non-stopping, relatively to herself,
procedure.
I'm not advancing this exactly as an argument against
computationalism, but I am curious to know if anyone has a better
answer to it than simply something like "it will emerge at higher
levels" or something - which to me just begs the question of how.
The problem is complex, and not solved at all levels, nor can it be,
and that is why it is better to bet on a low comp subst. level level,
than on a level where we might wrongly convince ourself that a machine
grasp (qualia included) infinity.
I would say that it is also the question on which mathematical logic
has put a lot of light, notably through model theory.
There is no definite criteria of "understanding" infinity, but there
are wonderful object, like the constructive ordinal omega_1^CK, which
shows how much in the constructive transfinite we can go in a provable
way. Yet, both us and machines can exploit the non-provable path, and
extend the path far beyond the constructive, and we have to do so once
we are interested in the theoretical possibilities and impossibilities
of the machines.
Infinity is important. I would say that the qualia of infinity might
be the logical ancestor of other qualia, and of semantic in general.
In the "phi_i" talk, i is the program, and phi_i is the function from
N to N that i computes, and it is a simple semantic, where the meaning
of i is the *infinite* set of input-outputs of the ith programs in the
universal language corresponding to those phi_i.
Another way to get infinity, in set theory, is by the use of the
reflexion and comprehension principle. I can explain someday, although
it is something eminently graphical.
The infinity rabbit hole is infinite.
Bruno
--
You received this message because you are subscribed to the Google
Groups "Everything List" group.
To unsubscribe from this group and stop receiving emails from it,
send an email to [email protected].
To post to this group, send email to [email protected].
Visit this group at http://groups.google.com/group/everything-list.
For more options, visit https://groups.google.com/d/optout.
http://iridia.ulb.ac.be/~marchal/
--
You received this message because you are subscribed to the Google Groups
"Everything List" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
To post to this group, send email to [email protected].
Visit this group at http://groups.google.com/group/everything-list.
For more options, visit https://groups.google.com/d/optout.
