Ancora su zero alla zero

Aggiornamento: il post contiene un colossale errore logico, vedi il commento di zar; la correzione qui.

Marco [Cameriero] rockz! I nostri lettori più affezionati lo sanno, da sempre. Anche perché Marco è un nostro autore. Emerito? no io lo considero in sabbatico ma prima o poi...
Intanto su G+ ha fatto un botto, con questo post: Quanto fa zero elevato alla zero?

Da leggere, interessantissimi e illuminanti i commenti.
I link nel post sono esaustivi; definitivi. Bravi .mau., GLF, Zar, Annarita.
Solo due cent(s) che mi sento in dovere di aggiungere.
Il più importante: vengo più volte citato come iniziatore della discussione. Non è vero: ha iniziato Tania Tanfoglio, purtroppo non sono riuscito a rintracciare il paperolesso, chissà se lei... (poi ce lo dico).

Mi suggerisce l'amico Gottfried Wilhelm: Calculemus!
Di WolframAlpha se ne è già parlato, peccato che Mathematica non sia freeware (uh! devo riprendere Mathics, il clone free, prossimamente, promesso (forse)).
Piuttosto i 'puters fanno quello che possono, spesso non per colpa loro ma degli umani ad essi connessi. Ecco un esempio, giusto per intorbidire le acque (chiaro che la risposta è indeterminato, nèh!).
Un programmino semplicissimo, in Python (mettete le parentesi a print se usate la versione 3):

1 2 3 4 5 6 7 8 9

#!/usr/bin/python #zero alla zero [float] for e in range(21): # e = esponente den = 10**e # denominatore ris = 1.0 / den z = 0**ris # quasi zero, numero piccolissimo print e, den, ris, z

Che da questo risultato:

* 0^0 $ python z.py
0 1 1.0 0.0
1 10 0.1 0.0
2 100 0.01 0.0
3 1000 0.001 0.0
4 10000 0.0001 0.0
5 100000 1e-05 0.0
6 1000000 1e-06 0.0
7 10000000 1e-07 0.0
8 100000000 1e-08 0.0
9 1000000000 1e-09 0.0
10 10000000000 1e-10 0.0
11 100000000000 1e-11 0.0
12 1000000000000 1e-12 0.0
13 10000000000000 1e-13 0.0
14 100000000000000 1e-14 0.0
15 1000000000000000 1e-15 0.0
16 10000000000000000 1e-16 0.0
17 100000000000000000 1e-17 0.0
18 1000000000000000000 1e-18 0.0
19 10000000000000000000 1e-19 0.0
20 100000000000000000000 1e-20 0.0
* 0^0 $
Quindi, contrordine compagni! (cit.), 0^0 = 0.
Notare che l'esponente non è esattamente 0 ma un numero ε piccolo a piacere (cit.). E float, approssimazione di reale.

Viene voglia di vedere cosa capiterebbe usando gli interi:

* 0^0 $ python
Python 2.7.8 (default, Oct 20 2014, 15:05:19)
[GCC 4.9.1] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 0**1e-50
0.0
>>> 0**1e-100
0.0
>>> 0**int(1e-50)
1
>>> 0**0
1
>>> quit()
* 0^0 $

Ecco, cambia, salta fuori il risultato 1 dettato dalla specifica IEEE, ma solo per l'int.

Usando calc, una calcolatrice a precisione arbitraria disponibile anche per Windows ottengo un comportamento ancora più bizzarro:

* 0^0 $ calc
C-style arbitrary precision calculator (version 2.12.4.4)
Calc is open software. For license details type:  help copyright
[Type "exit" to exit, or "help" for help.]

; 0.0**(1e-50)
    0
; 0.0**(1e-100)
    0
; 0.0**int(1e-100)
    0
; 0**int(1e-100)
    0
; int(1e-100)
    0
; 0**0
    1
; quit
* 0^0 $

Cioè 1 lo ottengo solo con uno 0 vero non con uno castato (ahemmm... convertito da float a int; davvero non so come si dice in italiano).

Morale, sì, questo post ha una morale: il risultato del 'puter vale nel suo ambito. Estendiamo i NOMA di Stephen?