main →  Big Psi

Constructie van Grote getallen

Auteur: Franzes van Novaloka
Datum: 29 januari 2009

Samenvatting:
Introductie van algoritmes voor het maken van steeds grotere getallen, waardoor de lezer begrip krijgt voor de enorme ruimte die de natuurlijke getallen beslaan, zodat oneindigheid opnieuw het perspectief krijgt dat het verdient.

Legenda voor de kleuren van wiskundige expressies in de webversie van dit artikel:

bruin
Kiest een bekende schrijfwijze, bijv: a^2 = a2 = a×a = a·a = aa = a*a
zwart (blauw (genest))
Standaard bigE schrijfwijzes: E(a,E(1,1),11) = E(a,11,11) = a;11;11 = a**11 = a*a
[paars] …of in kleur van expressie
Bepaalt herhalings-ellips of waarde: a+...[a#a] = a...[a#a] = a*a [a>0]
rood en dieper magenta
Subscripts van variabelen, bijv: as111 = ;;X1 = 1
groen
Legt nadruk op een onderdeel => dat apart gezien moet worden.

# Enen en operatoren

De natuurlijke getallen {0,1,2,3,4,5,...} kunnen we met louter cijfers 1 uitdrukken in wat ik noem hun eenvoudige vorm als { ,1,11,111,1111,11111,...} waarbij het nulde getal 0 aangegeven is door het ontbreken van 1.
Grote getallen zullen we op verschillende manieren noteren, waarbij het toegepaste algoritme definieert hoe elk getal uiteindelijk (theoretisch althans) herleid kan worden tot zijn eenvoudige vorm: n = 1...[1#n]

Notatie-conventie ABC...D [B#n] (waar A,C en D optioneel zijn en B≠C), uitleg:
De herhalingsregel [B#n] tussen vierkante meta-haken stelt, dat in de voorgaande expressie op de plaats van BC... de variabele of de karakterreeks B een n aantal maal achter elkaar wordt herhaald, met tussenplaatsing van karakter(s) C.
Bijvoorbeeld: a(b*...)[b#3] = a(b*b*b)
Notatie-conventie A...B...C [#n#] (waar B en C of A optioneel zijn), uitleg:
De herhalingsregel [#n] stelt, dat op de plaats van A... de karakters A een n aantal maal worden herhaald. De herhalingsregel [n#] stelt, dat op de plaats van ...C de karakters C een n aantal maal worden herhaald.
Bijv: S(... ...)[#111#] = S(S(S( ))) = 3 = 1...[#111] = ...1[3#] = 111

De basisoperaties van het rekenen kennen we als: optellen, vermenigvuldigen en machtsverheffen.
Optellen hoeven we niet als aparte operatie te behandelen, want twee natuurlijke getallen a en b tellen vanzelf op door deze in hun eenvoudige vorm als ab (of aanvankelijk als (a)(b)) naast elkaar te plaatsen. De nulde operator + is strikt genomen overbodig.

Met de introductie van het teken * voor operatoren, definiëren we vermenigvuldigen als herhaald optellen: a*b = a...[a#b]
Machtsverheffen schrijven we met twee ** operator-tekens, gedefinieerd als herhaald vermenigvuldigen: a**b = a*...[a#b]

De hierop volgende super-exponenten werken volgens hetzelfde principe:
met *** als operator voor de derde operatie van herhaald machtsverheffen: a***b = a**...[a#b]
en verder bijv: 111****11 = 111***111 = 111**111**111
Ieder hoger type macht is te definiëren als herhaling van een voorgaande operatie, zodat de algemene formule geldt:

a*...b [*#m1] = a*...... [*#m a#b]

Met de operatoren *...[#n n>11] kunnen we makkelijk al getallen uitdrukken die buiten het bereik van tijd en ruimte vallen, aangezien alle quantuminformatie van het astronomisch heelal isomorf is aan een getal U < 5***4

In het vervolg zullen we een 'super-Exponentiële' operatorfunctie bigE definiëren met E(a,b,c) = a*...b [*#c] om daarna de parameterlijst van bigE uit te bouwen in meerdere dimensies. Maar eerst beschouwen we de verschillende manieren om operatoren, parameters, etc. te evalueren:

# Evaluatierichting en precedentie

Gewoonlijks R-evalueren we een expressie van rechts naar links: 3**3**3 = 3**(3**3) = 3^27 = 7625597484987
L-evalueren van links naar rechts zou kleinere getallen opleveren: 3**3**3 = (3**3)**3 = 27^3 = 3^9 = 19683

Machten kunnen met ** of ^ worden geschreven, waarbij voor ^ operaties altijd school precedentie geldt, en:
^...[^#n] = *...[*#n1] (behalve bij precedentie 4. en 5. hieronder).

Neem aan dat we operaties en parameters voortaan R-evalueren vanaf de rechter kant van de expressie.
Volgt er een keuze uit vijf aanvullende regels voor de precedentie van operatoren, geordend van kleinere naar grotere uitkomsten:

  1. School precedentie: Zonder haakjes grotere operatoren altijd eerst evalueren, bijv:
    11**11*11**11 = (2^2)*(2^2) = 4*4 = 16
  2. Luie (lazy) precedentie: De linker operand is het getal tot aan de volgende operator.
    11**11*11**11 = 2^(2*(2^2)) = 2^8 = 256
  3. Gretige (greedy) precedentie: De linker operand loopt tot aan de eerstvolgende gelijke of grotere operator, zodat kleinere operatoren altijd eerst geëvalueerd worden.
    11**11*11**11 = 2^((2*2)^2)) = 2^16 = 65536
  4. Vasthoudende (possessive) precedentie: Kleinere operatoren eerst evalueren en daarbij operatoren (groter dan 0) apart betrekken op elke linker operand tot aan de eerstvolgende grotere operator.
    11**11*11**11 = (2^2)**((2*2)^2) = 4**16 = 4^(2^15) ~ 2E19728
  5. Obsessieve precedentie: Operatoren met hun rechter operand hebben apart betrekking op elke (ongeneste) linker operand tot aan het begin en evalueren deze op hun plek.
    11**11*11**11 = 4**4*4 = 16**16 = 16^(2^15) ~ 4E39456

In onze opzet met operatoren * hierboven past gretige precedentie het best, aangezien dit optellen als nulde operatie mogelijk maakt en expressies ermee kunnen worden geëvalueerd zonder ergens haakjes toe te voegen in de uitwerking.

# bigE parameters

Definitie van operatorfunctie bigE, die met zijn eerste drie parameters de operaties a*...b [*#c] weergeeft:

E(a) = a
E(...,0) = E(...)
E(a,1) = E(a1) = a1
E(a,b1) = E(E(a,1),b) = E(a1,b) = E(a1...) [1#b1] = ab1 = a+b1
E(a,b1,c1) = E(a,E(a,b,c1),c)
E(a,1,c1,...) = a

Alternatieve functie-definities zijn ook in het begin al goed mogelijk. In "Binary Big Number Systems" [NL20081014] vind je verschillende binaire-stijl operatorfuncties die ik baseerde op (het snellere algoritme) verdubbelen, met: E(a,1) = aa
en vervolgens bijvoorbeeld: E(a,b1) = E(E(a,b),b) = a*(2^(2^b))

De definitie van de vierde en volgende parameters van bigE is geenszins triviaal. In "Neuropol 0" [NL20080502] twijfelde ik tussen substitutie met [WA1928] Ackermann-getallen, door bijv: E(a,b,c,1) = E(E(a,a,a),E(b,b,b),E(c,c,c))
of substitutie in maximale [CG1996] Conway-stijl door: E(a,b,c,d1) = E(E(a,b,c,d),E(a,b,c,d),E(a,b,c,d),d)
Die laatste versie groeit maximaal, omdat in alle entries behalve de laatste de voorganger joker J wordt ingevuld:

E(a1,..,am,z1) = E(J,...,z) [J#m]  waar J = E(a1,..,am,z)

Ook is er een 'natuurlijk vervolg' op het operator-type *0...[#c] zoals ik dat eerder trachtte uit te werken in "Middelvinger. expansie van parameters" [NL20080924]. De doorbraak kwam met het besef dat operatoren en separatoren niet wezenlijk verschillen (noem de tekens * en , superatoren) en dat multi-dimensionale systemen uit te breiden zijn door subscripts toe te voegen aan hun superatoren.
Via de virtuele introductie van extra operator-typen *1, *d, *d,e, etc. rolt de eerste rij parameters van bigE er nu uit als:

E(a,b,1,1) = a*1b = a*...b [*#b] = E(a,b,b)
E(a,b1,c1,1) = a*1...b1 [*1#c1] = a*1...... [*1#c a#b1] = E(a,E(a,b,c1,1),c,1)
E(a,b,1,d1) = a*d1b = a*d...b [*d#b] = E(a,b,b,d)
E(a,b1,c1,d) = a*d...b1 [*d#c1] = a*d...... [*d#c a#b1] = E(a,E(a,b,c1,d),c,d)
E(a,b,1,1,1) = a*1,1b = a*b...b [*b#b] = E(a,b,b,b)
E(a,b,1,1,e1) = a*1,e1b = a*b,e...b [*b,e#b] = E(a,b,b,b,e)
E(a,b,1,d1,e) = a*d1,eb = a*d,e...b [*d,e#b] = E(a,b,b,d,e)
E(a,b1,c1,d,e) = a*d,e...b1 [*d,e#c1] = a*d,e...... [*d,e#c a#b1] = E(a,E(a,b,c1,d,e),c,d,e)
E(a,b,1,...) [1#k] = E(a,b,...) [b#k]
E(a,b,1,...,n1,..,r) [1#k] = E(a,b,...,n,..,r) [b#k1]
E(a,b1,c1,..,r) = E(a,E(a,b,c1,..,r),c,..,r)

# bigE dimensies

Na een dubbele komma ,, begint een nieuwe rij parameters in de "tweede dimensie". Met een reeks van m separatoren ,[#m] bouwen we een m-dimensionale parameter array voor bigE.
Voor de evaluatie van de meervoudige komma zijn weer verschillende definities mogelijk. We kunnen de herhalingsregels voor ster-operatoren * ook op komma-operaties toepassen, waarbij ongelukkig uitkomt dat: E(a,...0)[,#k] = 0

E(a,,b) = E(a,...) [a#b]
E(a,...b) [,#k1] = E(a,......) [,#k a#b]

Sneller is het volgende algoritme dat mijn voorkeur heeft, ook omdat: E(a,...0)[,#k] = a

E(a,,b1) = E(a,...,,b) [a#a]
E(a,...b1) [,#k1] = E(a,......,...b) [,#k a#a ,#k1]

In deze definities van bigE werken we eerst de lagere dimensies uit en passen dus gretige of vasthoudende precedentie toe. De meervoudige komma als gretige operator expandeert slechts de direct voorafgaande rij of dimensie, onafhankelijk van eerdere dimensies. De meervoudige komma ,[#m1] als vasthoudende operator past zijn algoritme toe op elke dimensie m>0 lengte.

Zouden we het eerder genoemde maximale Conway-stijl algoritme doortrekken in de hogere bigE dimensies, dan kunnen we obsessieve precedentie op verschillende manieren toepassen om zeer snel Grote getallen te creëren:
De eerste manier telt de finale countdown variabele z af, substitueert alle overige parameters met de waarde van voorganger J, maar stelt de lengte-expansie uit tot twee dimensies in bigE in de vorm van a,...b geëvalueerd kunnen worden.
De maximale methode (op groen) telt de finale countdown z af, expandeert in elke dimensie alle niet-finale lengtes tot de grootte van voorganger J en vult voor alle parameters de waarde J in.

E(a,,b,z1) = E(J,,J,z)  waar J = E(a,,b,z)
Es1,..,sn(a1,..,1,.:.ak,..,sn,z1) = Es1,..,sn(J,.:.J,z)  waar J = Es1,..,sn(a1,..,1,.:.ak,..,sn,z)
E(a,,b,z1) = E(J,...,,J,z) [J#J]  waar J = E(a,,b,z)
Es1,..,sn1(a1,..,1,.:.ak,..,sn1,z1) = EJ,...,sn1(J,.:.J,z) [J#n]
                        waar J = Es1,..,sn1(a1,..,1,.:.ak,..,sn1,z)

In de hier geschetste formules zijn de helper-subscripts in rood lengtes en die in magenta dimensies van (of in) bigE's parameter array.
Grote getallen die volgens zulke algoritmes voor bigE worden uitgewerkt zullen (theoretisch althans) moeten voldoen aan de eis van reduceerbaarheid tot eenvoudige vorm.

# bigE typen

In het vorige hoofdstuk zagen we hoe de evaluatie van komma-operatoren in bigE zowel de waardes van parameters als de lengtes in de parameter array rechtstreeks vergrootte. Dit hoofdstuk neemt de volgende stap: extra-dimensionale expansie van het aantal dimensies van bigE door hogere typen operator functies.

Introduceren we een superator ; waarmee we operator functies En(X) = ;...X [;#n] uitdrukken – dat is (als nulde) bigE met puntkomma separatoren ,... = ;... en waarbij de functie-aanhef E() is komen te vervallen.
Deze superator-notatie schrijft blote parameter arrays (zonder haakjes) in binair format met slechts de twee tekens 1 en ; (hoewel er in de uitwerking van zo'n expressie toch weer haakjes nodig zijn). De ; is in dit format op te vatten als de binaire nul en de formule-getallen als andersom geschreven. Zodat vanzelf: X;0 = X; = X

Gebruikmakend van de vrije ruimte die dit binair format nog biedt kunnen hogere typen bigE verschillend worden vormgegeven. Het systeem hiervoor in mijn "Binary Big Number Systems" [NL20081014] definieert een parameter-dimensionale typering voor bigE1.

In dit artikel geef ik een eenvoudig (nul-dimensionaal) systeem voor bigE-typering, dat met het aantal superatoren ;...[#n] direct aan het begin het type bigEn benoemt. Zodoende blijven de getallen kleiner (dan mogelijk zou zijn met parameter-dimensionale typering), maar de resolutie (bij dezelfde expressie-lengte) wordt groter – afhankelijk ook van het algoritme dat de evaluatie van deze typen bigEn definieert:

;...a [;#n1] = ;...a;...1 [;#n ;#a1]
;...X;z1 [;#n1] = ;...J;...1 [;#n ;#J1]  waar J = (;...X;z)[;#n1]

Een rigoreuzere definitie van bigE typen zou de operatoren *... als separatoren gebruiken in een operator functie E0() en daar op voortbouwen met En1(a,b,c) = En(a,...b)[,#c] of met de Ackermann-functie: En1(a) = En(a,...a)[,#a]

# bigE cycli

Terugblikkend merken we op, dat steeds weer nieuwe entiteiten telbaar worden. En dat, wanneer een notatievorm volledig is ingevuld, de eerder gekozen superatoren geteld kunnen worden door een variabele 1...[#n] binnen een universelere notatie, waarin een nieuw (of opnieuw gedefinieerd) karakter de rol van superator overneemt:

In prototype bigE is – gegeven de principes van getal en herhaling – de cyclus-lengte 3.
Als resolutie belangrijk is zou een algoritme voor bigEE deze taken kunnen comprimeren met bijv:

E...(X,0) = E...(X,) = E...(X)
EE(a,b,c,d,e,f) = ;... a;...b;...c;... ... [;#f ;#e1 ;#e1 ;#e1 c#d]

Of als we onze bigEE functies louter gebruiken voor het schrijven van Grote getallen:

; = ;1
E...(a) [E#u1] = ;u...a [;u#a]

Om vervolgens de bigEE... parameters en dimensies in maximale Conway-stijl te definiëren zoals voordien bij bigE en de uitbreiding naar E...[E#u]n() typen via superatoren ;u

Omdat we met de evaluatie in bigE... expressies steeds dezelfde weg afleggen als in het prototype bigE noem ik deze algoritmes cycli. Het aantal doorlopen cycli wordt hier nog eenvoudig uitgedrukt met het getal u van het superator-type aan het eind van de laatste cyclus.
Maar subscript u zou uitgebreid kunnen worden tot een extra-dimensionale parameter-array en verder totdat de superator-typering een cyclus heeft doorlopen van dezelfde lengte als de cyclus van de getals-evaluatie. Deze nesting van cyclus in cyclus kent een subscript-diepte die telbaar wordt binnen een universeler algoritme, waarmee de cyclus-lengte dus toeneemt met 1.

Meer filosofisch dan wiskundig kunnen we doorgaan virtuele algoritmes te postuleren, zodat de cyclus-lengte direct kan toenemen. Cyclus-lengte op cyclus-lengte worden genest binnen cyclus-dimensies, nestdiepte op nestdiepte ontstaat meta-nestdiepte. Meta-niveau's zijn telbaar en kunnen op hun beurt worden genest binnen meta-cycli die nog Grotere getallen aanduiden; maar de grens van het oneindige ligt verder weg dan ooit.
Telbaarheid kan nooit worden toegepast om het ontelbare te bereiken, ook al tellen we alsmaar sneller. Wel kregen we zicht op de ruimte van de natuurlijke getallen, die alsmaar Groter blijft worden…

Om maar eens een jazzy getal te noemen for your Beer Book of Bears:

Jazz 5 = ;55 = EEEEE11111(11111,,,,,,1)
Vague photograph of an Amsterdam metro plan

# Grote gaten

Eenvoudig "vingers tellen" is voor Grote getallen niet minder bruikbaar dan notatie in decimalen. Een reeks van V enen druk je uit met log(V) cijfers, dus als V = 10^^^3 dan heb je praktisch evenveel ruimte voor decimalen nodig:
log(10^^(10^^10)) = log(10^(10^^(10^^10-1))) = 10^^(10^^10-1) ~ 10^^(10^^10)

Dat het aantal cijfer-karakters hier een exponent 10 scheelt maakt weinig indruk. De resources van ons heelal zijn sowieso onvoldoende om Grote getallen zoals V in welke radix dan ook uit te schrijven.

Hoe groter de getallen die we met een algoritme kunnen uitdrukken, hoe groter de gaten ertussen waar zich random getallen ophouden die we gegeven onze fysieke resources nooit kunnen zien. Het beeld wat dit oproept is dat van een expanderend heelal met galaxies van getallen in een uit de oneindigheid omlaag vallende duistere ruimte.
Volgt het bewijs dat de meerderheid van deze tussenliggende getallen met geen enkel fysisch algoritme kan worden uitgedrukt:

Definitie: een [volledig] algoritme is een stel expressies met variabelen (inclusief variabele stappen), dat een getal vormt wanneer elke variabele een waarde krijgt [van binnen het algoritme onafleidbare entiteiten, zoals {1,0,-} dat zijn].

Stel dat je een universum hebt waar k karakters en p plaatsen het maximum is en die plaatsen verdeel je over een algoritmische tekst en een te creëren getal.
Met k karakters op a plaatsen, kun je maximaal k^a teksten schrijven, die eventueel volledige algoritmes zijn.
De resolutie van een algoritme met k karakters is nooit beter dan radix k, zodat een algoritme met k karakters op (p-a) plaatsen maximaal k^(p-a) unieke getallen uitdrukt.
Als al die algoritmes unieke getallen weergeven, is je maximum aantal getallen: k^(p-a) * k^a = k^p

Wanneer ons universum al zijn 10^121 quantum-bits ter beschikking stelt, dan is k=2 en p=10^121 en is het totaal aantal schrijfbare getallen hooguit: 2^(10^(11^2))
Omdat we op een papiertje al veel grotere getallen uit kunnen drukken, bijvoorbeeld met de in dit artikel geschetste formules, blijven de meeste Grote getallen fysisch gezien ontoegankelijk.

Voor de aardse fysische grens waar het eerste Grote getallen-gat begint, zou je de servers van Google als maatstaf kunnen nemen. Zouden ze hun 10^18 bits in serie schakelen, dan raken er boven de grens van Googol^(10^16) zeker getallen zoek.

# Andere getallen

We leiden de negatieve entiteit: - = -1 af uit de vergelijking: ?1 =   = 0 => ? = -
De negatieve gehele getallen volgen via identiteit a*1 = a en distributie a*bc = (a*b)(a*c)
zodat: -*1...[1#n] = -...[-#n]

De breuken volgen via identiteit a*(a**0) = a*1 en distributie a**bc = (a**b)*(a**c)
zodat: (a**-)*a = (a**-)*(a**1) = a**-1 = a**0 = 1
en: b*(a**-)*a = b

Via wortels: (b**a**-)**a = b volgen de algebraïsche complexe getallen gebaseerd op: (-**11**-) = i
Maar met de verzameling discrete getallen die we nu hebben, zijn lang niet alle getallen gegeven.
Door negatieve, rationale en algebraïsche complexe getallen in supermachten ***... toe te laten kun je vele andere discrete getallen maken.
Zoals bijvoorbeeld via de definitie: (b***a**-)***a = b

En wanneer je zulke getallen invult in de derde parameter c van operator functie E(a,b,c) = a;b;c zou je die operatie moeten definiëren met een nieuw algoritme.
Uit: a;(a;b;c1);c = a;b1;c1 en inductie volgt zo de fundamentele rol van Peano's successor operatie:
a;(a;b;0);- = a;b1;0 => a;ab;- = ab1 &&
a;(a;b;-*n);-*n1 = a;b1;-*n => a;b1;-*n1 = b11 => E(a,b,-*n1) = b1 [n1>0]

Alle andere mogelijkheden – te beginnen met rationale superexponenten – zijn nog onontgonnen terrein.
De wiskunde komt nooit af.
Probeer als oefening eens af te leiden (voor natuurlijke getallen m en n):
a;-;111 = 0 & a;--;1111 = - && E(a,-*m1,n11) = -*m [m<n]

# bigEta oneindig tellen

Georg Cantor formuleerde in de 19e eeuw twee vormen van oneindigheid: de telbare oneindigheid ω die groter is dan alle aftelbare getallen, en een ontelbare oneindigheid die groter is dan alle getallen die dieper zijn dan alle aftelbare getallen.
Cantor kon het verband tussen beide niet vinden door vanuit (en met) ω telbaar oneindig keer te blijven tellen.

Alle getallen die met onze algoritmes voor bigE te maken zijn, zijn aftelbaar en dus kleiner dan oneindig, zelfs wanneer we telbare entiteiten zoals de negatieve - toevoegen. Alleen door het eerste oneindige getal ω toe te voegen aan bigE, kunnen we daarmee verder rekenen in het oneindige, zoals Cantor deed met zijn ordinale getallen:

E(1,ω) = ω
E(ω,1) = ω+1
E(ω,11,1) = ω+ω
E(ω,11,11) = ω^2
E(ω,11,111) = ω^ω
E(ω,11,1111) = ε0

Hoewel Cantor zijn beroemde diagonale argument toonde in een van E(r,ω,11) afhankelijke radix r=11, zijn er met behulp van supermachten *...[*#c c>11] en verder met steeds meer parameters, dimensies, typen, cycli, etc. uit de hoge hoed van bigE steeds weer diepere getallen tussen eerdere getallen in te toveren. De cardinaliteit van het continuüm is een orde hoger dan die van de discrete oneindige getallen van bigE... met {1,-,ω} als entiteiten.

Daarom postuleren we naast de 'telbare eindigheid' 1 = ω0 en de telbare oneindigheid ω = ω1 een ontelbare oneindigheid ω11 die even groot is als de verzameling R van de ω-diepe getallen in E...() × {1,ω}
Deze (en volgende) vormen van oneindigheid tellen we met een functie bigEta en inductie:

Η() = 1
Η(1) = ω1 = ω
Η(11) = ω11
Η(a) = ωa
Η(1,1) = Η(Η(1)) = Η(ω) = ωω
Η(11,1) = Η(Η(11))
Η(1,11) = Η(Η(ω),1)
Η(a,b1) = Η(Η(a,b),b)
Η(α1,..,αμ,z1) = Η(J,...,z) [J#μ]  waar J = Η(α1,..,αμ,z)

Dit definieert de eerste rij parameters van bigEta. In het vervolg kunnen we dezelfde algoritmes toepassen als eerder beschreven bij bigE, zodat dimensies, typen, cycli, etc. ontstaan binnen een universum van oneindige operator-functies Η...()

Een hoger model voor oneindigheid kunnen we definiëren met het getal zeta ζ, dat groter is dan ieder getal dat met Η...() te maken is en een operator functie bigZeta Ζ die (zoals Η met ωα) met ζα correspondeert:

Ζ() = 1
Ζ(1) = ζ1 = ω
Ζ(11) = ζ11 = ζ
Ζ(α) = ζα
Ζ(α1,..,αμ,z1) = Ζ(J,...,z) [J#μ]  waar J = Ζ(α1,..,αμ,z)

Omdat het aantal Griekse letters in ons αλφαβετ maximaal oneindig is, is de lengte van deze oneindigheid-functie-cyclus dat ook.
Hoewel Kanamori [AK] schrijft dat 1=0 de finale entiteit in de wiskunde is (waarna het onderhavige axiomatische systeem met donderend geraas in elkaar stort), kan die positie nooit worden bereikt met de hierboven geschetste oneindige inductieve methodes (die kloppen).
We zouden 1=0 kunnen postuleren om ons vervolgens af te vragen of er een hoger getal is (een ergere fout?). Daarvoor hebben we (n)iets nodig dat fundamenteler (nulliger?) is dan onze nul: 0 =
Misschien voldoet een getal dat alles kan zijn, zoals: 0;(0;-;11);1 = 0/0
Want wat is "Zijn" ?

# Mijn weblogs over Grote getallen

# Books on numbers and sets

Niettemin, na op die manier ontelbare aantallen leerlingen wiskunde geleerd te hebben moet ik overwegen: geen enkele leerling heeft wiskunde geleerd. Waarom?

Photograph in an empty Amsterdam tram vehicle